jdk8-mips64-public/jaxws: src/share/jaxws_classes/com/sun/tools/internal/ws/wsdl/parser/WSDLParser.java@9c07ef4934dd

     1 /*

     2  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    26 package com.sun.tools.internal.ws.wsdl.parser;

    28 import com.sun.tools.internal.ws.api.wsdl.TWSDLExtensible;

    29 import com.sun.tools.internal.ws.api.wsdl.TWSDLExtensionHandler;

    30 import com.sun.tools.internal.ws.resources.WsdlMessages;

    31 import com.sun.tools.internal.ws.util.xml.XmlUtil;

    32 import com.sun.tools.internal.ws.wscompile.ErrorReceiverFilter;

    33 import com.sun.tools.internal.ws.wscompile.WsimportOptions;

    34 import com.sun.tools.internal.ws.wsdl.document.Binding;

    35 import com.sun.tools.internal.ws.wsdl.document.BindingFault;

    36 import com.sun.tools.internal.ws.wsdl.document.BindingInput;

    37 import com.sun.tools.internal.ws.wsdl.document.BindingOperation;

    38 import com.sun.tools.internal.ws.wsdl.document.BindingOutput;

    39 import com.sun.tools.internal.ws.wsdl.document.Definitions;

    40 import com.sun.tools.internal.ws.wsdl.document.Documentation;

    41 import com.sun.tools.internal.ws.wsdl.document.Fault;

    42 import com.sun.tools.internal.ws.wsdl.document.Import;

    43 import com.sun.tools.internal.ws.wsdl.document.Input;

    44 import com.sun.tools.internal.ws.wsdl.document.Message;

    45 import com.sun.tools.internal.ws.wsdl.document.MessagePart;

    46 import com.sun.tools.internal.ws.wsdl.document.Operation;

    47 import com.sun.tools.internal.ws.wsdl.document.OperationStyle;

    48 import com.sun.tools.internal.ws.wsdl.document.Output;

    49 import com.sun.tools.internal.ws.wsdl.document.Port;

    50 import com.sun.tools.internal.ws.wsdl.document.PortType;

    51 import com.sun.tools.internal.ws.wsdl.document.Service;

    52 import com.sun.tools.internal.ws.wsdl.document.WSDLConstants;

    53 import com.sun.tools.internal.ws.wsdl.document.WSDLDocument;

    54 import com.sun.tools.internal.ws.wsdl.document.jaxws.JAXWSBindingsConstants;

    55 import com.sun.tools.internal.ws.wsdl.document.schema.SchemaConstants;

    56 import com.sun.tools.internal.ws.wsdl.document.schema.SchemaKinds;

    57 import com.sun.tools.internal.ws.wsdl.framework.Entity;

    58 import com.sun.tools.internal.ws.wsdl.framework.ParserListener;

    59 import com.sun.tools.internal.ws.wsdl.framework.TWSDLParserContextImpl;

    60 import com.sun.xml.internal.ws.util.ServiceFinder;

    61 import org.w3c.dom.Attr;

    62 import org.w3c.dom.Document;

    63 import org.w3c.dom.Element;

    64 import org.w3c.dom.NodeList;

    65 import org.xml.sax.InputSource;

    66 import org.xml.sax.Locator;

    67 import org.xml.sax.SAXException;

    69 import java.io.IOException;

    70 import java.util.ArrayList;

    71 import java.util.HashMap;

    72 import java.util.Iterator;

    73 import java.util.Map;

    74 import org.w3c.dom.Node;

    76 /**

    77  * A parser for WSDL documents. This parser is used only at the tool time.

    78  * Extensions should extend TWSDLExtensionHandler, so that it will be called during

    79  * parsing wsdl to handle wsdl extenisbility elements. Generally these extensions

    80  * will effect the artifacts generated during WSDL processing.

    81  *

    82  * @see com.sun.xml.internal.ws.wsdl.parser.RuntimeWSDLParser which will be used for WSDL parsing

    83  * at runtime.

    84  *

    85  * @author WS Development Team

    86  */

    87 public class WSDLParser {

    88     private final ErrorReceiverFilter errReceiver;

    89     private WsimportOptions options;

    91     //wsdl extension handlers

    92     private final Map extensionHandlers;

    93     private MetadataFinder forest;

    94     private ArrayList<ParserListener> listeners;

    96     public WSDLParser(WsimportOptions options, ErrorReceiverFilter errReceiver, MetadataFinder forest) {

    97         this.extensionHandlers = new HashMap();

    98         this.options = options;

    99         this.errReceiver = errReceiver;

   100         if (forest == null) {

   101             forest = new MetadataFinder(new WSDLInternalizationLogic(), options, errReceiver);

   102             forest.parseWSDL();

   103             if (forest.isMexMetadata) {

   104                 errReceiver.reset();

   105         }

   106         }

   107         this.forest = forest;

   108         // register handlers for default extensions

   109         register(new SOAPExtensionHandler(extensionHandlers));

   110         register(new HTTPExtensionHandler(extensionHandlers));

   111         register(new MIMEExtensionHandler(extensionHandlers));

   112         register(new JAXWSBindingExtensionHandler(extensionHandlers));

   113         register(new SOAP12ExtensionHandler(extensionHandlers));

   115         // MemberSubmission Addressing not supported by WsImport anymore see JAX_WS-1040 for details

   116         //register(new MemberSubmissionAddressingExtensionHandler(extensionHandlers, errReceiver, options.isExtensionMode()));

   118         register(new W3CAddressingExtensionHandler(extensionHandlers, errReceiver));

   119         register(new W3CAddressingMetadataExtensionHandler(extensionHandlers, errReceiver));

   120         register(new Policy12ExtensionHandler());

   121         register(new Policy15ExtensionHandler());

   122         for (TWSDLExtensionHandler te : ServiceFinder.find(TWSDLExtensionHandler.class)) {

   123             register(te);

   124         }

   126     }

   128     //TODO RK remove this after tests are fixed.

   129     WSDLParser(WsimportOptions options, ErrorReceiverFilter errReceiver) {

   130         this(options,errReceiver,null);

   131     }

   132     private void register(TWSDLExtensionHandler h) {

   133         extensionHandlers.put(h.getNamespaceURI(), h);

   134     }

   136     public void addParserListener(ParserListener l) {

   137         if (listeners == null) {

   138             listeners = new ArrayList<ParserListener>();

   139         }

   140         listeners.add(l);

   141     }

   143     public WSDLDocument parse() throws SAXException, IOException {

   144         // parse external binding files

   145         for (InputSource value : options.getWSDLBindings()) {

   146             errReceiver.pollAbort();

   147             Document root = forest.parse(value, false);

   148             if(root==null)       continue;   // error must have been reported

   149             Element binding = root.getDocumentElement();

   150             if (!Internalizer.fixNull(binding.getNamespaceURI()).equals(JAXWSBindingsConstants.NS_JAXWS_BINDINGS)

   151                     || !binding.getLocalName().equals("bindings")){

   152                     errReceiver.error(forest.locatorTable.getStartLocation(binding), WsdlMessages.PARSER_NOT_A_BINDING_FILE(

   153                         binding.getNamespaceURI(),

   154                         binding.getLocalName()));

   155                 continue;

   156             }

   158             NodeList nl = binding.getElementsByTagNameNS(

   159                 "http://java.sun.com/xml/ns/javaee", "handler-chains");

   160             for(int i = 0; i < nl.getLength(); i++){

   161                 options.addHandlerChainConfiguration((Element) nl.item(i));

   162             }

   164         }

   165         return buildWSDLDocument();

   166     }

   168     public MetadataFinder getDOMForest() {

   169         return forest;

   170     }

   172     private WSDLDocument buildWSDLDocument(){

   173         /**

   174          * Currently we are working off first WSDL document

   175          * TODO: add support of creating WSDLDocument from fromjava.collection of WSDL documents

   176          */

   178         String location = forest.getRootWSDL();

   180         //It means that WSDL is not found, an error might have been reported, lets try to recover

   181         if(location == null)

   182             return null;

   184         Document root = forest.get(location);

   186         if(root == null)

   187             return null;

   189         WSDLDocument document = new WSDLDocument(forest, errReceiver);

   190         document.setSystemId(location);

   191         TWSDLParserContextImpl context = new TWSDLParserContextImpl(forest, document, listeners, errReceiver);

   193         Definitions definitions = parseDefinitions(context, root);

   194         document.setDefinitions(definitions);

   195         return document;

   196     }

   198     private Definitions parseDefinitions(TWSDLParserContextImpl context, Document root) {

   199         context.pushWSDLLocation();

   200         context.setWSDLLocation(context.getDocument().getSystemId());

   202         new Internalizer(forest, options, errReceiver).transform();

   204         Definitions definitions = parseDefinitionsNoImport(context, root);

   205         if(definitions == null){

   206             Locator locator = forest.locatorTable.getStartLocation(root.getDocumentElement());

   207             errReceiver.error(locator, WsdlMessages.PARSING_NOT_AWSDL(locator.getSystemId()));

   209         }

   210         processImports(context);

   211         context.popWSDLLocation();

   212         return definitions;

   213     }

   215     private void processImports(TWSDLParserContextImpl context) {

   216         for(String location : forest.getExternalReferences()){

   217             if (!context.getDocument().isImportedDocument(location)){

   218                 Document doc = forest.get(location);

   219                 if(doc == null)

   220                     continue;

   221                 Definitions importedDefinitions = parseDefinitionsNoImport(context, doc);

   222                 if(importedDefinitions == null)

   223                     continue;

   224                 context.getDocument().addImportedEntity(importedDefinitions);

   225                 context.getDocument().addImportedDocument(location);

   226             }

   227         }

   228     }

   230     private Definitions parseDefinitionsNoImport(

   231         TWSDLParserContextImpl context,

   232         Document doc) {

   233         Element e = doc.getDocumentElement();

   234         //at this poinjt we expect a wsdl or schema document to be fully qualified

   235         if(e.getNamespaceURI() == null || (!e.getNamespaceURI().equals(WSDLConstants.NS_WSDL) || !e.getLocalName().equals("definitions"))){

   236             return null;

   237         }

   238         context.push();

   239         context.registerNamespaces(e);

   241         Definitions definitions = new Definitions(context.getDocument(), forest.locatorTable.getStartLocation(e));

   242         String name = XmlUtil.getAttributeOrNull(e, Constants.ATTR_NAME);

   243         definitions.setName(name);

   245         String targetNamespaceURI =

   246             XmlUtil.getAttributeOrNull(e, Constants.ATTR_TARGET_NAMESPACE);

   248         definitions.setTargetNamespaceURI(targetNamespaceURI);

   250         boolean gotDocumentation = false;

   251         boolean gotTypes = false;

   253         for (Iterator iter = XmlUtil.getAllChildren(e); iter.hasNext();) {

   254             Element e2 = Util.nextElement(iter);

   255             if (e2 == null)

   256                 break;

   258             if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_DOCUMENTATION)) {

   259                 if (gotDocumentation) {

   260                     errReceiver.error(forest.locatorTable.getStartLocation(e2), WsdlMessages.PARSING_ONLY_ONE_DOCUMENTATION_ALLOWED(e.getLocalName()));

   261                     return null;

   262                 }

   263                 gotDocumentation = true;

   264                 if(definitions.getDocumentation() == null)

   265                     definitions.setDocumentation(getDocumentationFor(e2));

   266             } else if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_TYPES)) {

   267                 if (gotTypes && !options.isExtensionMode()) {

   268                     errReceiver.error(forest.locatorTable.getStartLocation(e2), WsdlMessages.PARSING_ONLY_ONE_TYPES_ALLOWED(Constants.TAG_DEFINITIONS));

   269                     return null;

   270                 }

   271                 gotTypes = true;

   272                 //add all the wsdl:type elements to latter make a list of all the schema elements

   273                 // that will be needed to create jaxb model

   274                 if(!options.isExtensionMode())

   275                     validateSchemaImports(e2);

   276             } else if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_MESSAGE)) {

   277                 Message message = parseMessage(context, definitions, e2);

   278                 definitions.add(message);

   279             } else if (

   280                 XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_PORT_TYPE)) {

   281                 PortType portType = parsePortType(context, definitions, e2);

   282                 definitions.add(portType);

   283             } else if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_BINDING)) {

   284                 Binding binding = parseBinding(context, definitions, e2);

   285                 definitions.add(binding);

   286             } else if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_SERVICE)) {

   287                 Service service = parseService(context, definitions, e2);

   288                 definitions.add(service);

   289             } else if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_IMPORT)) {

   290                 definitions.add(parseImport(context, definitions, e2));

   291             } else if (XmlUtil.matchesTagNS(e2, SchemaConstants.QNAME_IMPORT)) {

   292                 errReceiver.warning(forest.locatorTable.getStartLocation(e2), WsdlMessages.WARNING_WSI_R_2003());

   293             } else {

   294                 // possible extensibility element -- must live outside the WSDL namespace

   295                 checkNotWsdlElement(e2);

   296                 if (!handleExtension(context, definitions, e2)) {

   297                     checkNotWsdlRequired(e2);

   298                 }

   299             }

   300         }

   302         context.pop();

   303         context.fireDoneParsingEntity(

   304             WSDLConstants.QNAME_DEFINITIONS,

   305             definitions);

   306         return definitions;

   307     }

   309     private Message parseMessage(

   310         TWSDLParserContextImpl context,

   311         Definitions definitions,

   312         Element e) {

   313         context.push();

   314         context.registerNamespaces(e);

   315         Message message = new Message(definitions, forest.locatorTable.getStartLocation(e), errReceiver);

   316         String name = Util.getRequiredAttribute(e, Constants.ATTR_NAME);

   317         message.setName(name);

   319         boolean gotDocumentation = false;

   321         for (Iterator iter = XmlUtil.getAllChildren(e); iter.hasNext();) {

   322             Element e2 = Util.nextElement(iter);

   323             if (e2 == null)

   324                 break;

   326             if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_DOCUMENTATION)) {

   327                 if (gotDocumentation) {

   328                     Util.fail(

   329                         "parsing.onlyOneDocumentationAllowed",

   330                         e.getLocalName());

   331                 }

   332                 gotDocumentation = true;

   333                 message.setDocumentation(getDocumentationFor(e2));

   334             } else if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_PART)) {

   335                 MessagePart part = parseMessagePart(context, e2);

   336                 message.add(part);

   337             } else {

   338                 //Ignore any extensibility elements, WS-I BP 1.1 Profiled WSDL 1.1 schema allows extension elements here.

   339                 /*Util.fail(

   340                     "parsing.invalidElement",

   341                     e2.getTagName(),

   342                     e2.getNamespaceURI());

   343                     */

   344             }

   345         }

   347         context.pop();

   348         context.fireDoneParsingEntity(WSDLConstants.QNAME_MESSAGE, message);

   349         return message;

   350     }

   352     private MessagePart parseMessagePart(TWSDLParserContextImpl context, Element e) {

   353         context.push();

   354         context.registerNamespaces(e);

   355         MessagePart part = new MessagePart(forest.locatorTable.getStartLocation(e));

   356         String partName = Util.getRequiredAttribute(e, Constants.ATTR_NAME);

   357         part.setName(partName);

   359         String elementAttr =

   360             XmlUtil.getAttributeOrNull(e, Constants.ATTR_ELEMENT);

   361         String typeAttr = XmlUtil.getAttributeOrNull(e, Constants.ATTR_TYPE);

   363         if (elementAttr != null) {

   364             if (typeAttr != null) {

   365                 errReceiver.error(context.getLocation(e), WsdlMessages.PARSING_ONLY_ONE_OF_ELEMENT_OR_TYPE_REQUIRED(partName));

   367             }

   369             part.setDescriptor(context.translateQualifiedName(context.getLocation(e), elementAttr));

   370             part.setDescriptorKind(SchemaKinds.XSD_ELEMENT);

   371         } else if (typeAttr != null) {

   372             part.setDescriptor(context.translateQualifiedName(context.getLocation(e), typeAttr));

   373             part.setDescriptorKind(SchemaKinds.XSD_TYPE);

   374         } else {

   375             // XXX-NOTE - this is wrong; for extensibility purposes,

   376             // any attribute can be specified on a <part> element, so

   377             // we need to put an extensibility hook here

   378             errReceiver.warning(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_ELEMENT_OR_TYPE_REQUIRED(partName));

   379         }

   381         context.pop();

   382         context.fireDoneParsingEntity(WSDLConstants.QNAME_PART, part);

   383         return part;

   384     }

   386     private PortType parsePortType(

   387         TWSDLParserContextImpl context,

   388         Definitions definitions,

   389         Element e) {

   390         context.push();

   391         context.registerNamespaces(e);

   392         PortType portType = new PortType(definitions, forest.locatorTable.getStartLocation(e), errReceiver);

   393         String name = Util.getRequiredAttribute(e, Constants.ATTR_NAME);

   394         portType.setName(name);

   396         boolean gotDocumentation = false;

   398         for (Iterator iter = XmlUtil.getAllChildren(e); iter.hasNext();) {

   399             Element e2 = Util.nextElement(iter);

   400             if (e2 == null)

   401                 break;

   403             if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_DOCUMENTATION)) {

   404                 if (gotDocumentation) {

   405                     errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_ONLY_ONE_DOCUMENTATION_ALLOWED(e.getLocalName()));

   406                 }

   407                 gotDocumentation = true;

   408                 if(portType.getDocumentation() == null)

   409                     portType.setDocumentation(getDocumentationFor(e2));

   410             } else if (

   411                 XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_OPERATION)) {

   412                 Operation op = parsePortTypeOperation(context, e2);

   413                 op.setParent(portType);

   414                 portType.add(op);

   415             } else {

   416                 // possible extensibility element -- must live outside the WSDL namespace

   417                 checkNotWsdlElement(e2);

   418                 if (!handleExtension(context, portType, e2)) {

   419                     checkNotWsdlRequired(e2);

   420                 }

   421             }/*else {

   422                 Util.fail(

   423                     "parsing.invalidElement",

   424                     e2.getTagName(),

   425                     e2.getNamespaceURI());

   426             }*/

   427         }

   429         context.pop();

   430         context.fireDoneParsingEntity(WSDLConstants.QNAME_PORT_TYPE, portType);

   431         return portType;

   432     }

   434     private Operation parsePortTypeOperation(

   435         TWSDLParserContextImpl context,

   436         Element e) {

   437         context.push();

   438         context.registerNamespaces(e);

   440         Operation operation = new Operation(forest.locatorTable.getStartLocation(e));

   441         String name = Util.getRequiredAttribute(e, Constants.ATTR_NAME);

   442         operation.setName(name);

   443         String parameterOrderAttr =

   444             XmlUtil.getAttributeOrNull(e, Constants.ATTR_PARAMETER_ORDER);

   445         operation.setParameterOrder(parameterOrderAttr);

   447         boolean gotDocumentation = false;

   449         boolean gotInput = false;

   450         boolean gotOutput = false;

   451         boolean gotFault = false;

   452         boolean inputBeforeOutput = false;

   454         for (Iterator iter = XmlUtil.getAllChildren(e); iter.hasNext();) {

   455             Element e2 = Util.nextElement(iter);

   456             if (e2 == null)

   457                 break;

   459             if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_DOCUMENTATION)) {

   460                 if (gotDocumentation) {

   461                     errReceiver.error(forest.locatorTable.getStartLocation(e2), WsdlMessages.PARSING_ONLY_ONE_DOCUMENTATION_ALLOWED(e2.getLocalName()));

   462                 }

   463                 gotDocumentation = true;

   464                 if(operation.getDocumentation() == null)

   465                     operation.setDocumentation(getDocumentationFor(e2));

   466             } else if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_INPUT)) {

   467                 if (gotInput) {

   468                     errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_TOO_MANY_ELEMENTS(Constants.TAG_INPUT,

   469                             Constants.TAG_OPERATION,

   470                             name));

   471                 }

   473                 context.push();

   474                 context.registerNamespaces(e2);

   475                 Input input = new Input(forest.locatorTable.getStartLocation(e2), errReceiver);

   476                 input.setParent(operation);

   477                 String messageAttr =

   478                     Util.getRequiredAttribute(e2, Constants.ATTR_MESSAGE);

   479                 input.setMessage(context.translateQualifiedName(context.getLocation(e2), messageAttr));

   480                 String nameAttr =

   481                     XmlUtil.getAttributeOrNull(e2, Constants.ATTR_NAME);

   482                 input.setName(nameAttr);

   483                 operation.setInput(input);

   484                 gotInput = true;

   485                 if (gotOutput) {

   486                     inputBeforeOutput = false;

   487                 }

   489                 // check for extensiblity attributes

   490                 for (Iterator iter2 = XmlUtil.getAllAttributes(e2);

   491                      iter2.hasNext();

   492                 ) {

   493                     Attr e3 = (Attr)iter2.next();

   494                     if (e3.getLocalName().equals(Constants.ATTR_MESSAGE) ||

   495                         e3.getLocalName().equals(Constants.ATTR_NAME))

   496                         continue;

   498                     // possible extensibility element -- must live outside the WSDL namespace

   499                     checkNotWsdlAttribute(e3);

   500                     handleExtension(context, input, e3, e2);

   501                 }

   503                 // verify that there is at most one child element and it is a documentation element

   504                 boolean gotDocumentation2 = false;

   505                 for (Iterator iter2 = XmlUtil.getAllChildren(e2);

   506                      iter2.hasNext();

   507                     ) {

   508                     Element e3 = Util.nextElement(iter2);

   509                     if (e3 == null)

   510                         break;

   512                     if (XmlUtil

   513                         .matchesTagNS(e3, WSDLConstants.QNAME_DOCUMENTATION)) {

   514                         if (gotDocumentation2) {

   515                             errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_ONLY_ONE_DOCUMENTATION_ALLOWED(e.getLocalName()));

   516                         }

   517                         gotDocumentation2 = true;

   518                         input.setDocumentation(getDocumentationFor(e3));

   519                     } else {

   520                         errReceiver.error(forest.locatorTable.getStartLocation(e3), WsdlMessages.PARSING_INVALID_ELEMENT(e3.getTagName(),

   521                             e3.getNamespaceURI()));

   522                     }

   523                 }

   524                 context.pop();

   525             } else if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_OUTPUT)) {

   526                 if (gotOutput) {

   527                     errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_TOO_MANY_ELEMENTS(Constants.TAG_INPUT,

   528                             Constants.TAG_OPERATION,

   529                             name));

   530                 }

   532                 context.push();

   533                 context.registerNamespaces(e2);

   534                 Output output = new Output(forest.locatorTable.getStartLocation(e2), errReceiver);

   535                 output.setParent(operation);

   536                 String messageAttr =

   537                     Util.getRequiredAttribute(e2, Constants.ATTR_MESSAGE);

   538                 output.setMessage(context.translateQualifiedName(context.getLocation(e2), messageAttr));

   539                 String nameAttr =

   540                     XmlUtil.getAttributeOrNull(e2, Constants.ATTR_NAME);

   541                 output.setName(nameAttr);

   542                 operation.setOutput(output);

   543                 gotOutput = true;

   544                 if (gotInput) {

   545                     inputBeforeOutput = true;

   546                 }

   548                 // check for extensiblity attributes

   549                 for (Iterator iter2 = XmlUtil.getAllAttributes(e2);

   550                      iter2.hasNext();

   551                 ) {

   552                     Attr e3 = (Attr)iter2.next();

   553                     if (e3.getLocalName().equals(Constants.ATTR_MESSAGE) ||

   554                         e3.getLocalName().equals(Constants.ATTR_NAME))

   555                         continue;

   557                     // possible extensibility element -- must live outside the WSDL namespace

   558                     checkNotWsdlAttribute(e3);

   559                     handleExtension(context, output, e3, e2);

   560                 }

   562                 // verify that there is at most one child element and it is a documentation element

   563                 boolean gotDocumentation2 = false;

   564                 for (Iterator iter2 = XmlUtil.getAllChildren(e2);

   565                      iter2.hasNext();

   566                     ) {

   567                     Element e3 = Util.nextElement(iter2);

   568                     if (e3 == null)

   569                         break;

   571                     if (XmlUtil

   572                         .matchesTagNS(e3, WSDLConstants.QNAME_DOCUMENTATION)) {

   573                         if (gotDocumentation2) {

   574                             errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_ONLY_ONE_DOCUMENTATION_ALLOWED(e.getLocalName()));

   575                         }

   576                         gotDocumentation2 = true;

   577                         output.setDocumentation(getDocumentationFor(e3));

   578                     } else {

   579                         errReceiver.error(forest.locatorTable.getStartLocation(e3), WsdlMessages.PARSING_INVALID_ELEMENT(e3.getTagName(),

   580                             e3.getNamespaceURI()));

   581                     }

   582                 }

   583                 context.pop();

   584             } else if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_FAULT)) {

   585                 context.push();

   586                 context.registerNamespaces(e2);

   587                 Fault fault = new Fault(forest.locatorTable.getStartLocation(e2));

   588                 fault.setParent(operation);

   589                 String messageAttr =

   590                     Util.getRequiredAttribute(e2, Constants.ATTR_MESSAGE);

   591                 fault.setMessage(context.translateQualifiedName(context.getLocation(e2), messageAttr));

   592                 String nameAttr =

   593                     XmlUtil.getAttributeOrNull(e2, Constants.ATTR_NAME);

   594                 fault.setName(nameAttr);

   595                 operation.addFault(fault);

   596                 gotFault = true;

   598                 // check for extensiblity attributes

   599                 for (Iterator iter2 = XmlUtil.getAllAttributes(e2);

   600                      iter2.hasNext();

   601                 ) {

   602                     Attr e3 = (Attr)iter2.next();

   603                     if (e3.getLocalName().equals(Constants.ATTR_MESSAGE) ||

   604                         e3.getLocalName().equals(Constants.ATTR_NAME))

   605                         continue;

   607                     // possible extensibility element -- must live outside the WSDL namespace

   608                     checkNotWsdlAttribute(e3);

   609                     handleExtension(context, fault, e3, e2);

   610                 }

   612                 // verify that there is at most one child element and it is a documentation element

   613                 boolean gotDocumentation2 = false;

   614                 for (Iterator iter2 = XmlUtil.getAllChildren(e2);

   615                      iter2.hasNext();

   616                     ) {

   617                     Element e3 = Util.nextElement(iter2);

   618                     if (e3 == null)

   619                         break;

   621                     if (XmlUtil

   622                         .matchesTagNS(e3, WSDLConstants.QNAME_DOCUMENTATION)) {

   623                         if (gotDocumentation2) {

   624                             errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_ONLY_ONE_DOCUMENTATION_ALLOWED(e.getLocalName()));

   625                         }

   626                         gotDocumentation2 = true;

   627                         if(fault.getDocumentation() == null)

   628                             fault.setDocumentation(getDocumentationFor(e3));

   629                     } else {

   630                         // possible extensibility element -- must live outside the WSDL namespace

   631                         checkNotWsdlElement(e3);

   632                         if (!handleExtension(context, fault, e3)) {

   633                             checkNotWsdlRequired(e3);

   634                         }

   635                     }/*else {

   636                         Util.fail(

   637                             "parsing.invalidElement",

   638                             e3.getTagName(),

   639                             e3.getNamespaceURI());

   640                     }*/

   641                 }

   642                 context.pop();

   643             } else {

   644                 // possible extensibility element -- must live outside the WSDL namespace

   645                 checkNotWsdlElement(e2);

   646                 if (!handleExtension(context, operation, e2)) {

   647                     checkNotWsdlRequired(e2);

   648                 }

   649             }/*else {

   650                 Util.fail(

   651                     "parsing.invalidElement",

   652                     e2.getTagName(),

   653                     e2.getNamespaceURI());

   654             }*/

   655         }

   657         if (gotInput && !gotOutput && !gotFault) {

   658             operation.setStyle(OperationStyle.ONE_WAY);

   659         } else if (gotInput && gotOutput && inputBeforeOutput) {

   660             operation.setStyle(OperationStyle.REQUEST_RESPONSE);

   661         } else if (gotInput && gotOutput && !inputBeforeOutput) {

   662             operation.setStyle(OperationStyle.SOLICIT_RESPONSE);

   663         } else if (gotOutput && !gotInput && !gotFault) {

   664             operation.setStyle(OperationStyle.NOTIFICATION);

   665         } else {

   666             errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_INVALID_OPERATION_STYLE(name));

   667         }

   669         context.pop();

   670         context.fireDoneParsingEntity(WSDLConstants.QNAME_OPERATION, operation);

   671         return operation;

   672     }

   674     private Binding parseBinding(

   675         TWSDLParserContextImpl context,

   676         Definitions definitions,

   677         Element e) {

   678         context.push();

   679         context.registerNamespaces(e);

   680         Binding binding = new Binding(definitions, forest.locatorTable.getStartLocation(e), errReceiver);

   681         String name = Util.getRequiredAttribute(e, Constants.ATTR_NAME);

   682         binding.setName(name);

   683         String typeAttr = Util.getRequiredAttribute(e, Constants.ATTR_TYPE);

   684         binding.setPortType(context.translateQualifiedName(context.getLocation(e), typeAttr));

   686         boolean gotDocumentation = false;

   688         for (Iterator iter = XmlUtil.getAllChildren(e); iter.hasNext();) {

   689             Element e2 = Util.nextElement(iter);

   690             if (e2 == null)

   691                 break;

   693             if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_DOCUMENTATION)) {

   694                 if (gotDocumentation) {

   695                     errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_ONLY_ONE_DOCUMENTATION_ALLOWED(e.getLocalName()));

   696                 }

   697                 gotDocumentation = true;

   698                 binding.setDocumentation(getDocumentationFor(e2));

   699             } else if (

   700                 XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_OPERATION)) {

   701                 BindingOperation op = parseBindingOperation(context, e2);

   702                 binding.add(op);

   703             } else {

   704                 // possible extensibility element -- must live outside the WSDL namespace

   705                 checkNotWsdlElement(e2);

   706                 if (!handleExtension(context, binding, e2)) {

   707                     checkNotWsdlRequired(e2);

   708                 }

   709             }

   710         }

   712         context.pop();

   713         context.fireDoneParsingEntity(WSDLConstants.QNAME_BINDING, binding);

   714         return binding;

   715     }

   717     private BindingOperation parseBindingOperation(

   718         TWSDLParserContextImpl context,

   719         Element e) {

   720         context.push();

   721         context.registerNamespaces(e);

   722         BindingOperation operation = new BindingOperation(forest.locatorTable.getStartLocation(e));

   723         String name = Util.getRequiredAttribute(e, Constants.ATTR_NAME);

   724         operation.setName(name);

   726         boolean gotDocumentation = false;

   728         boolean gotInput = false;

   729         boolean gotOutput = false;

   730         boolean gotFault = false;

   731         boolean inputBeforeOutput = false;

   733         for (Iterator iter = XmlUtil.getAllChildren(e); iter.hasNext();) {

   734             Element e2 = Util.nextElement(iter);

   735             if (e2 == null)

   736                 break;

   737             if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_DOCUMENTATION)) {

   738                 if (gotDocumentation) {

   739                     errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_ONLY_ONE_DOCUMENTATION_ALLOWED(e.getLocalName()));

   740                 }

   741                 gotDocumentation = true;

   742                 operation.setDocumentation(getDocumentationFor(e2));

   743             } else if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_INPUT)) {

   744                 if (gotInput) {

   745                     errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_TOO_MANY_ELEMENTS(Constants.TAG_INPUT,

   746                             Constants.TAG_OPERATION,

   747                             name));

   748                 }

   750                 /* Here we check for the use scenario */

   751                 context.push();

   752                 context.registerNamespaces(e2);

   753                 BindingInput input = new BindingInput(forest.locatorTable.getStartLocation(e2));

   754                 String nameAttr =

   755                     XmlUtil.getAttributeOrNull(e2, Constants.ATTR_NAME);

   756                 input.setName(nameAttr);

   757                 operation.setInput(input);

   758                 gotInput = true;

   759                 if (gotOutput) {

   760                     inputBeforeOutput = false;

   761                 }

   763                 // verify that there is at most one child element and it is a documentation element

   764                 boolean gotDocumentation2 = false;

   765                 for (Iterator iter2 = XmlUtil.getAllChildren(e2);

   766                      iter2.hasNext();

   767                     ) {

   768                     Element e3 = Util.nextElement(iter2);

   769                     if (e3 == null)

   770                         break;

   772                     if (XmlUtil

   773                         .matchesTagNS(e3, WSDLConstants.QNAME_DOCUMENTATION)) {

   774                         if (gotDocumentation2) {

   775                             errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_ONLY_ONE_DOCUMENTATION_ALLOWED(e.getLocalName()));

   776                         }

   777                         gotDocumentation2 = true;

   778                         input.setDocumentation(getDocumentationFor(e3));

   779                     } else {

   780                         // possible extensibility element -- must live outside the WSDL namespace

   781                         checkNotWsdlElement(e3);

   782                         if (!handleExtension(context, input, e3)) {

   783                             checkNotWsdlRequired(e3);

   784                         }

   785                     }

   786                 }

   787                 context.pop();

   788             } else if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_OUTPUT)) {

   789                 if (gotOutput) {

   790                     errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_TOO_MANY_ELEMENTS(Constants.TAG_INPUT,

   791                             Constants.TAG_OPERATION,

   792                             name));

   793                 }

   795                 context.push();

   796                 context.registerNamespaces(e2);

   797                 BindingOutput output = new BindingOutput(forest.locatorTable.getStartLocation(e2));

   798                 String nameAttr =

   799                     XmlUtil.getAttributeOrNull(e2, Constants.ATTR_NAME);

   800                 output.setName(nameAttr);

   801                 operation.setOutput(output);

   802                 gotOutput = true;

   803                 if (gotInput) {

   804                     inputBeforeOutput = true;

   805                 }

   807                 // verify that there is at most one child element and it is a documentation element

   808                 boolean gotDocumentation2 = false;

   809                 for (Iterator iter2 = XmlUtil.getAllChildren(e2);

   810                      iter2.hasNext();

   811                     ) {

   813                     Element e3 = Util.nextElement(iter2);

   814                     if (e3 == null)

   815                         break;

   817                     if (XmlUtil

   818                         .matchesTagNS(e3, WSDLConstants.QNAME_DOCUMENTATION)) {

   819                         if (gotDocumentation2) {

   820                             errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_ONLY_ONE_DOCUMENTATION_ALLOWED(e.getLocalName()));

   821                         }

   822                         gotDocumentation2 = true;

   823                         output.setDocumentation(getDocumentationFor(e3));

   824                     } else {

   825                         // possible extensibility element -- must live outside the WSDL namespace

   826                         checkNotWsdlElement(e3);

   827                         if (!handleExtension(context, output, e3)) {

   828                             checkNotWsdlRequired(e3);

   829                         }

   830                     }

   831                 }

   832                 context.pop();

   833             } else if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_FAULT)) {

   834                 context.push();

   835                 context.registerNamespaces(e2);

   836                 BindingFault fault = new BindingFault(forest.locatorTable.getStartLocation(e2));

   837                 String nameAttr =

   838                     Util.getRequiredAttribute(e2, Constants.ATTR_NAME);

   839                 fault.setName(nameAttr);

   840                 operation.addFault(fault);

   841                 gotFault = true;

   843                 // verify that there is at most one child element and it is a documentation element

   844                 boolean gotDocumentation2 = false;

   845                 for (Iterator iter2 = XmlUtil.getAllChildren(e2);

   846                      iter2.hasNext();

   847                     ) {

   848                     Element e3 = Util.nextElement(iter2);

   849                     if (e3 == null)

   850                         break;

   852                     if (XmlUtil

   853                         .matchesTagNS(e3, WSDLConstants.QNAME_DOCUMENTATION)) {

   854                         if (gotDocumentation2) {

   855                             errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_ONLY_ONE_DOCUMENTATION_ALLOWED(e.getLocalName()));

   856                         }

   857                         gotDocumentation2 = true;

   858                         if(fault.getDocumentation() == null)

   859                             fault.setDocumentation(getDocumentationFor(e3));

   860                     } else {

   861                         // possible extensibility element -- must live outside the WSDL namespace

   862                         checkNotWsdlElement(e3);

   863                         if (!handleExtension(context, fault, e3)) {

   864                             checkNotWsdlRequired(e3);

   865                         }

   866                     }

   867                 }

   868                 context.pop();

   869             } else {

   870                 // possible extensibility element -- must live outside the WSDL namespace

   871                 checkNotWsdlElement(e2);

   872                 if (!handleExtension(context, operation, e2)) {

   873                     checkNotWsdlRequired(e2);

   874                 }

   875             }

   876         }

   878         if (gotInput && !gotOutput && !gotFault) {

   879             operation.setStyle(OperationStyle.ONE_WAY);

   880         } else if (gotInput && gotOutput && inputBeforeOutput) {

   881             operation.setStyle(OperationStyle.REQUEST_RESPONSE);

   882         } else if (gotInput && gotOutput && !inputBeforeOutput) {

   883             operation.setStyle(OperationStyle.SOLICIT_RESPONSE);

   884         } else if (gotOutput && !gotInput && !gotFault) {

   885             operation.setStyle(OperationStyle.NOTIFICATION);

   886         } else {

   887             errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_INVALID_OPERATION_STYLE(name));

   888         }

   890         context.pop();

   891         context.fireDoneParsingEntity(WSDLConstants.QNAME_OPERATION, operation);

   892         return operation;

   893     }

   895     private Import parseImport(

   896         TWSDLParserContextImpl context,

   897         Definitions definitions,

   898         Element e) {

   899         context.push();

   900         context.registerNamespaces(e);

   901         Import anImport = new Import(forest.locatorTable.getStartLocation(e));

   902         String namespace =

   903             Util.getRequiredAttribute(e, Constants.ATTR_NAMESPACE);

   904         anImport.setNamespace(namespace);

   905         String location = Util.getRequiredAttribute(e, Constants.ATTR_LOCATION);

   906         anImport.setLocation(location);

   908         // according to the schema in the WSDL 1.1 spec, an import can have a documentation element

   909         boolean gotDocumentation = false;

   911         for (Iterator iter = XmlUtil.getAllChildren(e); iter.hasNext();) {

   912             Element e2 = Util.nextElement(iter);

   913             if (e2 == null)

   914                 break;

   916             if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_DOCUMENTATION)) {

   917                 if (gotDocumentation) {

   918                     errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_ONLY_ONE_DOCUMENTATION_ALLOWED(e.getLocalName()));

   919                 }

   920                 gotDocumentation = true;

   921                 anImport.setDocumentation(getDocumentationFor(e2));

   922             } else {

   923                 errReceiver.error(forest.locatorTable.getStartLocation(e2), WsdlMessages.PARSING_INVALID_ELEMENT(e2.getTagName(),

   924                     e2.getNamespaceURI()));

   925             }

   926         }

   927         context.pop();

   928         context.fireDoneParsingEntity(WSDLConstants.QNAME_IMPORT, anImport);

   929         return anImport;

   930     }

   932     private Service parseService(

   933         TWSDLParserContextImpl context,

   934         Definitions definitions,

   935         Element e) {

   936         context.push();

   937         context.registerNamespaces(e);

   938         Service service = new Service(definitions, forest.locatorTable.getStartLocation(e), errReceiver);

   939         String name = Util.getRequiredAttribute(e, Constants.ATTR_NAME);

   940         service.setName(name);

   942         boolean gotDocumentation = false;

   944         for (Iterator iter = XmlUtil.getAllChildren(e); iter.hasNext();) {

   945             Element e2 = Util.nextElement(iter);

   946             if (e2 == null)

   947                 break;

   949             if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_DOCUMENTATION)) {

   950                 if (gotDocumentation) {

   951                     errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_ONLY_ONE_DOCUMENTATION_ALLOWED(e.getLocalName()));

   952                 }

   953                 gotDocumentation = true;

   954                 if (service.getDocumentation() == null) {

   955                     service.setDocumentation(getDocumentationFor(e2));

   956                 }

   957             } else if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_PORT)) {

   958                 Port port = parsePort(context, definitions, e2);

   959                 service.add(port);

   960             } else {

   961                 // possible extensibility element -- must live outside the WSDL namespace

   962                 checkNotWsdlElement(e2);

   963                 if (!handleExtension(context, service, e2)) {

   964                     checkNotWsdlRequired(e2);

   965                 }

   966             }

   967         }

   969         context.pop();

   970         context.fireDoneParsingEntity(WSDLConstants.QNAME_SERVICE, service);

   971         return service;

   972     }

   974     private Port parsePort(

   975         TWSDLParserContextImpl context,

   976         Definitions definitions,

   977         Element e) {

   978         context.push();

   979         context.registerNamespaces(e);

   981         Port port = new Port(definitions, forest.locatorTable.getStartLocation(e), errReceiver);

   982         String name = Util.getRequiredAttribute(e, Constants.ATTR_NAME);

   983         port.setName(name);

   985         String bindingAttr =

   986             Util.getRequiredAttribute(e, Constants.ATTR_BINDING);

   987         port.setBinding(context.translateQualifiedName(context.getLocation(e), bindingAttr));

   989         boolean gotDocumentation = false;

   991         for (Iterator iter = XmlUtil.getAllChildren(e); iter.hasNext();) {

   992             Element e2 = Util.nextElement(iter);

   993             if (e2 == null) {

   994                 break;

   995             }

   997             if (XmlUtil.matchesTagNS(e2, WSDLConstants.QNAME_DOCUMENTATION)) {

   998                 if (gotDocumentation) {

   999                     errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_ONLY_ONE_DOCUMENTATION_ALLOWED(e.getLocalName()));

  1000                 }

  1001                 gotDocumentation = true;

  1002                 if (port.getDocumentation() == null) {

  1003                     port.setDocumentation(getDocumentationFor(e2));

  1004                 }

  1005             } else {

  1006                 // possible extensibility element -- must live outside the WSDL namespace

  1007                 checkNotWsdlElement(e2);

  1008                 if (!handleExtension(context, port, e2)) {

  1009                     checkNotWsdlRequired(e2);

  1010                 }

  1011             }

  1012         }

  1014         context.pop();

  1015         context.fireDoneParsingEntity(WSDLConstants.QNAME_PORT, port);

  1016         return port;

  1017     }

  1019     private void validateSchemaImports(Element typesElement){

  1020         for (Iterator iter = XmlUtil.getAllChildren(typesElement); iter.hasNext();) {

  1021             Element e = Util.nextElement(iter);

  1022             if (e == null) {

  1023                 break;

  1024             }

  1025             if (XmlUtil.matchesTagNS(e, SchemaConstants.QNAME_IMPORT)) {

  1026                 errReceiver.warning(forest.locatorTable.getStartLocation(e), WsdlMessages.WARNING_WSI_R_2003());

  1027             }else{

  1028                 checkNotWsdlElement(e);

  1029 //                if (XmlUtil.matchesTagNS(e, SchemaConstants.QNAME_SCHEMA)) {

  1030 //                    forest.getInlinedSchemaElement().add(e);

  1031 //                }

  1033             }

  1034         }

  1035     }

  1038     private boolean handleExtension(

  1039         TWSDLParserContextImpl context,

  1040         TWSDLExtensible entity,

  1041         Element e) {

  1042         TWSDLExtensionHandler h =

  1043              (TWSDLExtensionHandler) extensionHandlers.get(e.getNamespaceURI());

  1044         if (h == null) {

  1045             context.fireIgnoringExtension(e, (Entity) entity);

  1046             errReceiver.warning(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_UNKNOWN_EXTENSIBILITY_ELEMENT_OR_ATTRIBUTE(e.getLocalName(), e.getNamespaceURI()));

  1047             return false;

  1048         } else {

  1049             return h.doHandleExtension(context, entity, e);

  1050         }

  1051     }

  1053     private boolean handleExtension(

  1054         TWSDLParserContextImpl context,

  1055         TWSDLExtensible entity,

  1056         Node n,

  1057         Element e) {

  1058         TWSDLExtensionHandler h =

  1059             (TWSDLExtensionHandler) extensionHandlers.get(n.getNamespaceURI());

  1060         if (h == null) {

  1061             context.fireIgnoringExtension(e, (Entity) entity);

  1062             errReceiver.warning(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_UNKNOWN_EXTENSIBILITY_ELEMENT_OR_ATTRIBUTE(n.getLocalName(), n.getNamespaceURI()));

  1063             return false;

  1064         } else {

  1065             return h.doHandleExtension(context, entity, e);

  1066         }

  1067     }

  1069     private void checkNotWsdlElement(Element e) {

  1070         // possible extensibility element -- must live outside the WSDL namespace

  1071         if (e.getNamespaceURI() != null && e.getNamespaceURI().equals(Constants.NS_WSDL)) {

  1072             errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_INVALID_WSDL_ELEMENT(e.getTagName()));

  1073     }

  1074     }

  1076     private void checkNotWsdlAttribute(Attr a) {

  1077         // possible extensibility element -- must live outside the WSDL namespace

  1078         if (Constants.NS_WSDL.equals(a.getNamespaceURI())) {

  1079             errReceiver.error(forest.locatorTable.getStartLocation(a.getOwnerElement()), WsdlMessages.PARSING_INVALID_WSDL_ELEMENT(a.getLocalName()));

  1080     }

  1081     }

  1083     private void checkNotWsdlRequired(Element e) {

  1084         // check the wsdl:required attribute, fail if set to "true"

  1085         String required =

  1086             XmlUtil.getAttributeNSOrNull(

  1087                 e,

  1088                 Constants.ATTR_REQUIRED,

  1089                 Constants.NS_WSDL);

  1090         if (required != null && required.equals(Constants.TRUE) && !options.isExtensionMode()) {

  1091             errReceiver.error(forest.locatorTable.getStartLocation(e), WsdlMessages.PARSING_REQUIRED_EXTENSIBILITY_ELEMENT(e.getTagName(),

  1092                 e.getNamespaceURI()));

  1093         }

  1094     }

  1096     private Documentation getDocumentationFor(Element e) {

  1097         String s = XmlUtil.getTextForNode(e);

  1098         if (s == null) {

  1099             return null;

  1100         } else {

  1101             return new Documentation(s);

  1102         }

  1103     }

  1104 }

Mercurial > jdk8-mips64-public > jaxws / file revision

src/share/jaxws_classes/com/sun/tools/internal/ws/wsdl/parser/WSDLParser.java@9c07ef4934dd

src/share/jaxws_classes/com/sun/tools/internal/ws/wsdl/parser/WSDLParser.java