nusoap/lib/class.xmlschema.php

   1 <?php
   2
   3
   4
   5
   6 /**
   7 * parses an XML Schema, allows access to it's data, other utility methods.
   8 * imperfect, no validation... yet, but quite functional.
   9 *
  10 * @author   Dietrich Ayala <dietrich@ganx4.com>
  11 * @author   Scott Nichol <snichol@users.sourceforge.net>
  12 * @version  $Id: class.xmlschema.php,v 1.53 2010/04/26 20:15:08 snichol Exp $
  13 * @access   public
  14 */
  15 class nusoap_xmlschema extends nusoap_base  {
  16
  17         // files
  18         var $schema = '';
  19         var $xml = '';
  20         // namespaces
  21         var $enclosingNamespaces;
  22         // schema info
  23         var $schemaInfo = array();
  24         var $schemaTargetNamespace = '';
  25         // types, elements, attributes defined by the schema
  26         var $attributes = array();
  27         var $complexTypes = array();
  28         var $complexTypeStack = array();
  29         var $currentComplexType = null;
  30         var $elements = array();
  31         var $elementStack = array();
  32         var $currentElement = null;
  33         var $simpleTypes = array();
  34         var $simpleTypeStack = array();
  35         var $currentSimpleType = null;
  36         // imports
  37         var $imports = array();
  38         // parser vars
  39         var $parser;
  40         var $position = 0;
  41         var $depth = 0;
  42         var $depth_array = array();
  43         var $message = array();
  44         var $defaultNamespace = array();
  45
  46         /**
  47         * constructor
  48         *
  49         * @param    string $schema schema document URI
  50         * @param    string $xml xml document URI
  51         * @param        string $namespaces namespaces defined in enclosing XML
  52         * @access   public
  53         */
  54         function nusoap_xmlschema($schema='',$xml='',$namespaces=array()){
  55                 parent::nusoap_base();
  56                 $this->debug('nusoap_xmlschema class instantiated, inside constructor');
  57                 // files
  58                 $this->schema = $schema;
  59                 $this->xml = $xml;
  60
  61                 // namespaces
  62                 $this->enclosingNamespaces = $namespaces;
  63                 $this->namespaces = array_merge($this->namespaces, $namespaces);
  64
  65                 // parse schema file
  66                 if($schema != ''){
  67                         $this->debug('initial schema file: '.$schema);
  68                         $this->parseFile($schema, 'schema');
  69                 }
  70
  71                 // parse xml file
  72                 if($xml != ''){
  73                         $this->debug('initial xml file: '.$xml);
  74                         $this->parseFile($xml, 'xml');
  75                 }
  76
  77         }
  78
  79     /**
  80     * parse an XML file
  81     *
  82     * @param string $xml path/URL to XML file
  83     * @param string $type (schema | xml)
  84         * @return boolean
  85     * @access public
  86     */
  87         function parseFile($xml,$type){
  88                 // parse xml file
  89                 if($xml != ""){
  90                         $xmlStr = @join("",@file($xml));
  91                         if($xmlStr == ""){
  92                                 $msg = 'Error reading XML from '.$xml;
  93                                 $this->setError($msg);
  94                                 $this->debug($msg);
  95                         return false;
  96                         } else {
  97                                 $this->debug("parsing $xml");
  98                                 $this->parseString($xmlStr,$type);
  99                                 $this->debug("done parsing $xml");
 100                         return true;
 101                         }
 102                 }
 103                 return false;
 104         }
 105
 106         /**
 107         * parse an XML string
 108         *
 109         * @param    string $xml path or URL
 110     * @param    string $type (schema|xml)
 111         * @access   private
 112         */
 113         function parseString($xml,$type){
 114                 // parse xml string
 115                 if($xml != ""){
 116
 117                 // Create an XML parser.
 118                 $this->parser = xml_parser_create();
 119                 // Set the options for parsing the XML data.
 120                 xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, 0);
 121
 122                 // Set the object for the parser.
 123                 xml_set_object($this->parser, $this);
 124
 125                 // Set the element handlers for the parser.
 126                         if($type == "schema"){
 127                         xml_set_element_handler($this->parser, 'schemaStartElement','schemaEndElement');
 128                         xml_set_character_data_handler($this->parser,'schemaCharacterData');
 129                         } elseif($type == "xml"){
 130                                 xml_set_element_handler($this->parser, 'xmlStartElement','xmlEndElement');
 131                         xml_set_character_data_handler($this->parser,'xmlCharacterData');
 132                         }
 133
 134                     // Parse the XML file.
 135                     if(!xml_parse($this->parser,$xml,true)){
 136                         // Display an error message.
 137                                 $errstr = sprintf('XML error parsing XML schema on line %d: %s',
 138                                 xml_get_current_line_number($this->parser),
 139                                 xml_error_string(xml_get_error_code($this->parser))
 140                                 );
 141                                 $this->debug($errstr);
 142                                 $this->debug("XML payload:\n" . $xml);
 143                                 $this->setError($errstr);
 144                 }
 145
 146                         xml_parser_free($this->parser);
 147                 } else{
 148                         $this->debug('no xml passed to parseString()!!');
 149                         $this->setError('no xml passed to parseString()!!');
 150                 }
 151         }
 152
 153         /**
 154          * gets a type name for an unnamed type
 155          *
 156          * @param       string  Element name
 157          * @return      string  A type name for an unnamed type
 158          * @access      private
 159          */
 160         function CreateTypeName($ename) {
 161                 $scope = '';
 162                 for ($i = 0; $i < count($this->complexTypeStack); $i++) {
 163                         $scope .= $this->complexTypeStack[$i] . '_';
 164                 }
 165                 return $scope . $ename . '_ContainedType';
 166         }
 167
 168         /**
 169         * start-element handler
 170         *
 171         * @param    string $parser XML parser object
 172         * @param    string $name element name
 173         * @param    string $attrs associative array of attributes
 174         * @access   private
 175         */
 176         function schemaStartElement($parser, $name, $attrs) {
 177
 178                 // position in the total number of elements, starting from 0
 179                 $pos = $this->position++;
 180                 $depth = $this->depth++;
 181                 // set self as current value for this depth
 182                 $this->depth_array[$depth] = $pos;
 183                 $this->message[$pos] = array('cdata' => '');
 184                 if ($depth > 0) {
 185                         $this->defaultNamespace[$pos] = $this->defaultNamespace[$this->depth_array[$depth - 1]];
 186                 } else {
 187                         $this->defaultNamespace[$pos] = false;
 188                 }
 189
 190                 // get element prefix
 191                 if($prefix = $this->getPrefix($name)){
 192                         // get unqualified name
 193                         $name = $this->getLocalPart($name);
 194                 } else {
 195                 $prefix = '';
 196         }
 197
 198         // loop thru attributes, expanding, and registering namespace declarations
 199         if(count($attrs) > 0){
 200                 foreach($attrs as $k => $v){
 201                 // if ns declarations, add to class level array of valid namespaces
 202                                 if(preg_match('/^xmlns/',$k)){
 203                         //$this->xdebug("$k: $v");
 204                         //$this->xdebug('ns_prefix: '.$this->getPrefix($k));
 205                         if($ns_prefix = substr(strrchr($k,':'),1)){
 206                                 //$this->xdebug("Add namespace[$ns_prefix] = $v");
 207                                                 $this->namespaces[$ns_prefix] = $v;
 208                                         } else {
 209                                                 $this->defaultNamespace[$pos] = $v;
 210                                                 if (! $this->getPrefixFromNamespace($v)) {
 211                                                         $this->namespaces['ns'.(count($this->namespaces)+1)] = $v;
 212                                                 }
 213                                         }
 214                                         if($v == 'http://www.w3.org/2001/XMLSchema' || $v == 'http://www.w3.org/1999/XMLSchema' || $v == 'http://www.w3.org/2000/10/XMLSchema'){
 215                                                 $this->XMLSchemaVersion = $v;
 216                                                 $this->namespaces['xsi'] = $v.'-instance';
 217                                         }
 218                                 }
 219                 }
 220                 foreach($attrs as $k => $v){
 221                 // expand each attribute
 222                 $k = strpos($k,':') ? $this->expandQname($k) : $k;
 223                 $v = strpos($v,':') ? $this->expandQname($v) : $v;
 224                         $eAttrs[$k] = $v;
 225                 }
 226                 $attrs = $eAttrs;
 227         } else {
 228                 $attrs = array();
 229         }
 230                 // find status, register data
 231                 switch($name){
 232                         case 'all':                     // (optional) compositor content for a complexType
 233                         case 'choice':
 234                         case 'group':
 235                         case 'sequence':
 236                                 //$this->xdebug("compositor $name for currentComplexType: $this->currentComplexType and currentElement: $this->currentElement");
 237                                 $this->complexTypes[$this->currentComplexType]['compositor'] = $name;
 238                                 //if($name == 'all' || $name == 'sequence'){
 239                                 //      $this->complexTypes[$this->currentComplexType]['phpType'] = 'struct';
 240                                 //}
 241                         break;
 242                         case 'attribute':       // complexType attribute
 243                 //$this->xdebug("parsing attribute $attrs[name] $attrs[ref] of value: ".$attrs['http://schemas.xmlsoap.org/wsdl/:arrayType']);
 244                 $this->xdebug("parsing attribute:");
 245                 $this->appendDebug($this->varDump($attrs));
 246                                 if (!isset($attrs['form'])) {
 247                                         // TODO: handle globals
 248                                         $attrs['form'] = $this->schemaInfo['attributeFormDefault'];
 249                                 }
 250                 if (isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'])) {
 251                                         $v = $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'];
 252                                         if (!strpos($v, ':')) {
 253                                                 // no namespace in arrayType attribute value...
 254                                                 if ($this->defaultNamespace[$pos]) {
 255                                                         // ...so use the default
 256                                                         $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'] = $this->defaultNamespace[$pos] . ':' . $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'];
 257                                                 }
 258                                         }
 259                 }
 260                 if(isset($attrs['name'])){
 261                                         $this->attributes[$attrs['name']] = $attrs;
 262                                         $aname = $attrs['name'];
 263                                 } elseif(isset($attrs['ref']) && $attrs['ref'] == 'http://schemas.xmlsoap.org/soap/encoding/:arrayType'){
 264                                         if (isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'])) {
 265                                 $aname = $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'];
 266                         } else {
 267                                 $aname = '';
 268                         }
 269                                 } elseif(isset($attrs['ref'])){
 270                                         $aname = $attrs['ref'];
 271                     $this->attributes[$attrs['ref']] = $attrs;
 272                                 }
 273
 274                                 if($this->currentComplexType){  // This should *always* be
 275                                         $this->complexTypes[$this->currentComplexType]['attrs'][$aname] = $attrs;
 276                                 }
 277                                 // arrayType attribute
 278                                 if(isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType']) || $this->getLocalPart($aname) == 'arrayType'){
 279                                         $this->complexTypes[$this->currentComplexType]['phpType'] = 'array';
 280                         $prefix = $this->getPrefix($aname);
 281                                         if(isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'])){
 282                                                 $v = $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'];
 283                                         } else {
 284                                                 $v = '';
 285                                         }
 286                     if(strpos($v,'[,]')){
 287                         $this->complexTypes[$this->currentComplexType]['multidimensional'] = true;
 288                     }
 289                     $v = substr($v,0,strpos($v,'[')); // clip the []
 290                     if(!strpos($v,':') && isset($this->typemap[$this->XMLSchemaVersion][$v])){
 291                         $v = $this->XMLSchemaVersion.':'.$v;
 292                     }
 293                     $this->complexTypes[$this->currentComplexType]['arrayType'] = $v;
 294                                 }
 295                         break;
 296                         case 'complexContent':  // (optional) content for a complexType
 297                                 $this->xdebug("do nothing for element $name");
 298                         break;
 299                         case 'complexType':
 300                                 array_push($this->complexTypeStack, $this->currentComplexType);
 301                                 if(isset($attrs['name'])){
 302                                         // TODO: what is the scope of named complexTypes that appear
 303                                         //       nested within other c complexTypes?
 304                                         $this->xdebug('processing named complexType '.$attrs['name']);
 305                                         //$this->currentElement = false;
 306                                         $this->currentComplexType = $attrs['name'];
 307                                         $this->complexTypes[$this->currentComplexType] = $attrs;
 308                                         $this->complexTypes[$this->currentComplexType]['typeClass'] = 'complexType';
 309                                         // This is for constructs like
 310                                         //           <complexType name="ListOfString" base="soap:Array">
 311                                         //                <sequence>
 312                                         //                    <element name="string" type="xsd:string"
 313                                         //                        minOccurs="0" maxOccurs="unbounded" />
 314                                         //                </sequence>
 315                                         //            </complexType>
 316                                         if(isset($attrs['base']) && preg_match('/:Array$/',$attrs['base'])){
 317                                                 $this->xdebug('complexType is unusual array');
 318                                                 $this->complexTypes[$this->currentComplexType]['phpType'] = 'array';
 319                                         } else {
 320                                                 $this->complexTypes[$this->currentComplexType]['phpType'] = 'struct';
 321                                         }
 322                                 } else {
 323                                         $name = $this->CreateTypeName($this->currentElement);
 324                                         $this->xdebug('processing unnamed complexType for element ' . $this->currentElement . ' named ' . $name);
 325                                         $this->currentComplexType = $name;
 326                                         //$this->currentElement = false;
 327                                         $this->complexTypes[$this->currentComplexType] = $attrs;
 328                                         $this->complexTypes[$this->currentComplexType]['typeClass'] = 'complexType';
 329                                         // This is for constructs like
 330                                         //           <complexType name="ListOfString" base="soap:Array">
 331                                         //                <sequence>
 332                                         //                    <element name="string" type="xsd:string"
 333                                         //                        minOccurs="0" maxOccurs="unbounded" />
 334                                         //                </sequence>
 335                                         //            </complexType>
 336                                         if(isset($attrs['base']) && preg_match('/:Array$/',$attrs['base'])){
 337                                                 $this->xdebug('complexType is unusual array');
 338                                                 $this->complexTypes[$this->currentComplexType]['phpType'] = 'array';
 339                                         } else {
 340                                                 $this->complexTypes[$this->currentComplexType]['phpType'] = 'struct';
 341                                         }
 342                                 }
 343                                 $this->complexTypes[$this->currentComplexType]['simpleContent'] = 'false';
 344                         break;
 345                         case 'element':
 346                                 array_push($this->elementStack, $this->currentElement);
 347                                 if (!isset($attrs['form'])) {
 348                                         if ($this->currentComplexType) {
 349                                                 $attrs['form'] = $this->schemaInfo['elementFormDefault'];
 350                                         } else {
 351                                                 // global
 352                                                 $attrs['form'] = 'qualified';
 353                                         }
 354                                 }
 355                                 if(isset($attrs['type'])){
 356                                         $this->xdebug("processing typed element ".$attrs['name']." of type ".$attrs['type']);
 357                                         if (! $this->getPrefix($attrs['type'])) {
 358                                                 if ($this->defaultNamespace[$pos]) {
 359                                                         $attrs['type'] = $this->defaultNamespace[$pos] . ':' . $attrs['type'];
 360                                                         $this->xdebug('used default namespace to make type ' . $attrs['type']);
 361                                                 }
 362                                         }
 363                                         // This is for constructs like
 364                                         //           <complexType name="ListOfString" base="soap:Array">
 365                                         //                <sequence>
 366                                         //                    <element name="string" type="xsd:string"
 367                                         //                        minOccurs="0" maxOccurs="unbounded" />
 368                                         //                </sequence>
 369                                         //            </complexType>
 370                                         if ($this->currentComplexType && $this->complexTypes[$this->currentComplexType]['phpType'] == 'array') {
 371                                                 $this->xdebug('arrayType for unusual array is ' . $attrs['type']);
 372                                                 $this->complexTypes[$this->currentComplexType]['arrayType'] = $attrs['type'];
 373                                         }
 374                                         $this->currentElement = $attrs['name'];
 375                                         $ename = $attrs['name'];
 376                                 } elseif(isset($attrs['ref'])){
 377                                         $this->xdebug("processing element as ref to ".$attrs['ref']);
 378                                         $this->currentElement = "ref to ".$attrs['ref'];
 379                                         $ename = $this->getLocalPart($attrs['ref']);
 380                                 } else {
 381                                         $type = $this->CreateTypeName($this->currentComplexType . '_' . $attrs['name']);
 382                                         $this->xdebug("processing untyped element " . $attrs['name'] . ' type ' . $type);
 383                                         $this->currentElement = $attrs['name'];
 384                                         $attrs['type'] = $this->schemaTargetNamespace . ':' . $type;
 385                                         $ename = $attrs['name'];
 386                                 }
 387                                 if (isset($ename) && $this->currentComplexType) {
 388                                         $this->xdebug("add element $ename to complexType $this->currentComplexType");
 389                                         $this->complexTypes[$this->currentComplexType]['elements'][$ename] = $attrs;
 390                                 } elseif (!isset($attrs['ref'])) {
 391                                         $this->xdebug("add element $ename to elements array");
 392                                         $this->elements[ $attrs['name'] ] = $attrs;
 393                                         $this->elements[ $attrs['name'] ]['typeClass'] = 'element';
 394                                 }
 395                         break;
 396                         case 'enumeration':     //      restriction value list member
 397                                 $this->xdebug('enumeration ' . $attrs['value']);
 398                                 if ($this->currentSimpleType) {
 399                                         $this->simpleTypes[$this->currentSimpleType]['enumeration'][] = $attrs['value'];
 400                                 } elseif ($this->currentComplexType) {
 401                                         $this->complexTypes[$this->currentComplexType]['enumeration'][] = $attrs['value'];
 402                                 }
 403                         break;
 404                         case 'extension':       // simpleContent or complexContent type extension
 405                                 $this->xdebug('extension ' . $attrs['base']);
 406                                 if ($this->currentComplexType) {
 407                                         $ns = $this->getPrefix($attrs['base']);
 408                                         if ($ns == '') {
 409                                                 $this->complexTypes[$this->currentComplexType]['extensionBase'] = $this->schemaTargetNamespace . ':' . $attrs['base'];
 410                                         } else {
 411                                                 $this->complexTypes[$this->currentComplexType]['extensionBase'] = $attrs['base'];
 412                                         }
 413                                 } else {
 414                                         $this->xdebug('no current complexType to set extensionBase');
 415                                 }
 416                         break;
 417                         case 'import':
 418                             if (isset($attrs['schemaLocation'])) {
 419                                         $this->xdebug('import namespace ' . $attrs['namespace'] . ' from ' . $attrs['schemaLocation']);
 420                     $this->imports[$attrs['namespace']][] = array('location' => $attrs['schemaLocation'], 'loaded' => false);
 421                                 } else {
 422                                         $this->xdebug('import namespace ' . $attrs['namespace']);
 423                     $this->imports[$attrs['namespace']][] = array('location' => '', 'loaded' => true);
 424                                         if (! $this->getPrefixFromNamespace($attrs['namespace'])) {
 425                                                 $this->namespaces['ns'.(count($this->namespaces)+1)] = $attrs['namespace'];
 426                                         }
 427                                 }
 428                         break;
 429                         case 'include':
 430                             if (isset($attrs['schemaLocation'])) {
 431                                         $this->xdebug('include into namespace ' . $this->schemaTargetNamespace . ' from ' . $attrs['schemaLocation']);
 432                     $this->imports[$this->schemaTargetNamespace][] = array('location' => $attrs['schemaLocation'], 'loaded' => false);
 433                                 } else {
 434                                         $this->xdebug('ignoring invalid XML Schema construct: include without schemaLocation attribute');
 435                                 }
 436                         break;
 437                         case 'list':    // simpleType value list
 438                                 $this->xdebug("do nothing for element $name");
 439                         break;
 440                         case 'restriction':     // simpleType, simpleContent or complexContent value restriction
 441                                 $this->xdebug('restriction ' . $attrs['base']);
 442                                 if($this->currentSimpleType){
 443                                         $this->simpleTypes[$this->currentSimpleType]['type'] = $attrs['base'];
 444                                 } elseif($this->currentComplexType){
 445                                         $this->complexTypes[$this->currentComplexType]['restrictionBase'] = $attrs['base'];
 446                                         if(strstr($attrs['base'],':') == ':Array'){
 447                                                 $this->complexTypes[$this->currentComplexType]['phpType'] = 'array';
 448                                         }
 449                                 }
 450                         break;
 451                         case 'schema':
 452                                 $this->schemaInfo = $attrs;
 453                                 $this->schemaInfo['schemaVersion'] = $this->getNamespaceFromPrefix($prefix);
 454                                 if (isset($attrs['targetNamespace'])) {
 455                                         $this->schemaTargetNamespace = $attrs['targetNamespace'];
 456                                 }
 457                                 if (!isset($attrs['elementFormDefault'])) {
 458                                         $this->schemaInfo['elementFormDefault'] = 'unqualified';
 459                                 }
 460                                 if (!isset($attrs['attributeFormDefault'])) {
 461                                         $this->schemaInfo['attributeFormDefault'] = 'unqualified';
 462                                 }
 463                         break;
 464                         case 'simpleContent':   // (optional) content for a complexType
 465                                 if ($this->currentComplexType) {        // This should *always* be
 466                                         $this->complexTypes[$this->currentComplexType]['simpleContent'] = 'true';
 467                                 } else {
 468                                         $this->xdebug("do nothing for element $name because there is no current complexType");
 469                                 }
 470                         break;
 471                         case 'simpleType':
 472                                 array_push($this->simpleTypeStack, $this->currentSimpleType);
 473                                 if(isset($attrs['name'])){
 474                                         $this->xdebug("processing simpleType for name " . $attrs['name']);
 475                                         $this->currentSimpleType = $attrs['name'];
 476                                         $this->simpleTypes[ $attrs['name'] ] = $attrs;
 477                                         $this->simpleTypes[ $attrs['name'] ]['typeClass'] = 'simpleType';
 478                                         $this->simpleTypes[ $attrs['name'] ]['phpType'] = 'scalar';
 479                                 } else {
 480                                         $name = $this->CreateTypeName($this->currentComplexType . '_' . $this->currentElement);
 481                                         $this->xdebug('processing unnamed simpleType for element ' . $this->currentElement . ' named ' . $name);
 482                                         $this->currentSimpleType = $name;
 483                                         //$this->currentElement = false;
 484                                         $this->simpleTypes[$this->currentSimpleType] = $attrs;
 485                                         $this->simpleTypes[$this->currentSimpleType]['phpType'] = 'scalar';
 486                                 }
 487                         break;
 488                         case 'union':   // simpleType type list
 489                                 $this->xdebug("do nothing for element $name");
 490                         break;
 491                         default:
 492                                 $this->xdebug("do not have any logic to process element $name");
 493                 }
 494         }
 495
 496         /**
 497         * end-element handler
 498         *
 499         * @param    string $parser XML parser object
 500         * @param    string $name element name
 501         * @access   private
 502         */
 503         function schemaEndElement($parser, $name) {
 504                 // bring depth down a notch
 505                 $this->depth--;
 506                 // position of current element is equal to the last value left in depth_array for my depth
 507                 if(isset($this->depth_array[$this->depth])){
 508                 $pos = $this->depth_array[$this->depth];
 509         }
 510                 // get element prefix
 511                 if ($prefix = $this->getPrefix($name)){
 512                         // get unqualified name
 513                         $name = $this->getLocalPart($name);
 514                 } else {
 515                 $prefix = '';
 516         }
 517                 // move on...
 518                 if($name == 'complexType'){
 519                         $this->xdebug('done processing complexType ' . ($this->currentComplexType ? $this->currentComplexType : '(unknown)'));
 520                         $this->xdebug($this->varDump($this->complexTypes[$this->currentComplexType]));
 521                         $this->currentComplexType = array_pop($this->complexTypeStack);
 522                         //$this->currentElement = false;
 523                 }
 524                 if($name == 'element'){
 525                         $this->xdebug('done processing element ' . ($this->currentElement ? $this->currentElement : '(unknown)'));
 526                         $this->currentElement = array_pop($this->elementStack);
 527                 }
 528                 if($name == 'simpleType'){
 529                         $this->xdebug('done processing simpleType ' . ($this->currentSimpleType ? $this->currentSimpleType : '(unknown)'));
 530                         $this->xdebug($this->varDump($this->simpleTypes[$this->currentSimpleType]));
 531                         $this->currentSimpleType = array_pop($this->simpleTypeStack);
 532                 }
 533         }
 534
 535         /**
 536         * element content handler
 537         *
 538         * @param    string $parser XML parser object
 539         * @param    string $data element content
 540         * @access   private
 541         */
 542         function schemaCharacterData($parser, $data){
 543                 $pos = $this->depth_array[$this->depth - 1];
 544                 $this->message[$pos]['cdata'] .= $data;
 545         }
 546
 547         /**
 548         * serialize the schema
 549         *
 550         * @access   public
 551         */
 552         function serializeSchema(){
 553
 554                 $schemaPrefix = $this->getPrefixFromNamespace($this->XMLSchemaVersion);
 555                 $xml = '';
 556                 // imports
 557                 if (sizeof($this->imports) > 0) {
 558                         foreach($this->imports as $ns => $list) {
 559                                 foreach ($list as $ii) {
 560                                         if ($ii['location'] != '') {
 561                                                 $xml .= " <$schemaPrefix:import location=\"" . $ii['location'] . '" namespace="' . $ns . "\" />\n";
 562                                         } else {
 563                                                 $xml .= " <$schemaPrefix:import namespace=\"" . $ns . "\" />\n";
 564                                         }
 565                                 }
 566                         }
 567                 }
 568                 // complex types
 569                 foreach($this->complexTypes as $typeName => $attrs){
 570                         $contentStr = '';
 571                         // serialize child elements
 572                         if(isset($attrs['elements']) && (count($attrs['elements']) > 0)){
 573                                 foreach($attrs['elements'] as $element => $eParts){
 574                                         if(isset($eParts['ref'])){
 575                                                 $contentStr .= "   <$schemaPrefix:element ref=\"$element\"/>\n";
 576                                         } else {
 577                                                 $contentStr .= "   <$schemaPrefix:element name=\"$element\" type=\"" . $this->contractQName($eParts['type']) . "\"";
 578                                                 foreach ($eParts as $aName => $aValue) {
 579                                                         // handle, e.g., abstract, default, form, minOccurs, maxOccurs, nillable
 580                                                         if ($aName != 'name' && $aName != 'type') {
 581                                                                 $contentStr .= " $aName=\"$aValue\"";
 582                                                         }
 583                                                 }
 584                                                 $contentStr .= "/>\n";
 585                                         }
 586                                 }
 587                                 // compositor wraps elements
 588                                 if (isset($attrs['compositor']) && ($attrs['compositor'] != '')) {
 589                                         $contentStr = "  <$schemaPrefix:$attrs[compositor]>\n".$contentStr."  </$schemaPrefix:$attrs[compositor]>\n";
 590                                 }
 591                         }
 592                         // attributes
 593                         if(isset($attrs['attrs']) && (count($attrs['attrs']) >= 1)){
 594                                 foreach($attrs['attrs'] as $attr => $aParts){
 595                                         $contentStr .= "    <$schemaPrefix:attribute";
 596                                         foreach ($aParts as $a => $v) {
 597                                                 if ($a == 'ref' || $a == 'type') {
 598                                                         $contentStr .= " $a=\"".$this->contractQName($v).'"';
 599                                                 } elseif ($a == 'http://schemas.xmlsoap.org/wsdl/:arrayType') {
 600                                                         $this->usedNamespaces['wsdl'] = $this->namespaces['wsdl'];
 601                                                         $contentStr .= ' wsdl:arrayType="'.$this->contractQName($v).'"';
 602                                                 } else {
 603                                                         $contentStr .= " $a=\"$v\"";
 604                                                 }
 605                                         }
 606                                         $contentStr .= "/>\n";
 607                                 }
 608                         }
 609                         // if restriction
 610                         if (isset($attrs['restrictionBase']) && $attrs['restrictionBase'] != ''){
 611                                 $contentStr = "   <$schemaPrefix:restriction base=\"".$this->contractQName($attrs['restrictionBase'])."\">\n".$contentStr."   </$schemaPrefix:restriction>\n";
 612                                 // complex or simple content
 613                                 if ((isset($attrs['elements']) && count($attrs['elements']) > 0) || (isset($attrs['attrs']) && count($attrs['attrs']) > 0)){
 614                                         $contentStr = "  <$schemaPrefix:complexContent>\n".$contentStr."  </$schemaPrefix:complexContent>\n";
 615                                 }
 616                         }
 617                         // finalize complex type
 618                         if($contentStr != ''){
 619                                 $contentStr = " <$schemaPrefix:complexType name=\"$typeName\">\n".$contentStr." </$schemaPrefix:complexType>\n";
 620                         } else {
 621                                 $contentStr = " <$schemaPrefix:complexType name=\"$typeName\"/>\n";
 622                         }
 623                         $xml .= $contentStr;
 624                 }
 625                 // simple types
 626                 if(isset($this->simpleTypes) && count($this->simpleTypes) > 0){
 627                         foreach($this->simpleTypes as $typeName => $eParts){
 628                                 $xml .= " <$schemaPrefix:simpleType name=\"$typeName\">\n  <$schemaPrefix:restriction base=\"".$this->contractQName($eParts['type'])."\">\n";
 629                                 if (isset($eParts['enumeration'])) {
 630                                         foreach ($eParts['enumeration'] as $e) {
 631                                                 $xml .= "  <$schemaPrefix:enumeration value=\"$e\"/>\n";
 632                                         }
 633                                 }
 634                                 $xml .= "  </$schemaPrefix:restriction>\n </$schemaPrefix:simpleType>";
 635                         }
 636                 }
 637                 // elements
 638                 if(isset($this->elements) && count($this->elements) > 0){
 639                         foreach($this->elements as $element => $eParts){
 640                                 $xml .= " <$schemaPrefix:element name=\"$element\" type=\"".$this->contractQName($eParts['type'])."\"/>\n";
 641                         }
 642                 }
 643                 // attributes
 644                 if(isset($this->attributes) && count($this->attributes) > 0){
 645                         foreach($this->attributes as $attr => $aParts){
 646                                 $xml .= " <$schemaPrefix:attribute name=\"$attr\" type=\"".$this->contractQName($aParts['type'])."\"\n/>";
 647                         }
 648                 }
 649                 // finish 'er up
 650                 $attr = '';
 651                 foreach ($this->schemaInfo as $k => $v) {
 652                         if ($k == 'elementFormDefault' || $k == 'attributeFormDefault') {
 653                                 $attr .= " $k=\"$v\"";
 654                         }
 655                 }
 656                 $el = "<$schemaPrefix:schema$attr targetNamespace=\"$this->schemaTargetNamespace\"\n";
 657                 foreach (array_diff($this->usedNamespaces, $this->enclosingNamespaces) as $nsp => $ns) {
 658                         $el .= " xmlns:$nsp=\"$ns\"";
 659                 }
 660                 $xml = $el . ">\n".$xml."</$schemaPrefix:schema>\n";
 661                 return $xml;
 662         }
 663
 664         /**
 665         * adds debug data to the clas level debug string
 666         *
 667         * @param    string $string debug data
 668         * @access   private
 669         */
 670         function xdebug($string){
 671                 $this->debug('<' . $this->schemaTargetNamespace . '> '.$string);
 672         }
 673
 674     /**
 675     * get the PHP type of a user defined type in the schema
 676     * PHP type is kind of a misnomer since it actually returns 'struct' for assoc. arrays
 677     * returns false if no type exists, or not w/ the given namespace
 678     * else returns a string that is either a native php type, or 'struct'
 679     *
 680     * @param string $type name of defined type
 681     * @param string $ns namespace of type
 682     * @return mixed
 683     * @access public
 684     * @deprecated
 685     */
 686         function getPHPType($type,$ns){
 687                 if(isset($this->typemap[$ns][$type])){
 688                         //print "found type '$type' and ns $ns in typemap<br>";
 689                         return $this->typemap[$ns][$type];
 690                 } elseif(isset($this->complexTypes[$type])){
 691                         //print "getting type '$type' and ns $ns from complexTypes array<br>";
 692                         return $this->complexTypes[$type]['phpType'];
 693                 }
 694                 return false;
 695         }
 696
 697         /**
 698     * returns an associative array of information about a given type
 699     * returns false if no type exists by the given name
 700     *
 701         *       For a complexType typeDef = array(
 702         *       'restrictionBase' => '',
 703         *       'phpType' => '',
 704         *       'compositor' => '(sequence|all)',
 705         *       'elements' => array(), // refs to elements array
 706         *       'attrs' => array() // refs to attributes array
 707         *       ... and so on (see addComplexType)
 708         *       )
 709         *
 710         *   For simpleType or element, the array has different keys.
 711     *
 712     * @param string $type
 713     * @return mixed
 714     * @access public
 715     * @see addComplexType
 716     * @see addSimpleType
 717     * @see addElement
 718     */
 719         function getTypeDef($type){
 720                 //$this->debug("in getTypeDef for type $type");
 721                 if (substr($type, -1) == '^') {
 722                         $is_element = 1;
 723                         $type = substr($type, 0, -1);
 724                 } else {
 725                         $is_element = 0;
 726                 }
 727
 728                 if((! $is_element) && isset($this->complexTypes[$type])){
 729                         $this->xdebug("in getTypeDef, found complexType $type");
 730                         return $this->complexTypes[$type];
 731                 } elseif((! $is_element) && isset($this->simpleTypes[$type])){
 732                         $this->xdebug("in getTypeDef, found simpleType $type");
 733                         if (!isset($this->simpleTypes[$type]['phpType'])) {
 734                                 // get info for type to tack onto the simple type
 735                                 // TODO: can this ever really apply (i.e. what is a simpleType really?)
 736                                 $uqType = substr($this->simpleTypes[$type]['type'], strrpos($this->simpleTypes[$type]['type'], ':') + 1);
 737                                 $ns = substr($this->simpleTypes[$type]['type'], 0, strrpos($this->simpleTypes[$type]['type'], ':'));
 738                                 $etype = $this->getTypeDef($uqType);
 739                                 if ($etype) {
 740                                         $this->xdebug("in getTypeDef, found type for simpleType $type:");
 741                                         $this->xdebug($this->varDump($etype));
 742                                         if (isset($etype['phpType'])) {
 743                                                 $this->simpleTypes[$type]['phpType'] = $etype['phpType'];
 744                                         }
 745                                         if (isset($etype['elements'])) {
 746                                                 $this->simpleTypes[$type]['elements'] = $etype['elements'];
 747                                         }
 748                                 }
 749                         }
 750                         return $this->simpleTypes[$type];
 751                 } elseif(isset($this->elements[$type])){
 752                         $this->xdebug("in getTypeDef, found element $type");
 753                         if (!isset($this->elements[$type]['phpType'])) {
 754                                 // get info for type to tack onto the element
 755                                 $uqType = substr($this->elements[$type]['type'], strrpos($this->elements[$type]['type'], ':') + 1);
 756                                 $ns = substr($this->elements[$type]['type'], 0, strrpos($this->elements[$type]['type'], ':'));
 757                                 $etype = $this->getTypeDef($uqType);
 758                                 if ($etype) {
 759                                         $this->xdebug("in getTypeDef, found type for element $type:");
 760                                         $this->xdebug($this->varDump($etype));
 761                                         if (isset($etype['phpType'])) {
 762                                                 $this->elements[$type]['phpType'] = $etype['phpType'];
 763                                         }
 764                                         if (isset($etype['elements'])) {
 765                                                 $this->elements[$type]['elements'] = $etype['elements'];
 766                                         }
 767                                         if (isset($etype['extensionBase'])) {
 768                                                 $this->elements[$type]['extensionBase'] = $etype['extensionBase'];
 769                                         }
 770                                 } elseif ($ns == 'http://www.w3.org/2001/XMLSchema') {
 771                                         $this->xdebug("in getTypeDef, element $type is an XSD type");
 772                                         $this->elements[$type]['phpType'] = 'scalar';
 773                                 }
 774                         }
 775                         return $this->elements[$type];
 776                 } elseif(isset($this->attributes[$type])){
 777                         $this->xdebug("in getTypeDef, found attribute $type");
 778                         return $this->attributes[$type];
 779                 } elseif (preg_match('/_ContainedType$/', $type)) {
 780                         $this->xdebug("in getTypeDef, have an untyped element $type");
 781                         $typeDef['typeClass'] = 'simpleType';
 782                         $typeDef['phpType'] = 'scalar';
 783                         $typeDef['type'] = 'http://www.w3.org/2001/XMLSchema:string';
 784                         return $typeDef;
 785                 }
 786                 $this->xdebug("in getTypeDef, did not find $type");
 787                 return false;
 788         }
 789
 790         /**
 791     * returns a sample serialization of a given type, or false if no type by the given name
 792     *
 793     * @param string $type name of type
 794     * @return mixed
 795     * @access public
 796     * @deprecated
 797     */
 798     function serializeTypeDef($type){
 799         //print "in sTD() for type $type<br>";
 800         if($typeDef = $this->getTypeDef($type)){
 801                 $str .= '<'.$type;
 802             if(is_array($typeDef['attrs'])){
 803                 foreach($typeDef['attrs'] as $attName => $data){
 804                     $str .= " $attName=\"{type = ".$data['type']."}\"";
 805                 }
 806             }
 807             $str .= " xmlns=\"".$this->schema['targetNamespace']."\"";
 808             if(count($typeDef['elements']) > 0){
 809                 $str .= ">";
 810                 foreach($typeDef['elements'] as $element => $eData){
 811                     $str .= $this->serializeTypeDef($element);
 812                 }
 813                 $str .= "</$type>";
 814             } elseif($typeDef['typeClass'] == 'element') {
 815                 $str .= "></$type>";
 816             } else {
 817                 $str .= "/>";
 818             }
 819                         return $str;
 820         }
 821         return false;
 822     }
 823
 824     /**
 825     * returns HTML form elements that allow a user
 826     * to enter values for creating an instance of the given type.
 827     *
 828     * @param string $name name for type instance
 829     * @param string $type name of type
 830     * @return string
 831     * @access public
 832     * @deprecated
 833         */
 834         function typeToForm($name,$type){
 835                 // get typedef
 836                 if($typeDef = $this->getTypeDef($type)){
 837                         // if struct
 838                         if($typeDef['phpType'] == 'struct'){
 839                                 $buffer .= '<table>';
 840                                 foreach($typeDef['elements'] as $child => $childDef){
 841                                         $buffer .= "
 842                                         <tr><td align='right'>$childDef[name] (type: ".$this->getLocalPart($childDef['type'])."):</td>
 843                                         <td><input type='text' name='parameters[".$name."][$childDef[name]]'></td></tr>";
 844                                 }
 845                                 $buffer .= '</table>';
 846                         // if array
 847                         } elseif($typeDef['phpType'] == 'array'){
 848                                 $buffer .= '<table>';
 849                                 for($i=0;$i < 3; $i++){
 850                                         $buffer .= "
 851                                         <tr><td align='right'>array item (type: $typeDef[arrayType]):</td>
 852                                         <td><input type='text' name='parameters[".$name."][]'></td></tr>";
 853                                 }
 854                                 $buffer .= '</table>';
 855                         // if scalar
 856                         } else {
 857                                 $buffer .= "<input type='text' name='parameters[$name]'>";
 858                         }
 859                 } else {
 860                         $buffer .= "<input type='text' name='parameters[$name]'>";
 861                 }
 862                 return $buffer;
 863         }
 864
 865         /**
 866         * adds a complex type to the schema
 867         *
 868         * example: array
 869         *
 870         * addType(
 871         *       'ArrayOfstring',
 872         *       'complexType',
 873         *       'array',
 874         *       '',
 875         *       'SOAP-ENC:Array',
 876         *       array('ref'=>'SOAP-ENC:arrayType','wsdl:arrayType'=>'string[]'),
 877         *       'xsd:string'
 878         * );
 879         *
 880         * example: PHP associative array ( SOAP Struct )
 881         *
 882         * addType(
 883         *       'SOAPStruct',
 884         *       'complexType',
 885         *       'struct',
 886         *       'all',
 887         *       array('myVar'=> array('name'=>'myVar','type'=>'string')
 888         * );
 889         *
 890         * @param name
 891         * @param typeClass (complexType|simpleType|attribute)
 892         * @param phpType: currently supported are array and struct (php assoc array)
 893         * @param compositor (all|sequence|choice)
 894         * @param restrictionBase namespace:name (http://schemas.xmlsoap.org/soap/encoding/:Array)
 895         * @param elements = array ( name = array(name=>'',type=>'') )
 896         * @param attrs = array(
 897         *       array(
 898         *               'ref' => "http://schemas.xmlsoap.org/soap/encoding/:arrayType",
 899         *               "http://schemas.xmlsoap.org/wsdl/:arrayType" => "string[]"
 900         *       )
 901         * )
 902         * @param arrayType: namespace:name (http://www.w3.org/2001/XMLSchema:string)
 903         * @access public
 904         * @see getTypeDef
 905         */
 906         function addComplexType($name,$typeClass='complexType',$phpType='array',$compositor='',$restrictionBase='',$elements=array(),$attrs=array(),$arrayType=''){
 907                 $this->complexTypes[$name] = array(
 908             'name'              => $name,
 909             'typeClass' => $typeClass,
 910             'phpType'   => $phpType,
 911                 'compositor'=> $compositor,
 912             'restrictionBase' => $restrictionBase,
 913                 'elements'      => $elements,
 914             'attrs'             => $attrs,
 915             'arrayType' => $arrayType
 916                 );
 917
 918                 $this->xdebug("addComplexType $name:");
 919                 $this->appendDebug($this->varDump($this->complexTypes[$name]));
 920         }
 921
 922         /**
 923         * adds a simple type to the schema
 924         *
 925         * @param string $name
 926         * @param string $restrictionBase namespace:name (http://schemas.xmlsoap.org/soap/encoding/:Array)
 927         * @param string $typeClass (should always be simpleType)
 928         * @param string $phpType (should always be scalar)
 929         * @param array $enumeration array of values
 930         * @access public
 931         * @see nusoap_xmlschema
 932         * @see getTypeDef
 933         */
 934         function addSimpleType($name, $restrictionBase='', $typeClass='simpleType', $phpType='scalar', $enumeration=array()) {
 935                 $this->simpleTypes[$name] = array(
 936             'name'                      => $name,
 937             'typeClass'         => $typeClass,
 938             'phpType'           => $phpType,
 939             'type'                      => $restrictionBase,
 940             'enumeration'       => $enumeration
 941                 );
 942
 943                 $this->xdebug("addSimpleType $name:");
 944                 $this->appendDebug($this->varDump($this->simpleTypes[$name]));
 945         }
 946
 947         /**
 948         * adds an element to the schema
 949         *
 950         * @param array $attrs attributes that must include name and type
 951         * @see nusoap_xmlschema
 952         * @access public
 953         */
 954         function addElement($attrs) {
 955                 if (! $this->getPrefix($attrs['type'])) {
 956                         $attrs['type'] = $this->schemaTargetNamespace . ':' . $attrs['type'];
 957                 }
 958                 $this->elements[ $attrs['name'] ] = $attrs;
 959                 $this->elements[ $attrs['name'] ]['typeClass'] = 'element';
 960
 961                 $this->xdebug("addElement " . $attrs['name']);
 962                 $this->appendDebug($this->varDump($this->elements[ $attrs['name'] ]));
 963         }
 964 }
 965
 966 /**
 967  * Backward compatibility
 968  */
 969 class XMLSchema extends nusoap_xmlschema {
 970 }
 971
 972
 973 ?>