35 bool WsdlParser::useLocalSchema_=
true;
37 WsdlParser::WsdlParser(istream & in, ostream & out,
38 const std::string & schemaPath)
39 :errorOccured_(false),
47 schemaPath_(schemaPath)
53 const std::string & schemaPath)
54 :errorOccured_(false),
62 schemaPath_(schemaPath)
64 uri_ = Uri.substr(0,Uri.rfind(
'/') + 1);
67 xmlStream.open(wsdlFileName.c_str());
71 std::string e=
"Unable to connect to ";
77 WsdlParser::initialize(
bool file)
79 if (schemaPath_.empty()) {
82 schemaPath_= SCHEMADIR;
84 schemaPath_=
"src/schemas";
98 wsdlExtensions_.clear();
99 schemaParser_.clear();
114 schemaParser_.push_back(sParser);
117 soap_ =
new Soap(schemaPath_);
128 for (list < const Message * >::iterator mi =
129 messages_.begin(); mi != messages_.end();
132 for (list < Binding * >::iterator bi =
133 bindings_.begin(); bi != bindings_.end();
137 for (list < Service*>::iterator si =services_.begin();
138 si != services_.end();
142 for (list < PortType * >::iterator pti =
143 porttypes_.begin(); pti != porttypes_.end();
147 for (i = 0; i < schemaParser_.size(); i++)
148 delete schemaParser_[i];
153 for (list < string * >::iterator sti =
154 docs_list_.begin(); sti != docs_list_.end();
158 for (vector<ExtensionInfo>::iterator ie = wsdlExtensions_.begin();
159 ie != wsdlExtensions_.end();
169 std::string fname = dir.
next();
170 if (fname.find(
".wp-tmp") != std::string::npos)
173 ::DeleteFile(fname.c_str());
175 unlink(fname.c_str());
186 error (
"Attempted to extract a Binding when ,no binding was parsed",1);
191 return bindings_.back();
201 wsdlExtensions_.push_back(exi);
215 for (list <Binding * >::iterator pBinding =
216 bindings_.begin(); pBinding != bindings_.end();
229 error (
"Attempted to extract a Service when ,no service was parsed",1);
234 return services_.back();
249 for (list <Service * >::iterator si =services_.begin();
250 si != services_.end();
261 if (services_.size() > 0)
263 from = services_.begin();
264 to = services_.end();
273 error (
"Attempted to extract a PortType when ,no PortType was parsed",1);
278 return porttypes_.back();
294 pPortType != porttypes_.end();
296 if ((*pPortType)->getName() == name)
325 for (
int i = 0; i < num; i++)
341 error (
"Attempted to extract a Message when ,no Message was parsed",1);
346 return messages_.back();
352 WsdlParser::pgetMessage(
const Qname & qn)
358 putMessage(newMessage);
374 for (list < const Message * >::iterator pMessage =
375 messages_.begin(); pMessage != messages_.end();
377 if ((*pMessage)->getName() == name)
389 for (
size_t i = 0; i < schemaParser_.size(); i++){
390 if (schemaParser_[i]->
getNamespace() == targetNamespace)
393 if (schemaParser_[i]->isImported(targetNamespace)) {
395 return schemaParser_[i]->getImportedSchemaParser(targetNamespace);
415 WsdlParser::peek(
bool lookahead)
419 int event_type, tmp_event_type = xParser_->
getEventType();
420 int tmpState = state_;
426 if (lookahead ==
true || state_ ==
START || state_ ==
NONE)
432 string tag = xParser_->
getName();
437 error(
"Syntax error at the start");
444 else if (tag ==
"definitions")
447 else if (tag ==
"documentation")
450 else if (tag ==
"annotation")
453 else if (tag ==
"import")
456 else if (tag ==
"schema")
459 else if (tag ==
"types")
462 else if (tag ==
"message")
465 else if (tag ==
"port")
468 else if (tag ==
"operation")
471 else if (tag ==
"portType")
474 else if (tag ==
"input")
477 else if (tag ==
"output")
480 else if (tag ==
"fault")
483 else if (tag ==
"part")
486 else if (tag ==
"binding")
489 else if (tag ==
"service")
493 error(
"Unknown Tag " + tag);
496 if (tag ==
"definitions")
505 if (tag ==
"types" ||
507 tag ==
"documentation"||
508 tag ==
"annotation"||
514 return state_ =
NONE;
516 return peek(lookahead);
527 error(
"Doc Declaration ??");
530 error(
"Unknown Wsdl tag");
534 && tmpState == state_ &&event_type ==
597 error(
"Syntax error");
601 catch(WsdlException we)
605 errorOccured_ =
true;
609 ostr << we.description <<
" at " << we.line <<
"," << we.col << std::endl;
616 errorOccured_ =
true;
628 WsdlParser::parseDoc()
630 string* documentation =
new string();
632 error(
"syntax error");
638 *documentation += xParser_->
getText();
640 && xParser_->
getName() ==
"documentation")
643 docs_list_.push_back(documentation);
646 return documentation;
654 WsdlParser::parseAnnotation()
657 error(
"syntax error");
663 &&xParser_->
getName() ==
"annotation")
675 WsdlParser::parseDefinitions()
678 error(
"syntax error");
694 schemaParser_.push_back(sParser);
703 schemaParser_.push_back(sParser);
711 for (
size_t j = 0; j < wsdlExtensions_.size(); j++)
712 if (wsdlExtensions_[j].we != 0 &&
713 wsdlExtensions_[j].we->isNamespaceHandler(xParser_->
getNamespaceUri(i)))
715 wsdlExtensions_[j].we->setNamespacePrefix(xParser_->
719 wsdlExtensions_[j].we->setStartId(MAX_EXT_XML * j + 1);
727 new SchemaParser(wsdlExtensions_[j].we->getExtensibilitySchema(),
728 wsdlExtensions_ [j].we->getNamespace(),ostr,schemaPath_);
731 xtmpSchemaParser->
addImport(schemaParser_[0]);
734 wsdlExtensions_[j].spe = xtmpSchemaParser;
735 wsdlExtensions_[j].we->
736 setSchemaParser(xtmpSchemaParser);
737 wsdlExtensions_[j].we->setWsdlParser(
this);
741 std::string err =
"Error parsing the schema for the namespace ";
742 err +=wsdlExtensions_[j].we->getNamespace();
744 err +=
"Unable to locate the file ";
745 err += wsdlExtensions_[j].we->getExtensibilitySchema();
754 error(
"Atleast a targetNamespace attribute is needed");
755 for (i = 0; i < num_attr; i++)
774 WsdlParser::parseImport()
777 error(
"syntax error");
793 wsdlStream.open(fname.c_str());
805 error(
"Error while opening the included wsdl " + imp.loc);
808 error(
"location is a required attribute for <import>");
810 imports_.push_back(imp);
819 WsdlParser::parseMessage()
822 error(
"syntax error");
829 m=
new Message(*
this);
834 for (
int i = 0; i < num_att; i++){
837 m->addExtAttribute(handleExtensibilityAttributes
842 if (m->getName() ==
"")
843 error(
"syntax error <message> name required");
849 m->setDocumentation(parseDoc());
857 while (state_ ==
PART)
860 int type_id = 0, schemaId = -1;
865 for (
int i = 0; i < num_att; i++)
879 (
"either type or element must occur(only once) in part ");
891 type_id = getTypeId(type);
893 error(
"Could not resolve type " +
894 type.getNamespace() +
":" +
895 type.getLocalName());
901 e = getElement(type);
903 error(
"Could not resolve element " +
904 type.getNamespace() +
":" +
905 type.getLocalName());
910 schemaId = getSchema(type,reftype ==
Part::Type);
914 p_extId = handleExtensibilityAttributes(xParser_->
923 error(
"Syntax error");
932 m->addPart(p_name, reftype, (
void*)(e) , schemaId);
934 m->addPart(p_name, reftype, (
void*)(&type_id) , schemaId);
935 m->addExtElement(p_extId);
939 catch(WsdlException we)
951 m->addExtElement(handleExtensibilityElement(
MESSAGE));
963 WsdlParser::parsePortType()
968 PortType * pt =
new PortType(*
this);
970 for (
int i = 0; i < num_att; i++){
979 pt->addExtAttribute(handleExtensibilityAttributes
985 error(
"Syntax error.Unrecognized attribute");
988 if (pt->getName() ==
"")
989 error(
"syntax error <PortType> name required");
994 pt->setDocumentation(parseDoc());
1002 Operation * op = parseOperation(pt);
1010 pt->addExtElement(handleExtensibilityElement(
PORT_TYPE));
1022 WsdlParser::parseOperation(PortType * p)
1024 Operation * op =
new Operation(*
this,p);
1026 error(
"syntax error");
1029 for (
int i = 0; i < num_att; i++){
1039 op->addExtAttribute(handleExtensibilityAttributes
1049 error(
"Syntax error..unrecognized attribute");
1051 if (op->getName() ==
"")
1052 error(
"syntax error <operation> name required");
1056 op->setDocumentation(parseDoc());
1059 if (state_ ==
INPUT)
1076 while (state_ ==
FAULT)
1087 else if (state_ ==
OUTPUT)
1094 if (state_ ==
INPUT)
1102 while (state_ ==
FAULT)
1113 op->setDocumentation(parseDoc());
1119 op->addExtElement(handleExtensibilityElement(
OPERATION));
1129 WsdlParser::processMessageExtensibility(Operation * op,
1134 std::string message_name;
1135 for (
int i = 0; i < num_att; i++){
1145 op->addMessageExtensibility(mtype,handleExtensibilityAttributes
1153 WsdlParser::parseTypes()
1169 for (
size_t s = 1 ;s<schemaParser_.size();s++){
1181 error(
"Error parsing schema types for "+tnsUri_);
1183 schemaParser_.push_back(sParser);
1187 for (
size_t i = 1; i < schemaParser_.size(); i++)
1190 for (
size_t j = 1; j < schemaParser_.size(); j++) {
1192 if (schemaParser_[i]->isImported(schemaParser_[j]->
getNamespace()))
1193 schemaParser_[i]->addImport(schemaParser_[j]);
1197 if (!schemaParser_[i]->finalize())
1198 error(
"Invalid schema");
1207 we.WsdlState = state_;
1214 WsdlParser::putMessage(Message * m)
1218 messages_.push_back(m);
1223 WsdlParser::putBinding(Binding * bn)
1225 bindings_.push_back(bn);
1229 WsdlParser::putPortType(PortType * pt)
1231 porttypes_.push_back(pt);
1236 WsdlParser::handleExtensibilityElement(
int parent)
1245 return we->handleElement(parent, xParser_);
1250 WsdlParser::handleExtensibilityAttributes(
string prefix,
string name)
1257 return we->handleAttribute(state_, name, xParser_);
1263 for (
size_t i = 0; i < wsdlExtensions_.size(); i++)
1264 if (wsdlExtensions_[i].we != 0 &&
1265 (wsdlExtensions_[i].we->isNamespaceHandler(Ns)))
1266 return wsdlExtensions_[i].we;
1277 for (
size_t i = 0; i < wsdlExtensions_.size(); i++)
1278 if (wsdlExtensions_[i].we != 0 &&
1279 (extId >= wsdlExtensions_[i].we->getStartId()&&
1280 extId < MAX_EXT_XML + wsdlExtensions_[i].we->getStartId()))
1281 return wsdlExtensions_[i].we;
1287 WsdlParser::parseBinding()
1290 Binding * bn =
new Binding(*
this);
1292 int opBinding, inputBinding, outputBinding, faultBinding, index,
1294 opBinding = inputBinding = outputBinding = faultBinding = index =
1297 error(
"syntax error");
1302 for (i = 0; i < num_att; i++)
1314 error(
"Unknown port type "+ q.getLocalName());
1315 bn->setPortType(pt);
1316 (const_cast<PortType*>(pt))->setBinding(bn);
1320 error(
"Syntax error..unrecognized attribute");
1326 bn->setDocumentation(parseDoc());
1333 bn->setBindingInfo(bindingInfo =
1334 handleExtensibilityElement(
BINDING));
1337 if(bindingExtension)
1338 bn->setBindingMethod(bindingExtension->
getNamespace());
1345 const Operation *op = NULL;
1346 for (i = 0; i < num_att; i++){
1352 op = pt->getOperation(q);
1356 error(
"Unrecognized attribute");
1358 index = bn->addOperation(op);
1368 opBinding = handleExtensibilityElement(
OPERATION);
1369 if(opBinding) bn->addOpBinding(index, opBinding);
1377 if (state_ ==
INPUT) {
1382 inputBinding = handleExtensibilityElement(
OPERATION);
1383 if(inputBinding) bn->addInputBinding(index, inputBinding);
1392 outputBinding = handleExtensibilityElement(
OPERATION);
1393 if(outputBinding) bn->addOutputBinding(index, outputBinding);
1397 while (state_ ==
FAULT) {
1402 faultBinding = handleExtensibilityElement(
OPERATION);
1404 if(faultBinding) bn->addFaultBinding(index, faultBinding);
1413 WsdlParser::parseService()
1416 error(
"Syntax error");
1418 Service * sv =
new Service(*
this);
1421 for (i = 0; i < num_att; i++) {
1428 error(
"Unrecognized attribute");
1430 sv->setName(serviceName);
1434 sv->setDocumentation(parseDoc());
1436 while (state_ ==
PORT) {
1438 string bnName,portName;
1440 int serviceExtId = 0;
1442 for (i = 0; i < num_att; i++) {
1464 serviceExtId = handleExtensibilityElement(
BINDING);
1468 bn->addServiceExtId(serviceExtId);
1470 sv->addPort(portName,bn,serviceExtId);
1472 services_.push_back(sv);
1481 WsdlParser::getSchema(
const Qname & name,
bool isType)
1491 for (
size_t i = 0; i < schemaParser_.size(); i++) {
1499 if ((isType && schemaParser_[i]->getType(name,
false) != 0) ||
1500 (!isType && schemaParser_[i]->getElement(name,
false) != 0))
1510 WsdlParser::getElement(
const Qname& name)
1512 int i = getSchema(name,
false);
1514 return const_cast<Element*>(schemaParser_[i]->getElement(name));
1520 WsdlParser::getTypeId(
const Qname & type)
1523 int i = getSchema(type,
true);
1527 return schemaParser_[i]->getTypeId(t);
1535 std::vector<SchemaParser* >::iterator & to)
1538 from=schemaParser_.begin();
1541 to=schemaParser_.end();
1546 WsdlParser::error(
string s,
int level)
1556 we.WsdlState = state_;
1557 errorOccured_ =
true;
1561 else if (level == 1) {
1563 ostr<<
"Wsdl parser warning : "<<s<<endl;
1565 else if (level == 2) {
1567 ostr<<
"Wsdl parser info : "<<s<<endl;
1574 Binding::cBindingIterator & end)
const 1576 if(bindings_.size()>0){
1578 begin=bindings_.begin();
1579 end=bindings_.end();
1590 if(porttypes_.size()>0){
1592 begin=porttypes_.begin();
1593 end=porttypes_.end();
1603 return schemaParser_.size() - 2;
1610 schemaPath_ = schemaPath;
1612 for (vector<ExtensionInfo>::iterator ie = wsdlExtensions_.begin();
1613 ie != wsdlExtensions_.end();
1615 ie->we->setSchemaPath(schemaPath);
void addExtensibilityHandler(WsdlExtension *ext)
void require(int type, std::string ns, std::string name)
int getNumOps(void) const
void setSchemaPath(const std::string &schemaPath)
std::string getAttributeName(int index)
void setFeature(std::string feature, bool value)
int getNamespaceCount(int depth)
void setNamespace(std::string uri)
const Service * getService()
std::string getEncodingSchema(void) const
std::list< PortType * >::const_iterator cPortTypeIterator
std::string getNamespace(void) const
virtual std::string getNamespace() const =0
std::string getNamespace(void) const
static bool useLocalSchema_
std::string getNamespace(std::string prefix)
std::string getName() const
bool isValidWsdlElement(int id)
std::list< Service * >::iterator ServiceIterator
std::string getEncodingUri(void) const
std::string getAttributeValue(int index)
const SchemaParser * getSchemaParser(std::string targetNamespace) const
std::string getLocalName(void) const
void getSchemaParsers(std::vector< SchemaParser * >::iterator &from, std::vector< SchemaParser * >::iterator &to)
std::string getPrefix(void) const
bool getOperations(const Qname &portType, Operation::cOpIterator &begin, Operation::cOpIterator &end)
const Operation * getOperation(const Qname &portType, const Qname &q)
std::string getNamespacePrefix(int pos)
WsdlExtension * getExtensibilityHandler(const std::string &ns)
int getNumSchemas() const
bool getPortTypes(PortType::cPortTypeIterator &begin, PortType::cPortTypeIterator &end) const
const Binding * getBinding()
bool getBindings(Binding::cBindingIterator &begin, Binding::cBindingIterator &end) const
WsdlParser(std::istream &in=std::cin, std::ostream &out=std::cout, const std::string &schemaPath="")
const Operation * getOperation(int index) const
const PortType * getPortType()
void getServices(ServiceIterator &from, ServiceIterator &to)
bool WSDLPULL_EXPORT fetchUri(std::string uri, std::string &path)
std::string getNamespaceUri(int pos)
bool getOperations(Operation::cOpIterator &start, Operation::cOpIterator &finish) const
void setUri(const std::string &u)
std::vector< Operation * >::const_iterator cOpIterator
std::string getAttributePrefix(int index)
const std::string wsdlUri
const Message * getMessage()
const std::string SchemaUri
void setName(std::string nam)
bool addImport(std::string ns, std::string location="")
std::string getNamespace(void)
#define FEATURE_PROCESS_NAMESPACES