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 ";
77WsdlParser::initialize(
bool file)
79 if (schemaPath_.empty()) {
82 schemaPath_= SCHEMADIR;
84 schemaPath_=
"src/schemas";
98 wsdlExtensions_.clear();
99 schemaParser_.clear();
109 sParser =
new SchemaParser (schemaPath_+
"wsdl10.xsd",
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();
352WsdlParser::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);
415WsdlParser::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");
533 }
while (event_type != xParser_->END_DOCUMENT
534 && tmpState == state_ &&event_type ==
597 error(
"Syntax error");
601 catch(WsdlException we)
603 we.line = xParser_->getLineNumber();
604 we.col = xParser_->getColumnNumber();
605 errorOccured_ =
true;
609 ostr << we.description <<
" at " << we.line <<
"," << we.col << std::endl;
612 catch(XmlPullParserException xe)
616 errorOccured_ =
true;
628WsdlParser::parseDoc()
630 string* documentation =
new string();
632 error(
"syntax error");
636 xParser_->nextToken();
637 if (xParser_->getEventType() == xParser_->TEXT)
638 *documentation += xParser_->getText();
639 if (xParser_->getEventType() == xParser_->END_TAG
640 && xParser_->getName() ==
"documentation")
643 docs_list_.push_back(documentation);
646 return documentation;
654WsdlParser::parseAnnotation()
657 error(
"syntax error");
661 xParser_->nextToken();
662 if (xParser_->getEventType() == xParser_->END_TAG
663 &&xParser_->getName() ==
"annotation")
675WsdlParser::parseDefinitions()
678 error(
"syntax error");
680 tnsUri_ = xParser_->getAttributeValue(
"",
"targetNamespace");
682 for (i = xParser_->getNamespaceCount(xParser_->getDepth()) - 1;
683 i > xParser_->getNamespaceCount(xParser_->getDepth() - 1) - 1; i--)
685 if (xParser_->getNamespaceUri(i) == tnsUri_)
686 tnsPrefix_ = xParser_->getNamespacePrefix(i);
688 if (xParser_->getNamespaceUri(i) == soap_->getEncodingUri()) {
691 SchemaParser * sParser =
new SchemaParser(soap_->getEncodingSchema(),
692 soap_->getEncodingUri(),ostr,schemaPath_);
694 schemaParser_.push_back(sParser);
697 if (xParser_->getNamespaceUri(i) == soap2_->getEncodingUri()) {
700 SchemaParser * sParser =
new SchemaParser(soap2_->getEncodingSchema(),
701 soap2_->getEncodingUri(),ostr,schemaPath_);
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);
726 SchemaParser * xtmpSchemaParser =
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();
752 int num_attr = xParser_->getAttributeCount();
754 error(
"Atleast a targetNamespace attribute is needed");
755 for (i = 0; i < num_attr; i++)
757 if (xParser_->getAttributeName(i) ==
"name")
759 name_ = xParser_->getAttributeValue(i);
763 else if (xParser_->getAttributeName(i) !=
"targetNamespace")
765 handleExtensibilityAttributes(xParser_->getAttributePrefix(i),
766 xParser_->getAttributeName(i));
774WsdlParser::parseImport()
777 error(
"syntax error");
778 Imports imp (xParser_->getAttributeValue(
"",
"namespace"),
779 xParser_->getAttributeValue(
"",
"location"));
793 wsdlStream.open(fname.c_str());
795 XmlPullParser * xpp =
new XmlPullParser(wsdlStream);
796 XmlPullParser * tmpXparser=xParser_;
805 error(
"Error while opening the included wsdl " + imp.loc);
808 error(
"location is a required attribute for <import>");
810 imports_.push_back(imp);
819WsdlParser::parseMessage()
822 error(
"syntax error");
825 int num_att = xParser_->getAttributeCount();
826 std::string n=xParser_->getAttributeValue(
"",
"name");
829 m=
new Message(*
this);
834 for (
int i = 0; i < num_att; i++){
836 if (!(xParser_->getAttributePrefix(i)).empty())
837 m->addExtAttribute(handleExtensibilityAttributes
838 (xParser_->getAttributePrefix(i),
839 xParser_->getAttributeName(i)));
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;
863 int num_att = xParser_->getAttributeCount();
865 for (
int i = 0; i < num_att; i++)
867 if (
"name" == xParser_->getAttributeName(i) &&
869 (xParser_->getAttributePrefix(i)).empty())
870 p_name = xParser_->getAttributeValue(i);
872 else if ((
"type" == xParser_->getAttributeName(i)
873 &&xParser_->getAttributePrefix(i).empty())
874 ||(
"element" == xParser_->getAttributeName(i)
875 &&xParser_->getAttributePrefix(i).empty()))
879 (
"either type or element must occur(only once) in part ");
880 if (
"type" == xParser_->getAttributeName(i))
885 Qname type(xParser_->getAttributeValue(i));
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);
913 else if (!(xParser_->getAttributePrefix(i)).empty())
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)
941 we.line = xParser_->getLineNumber();
942 we.col = xParser_->getColumnNumber();
951 m->addExtElement(handleExtensibilityElement(
MESSAGE));
963WsdlParser::parsePortType()
968 PortType * pt =
new PortType(*
this);
969 int num_att = xParser_->getAttributeCount();
970 for (
int i = 0; i < num_att; i++){
972 if (
"name" == xParser_->getAttributeName(i) &&
974 (xParser_->getAttributePrefix(i)).empty())
975 pt->setName(xParser_->getAttributeValue(i));
977 else if (!(xParser_->getAttributePrefix(i)).empty()) {
979 pt->addExtAttribute(handleExtensibilityAttributes
980 (xParser_->getAttributePrefix(i),
981 xParser_->getAttributeName(i)));
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));
1022WsdlParser::parseOperation(
PortType * p)
1024 Operation * op =
new Operation(*
this,p);
1026 error(
"syntax error");
1028 int num_att = xParser_->getAttributeCount();
1029 for (
int i = 0; i < num_att; i++){
1031 if (
"name" == xParser_->getAttributeName(i) &&
1032 (xParser_->getAttributePrefix(i)).empty())
1033 op->setName(xParser_->getAttributeValue(i));
1037 else if (!(xParser_->getAttributePrefix(i)).empty()) {
1039 op->addExtAttribute(handleExtensibilityAttributes
1040 (xParser_->getAttributePrefix(i),
1041 xParser_->getAttributeName(i)));
1044 else if (
"parameterOrder" == xParser_->getAttributeName(i)) {
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)
1061 op->setMessage(pgetMessage(Qname(xParser_->getAttributeValue(
"",
"message"))),
1063 xParser_->getAttributeValue(
"",
"name"));
1069 op->setMessage(pgetMessage(Qname(xParser_->getAttributeValue(
"",
"message"))),
1071 xParser_->getAttributeValue(
"",
"name"));
1076 while (state_ ==
FAULT)
1078 op->setMessage(pgetMessage(Qname(xParser_->getAttributeValue(
"",
"message"))),
1080 xParser_->getAttributeValue(
"",
"name"));
1087 else if (state_ ==
OUTPUT)
1089 op->setMessage(pgetMessage(Qname(xParser_->getAttributeValue(
"",
"message"))),
1091 xParser_->getAttributeValue(
"",
"name"));
1094 if (state_ ==
INPUT)
1096 op->setMessage(pgetMessage(Qname(xParser_->getAttributeValue(
"",
"message"))),
1098 xParser_->getAttributeValue(
"",
"name"));
1102 while (state_ ==
FAULT)
1104 op->setMessage(pgetMessage(Qname(xParser_->getAttributeValue(
"",
"message"))),
1106 xParser_->getAttributeValue(
"",
"name"));
1113 op->setDocumentation(parseDoc());
1119 op->addExtElement(handleExtensibilityElement(
OPERATION));
1129WsdlParser::processMessageExtensibility(
Operation * op,
1133 int num_att = xParser_->getAttributeCount();
1134 std::string message_name;
1135 for (
int i = 0; i < num_att; i++){
1137 if (
"name" == xParser_->getAttributeName(i) &&
1138 (xParser_->getAttributePrefix(i)).empty())
1139 message_name = xParser_->getAttributeValue(i);
1143 else if (!(xParser_->getAttributePrefix(i)).empty()) {
1145 op->addMessageExtensibility(mtype,handleExtensibilityAttributes
1146 (xParser_->getAttributePrefix(i),
1147 xParser_->getAttributeName(i)));
1153WsdlParser::parseTypes()
1165 SchemaParser *sParser=
new SchemaParser(xParser_, tnsUri_,ostr,schemaPath_);
1169 for (
size_t s = 1 ;s<schemaParser_.size();s++){
1172 if (schemaParser_[s]->
getNamespace() == soap_->getEncodingUri())
1174 if (schemaParser_[s]->
getNamespace() == soap2_->getEncodingUri())
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");
1202 catch(SchemaParserException spe)
1207 we.WsdlState = state_;
1214WsdlParser::putMessage(
Message * m)
1218 messages_.push_back(m);
1223WsdlParser::putBinding(
Binding * bn)
1225 bindings_.push_back(bn);
1229WsdlParser::putPortType(
PortType * pt)
1231 porttypes_.push_back(pt);
1236WsdlParser::handleExtensibilityElement(
int parent)
1240 xParser_->skipSubTree();
1245 return we->handleElement(parent, xParser_);
1250WsdlParser::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;
1287WsdlParser::parseBinding()
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());
1316 (
const_cast<PortType*
>(pt))->setBinding(bn);
1320 error(
"Syntax error..unrecognized attribute");
1334 handleExtensibilityElement(
BINDING));
1337 if(bindingExtension)
1344 num_att = xParser_->getAttributeCount();
1345 const Operation *op = NULL;
1346 for (i = 0; i < num_att; i++){
1348 if (
"name" == xParser_->getAttributeName(i) &&
1349 (xParser_->getAttributePrefix(i)).empty()){
1351 Qname q(xParser_->getAttributeValue(i));
1356 error(
"Unrecognized attribute");
1368 opBinding = handleExtensibilityElement(
OPERATION);
1377 if (state_ ==
INPUT) {
1382 inputBinding = handleExtensibilityElement(
OPERATION);
1392 outputBinding = handleExtensibilityElement(
OPERATION);
1397 while (state_ ==
FAULT) {
1402 faultBinding = handleExtensibilityElement(
OPERATION);
1413WsdlParser::parseService()
1416 error(
"Syntax error");
1418 Service * sv =
new Service(*
this);
1419 int num_att = xParser_->getAttributeCount();
1421 for (i = 0; i < num_att; i++) {
1423 if (
"name" == xParser_->getAttributeName(i) &&
1424 (xParser_->getAttributePrefix(i)).empty())
1425 serviceName = xParser_->getAttributeValue(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;
1441 num_att = xParser_->getAttributeCount();
1442 for (i = 0; i < num_att; i++) {
1444 if (
"binding" == xParser_->getAttributeName(i) &&
1445 (xParser_->getAttributePrefix(i)).empty()) {
1447 bnName = xParser_->getAttributeValue(i);
1449 else if (
"name" == xParser_->getAttributeName(i)) {
1451 portName = xParser_->getAttributeValue(i);
1464 serviceExtId = handleExtensibilityElement(
BINDING);
1468 bn->addServiceExtId(serviceExtId);
1470 sv->addPort(portName,bn,serviceExtId);
1472 services_.push_back(sv);
1481WsdlParser::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))
1510WsdlParser::getElement(
const Qname& name)
1512 int i = getSchema(name,
false);
1514 return const_cast<Element*
>(schemaParser_[i]->getElement(name));
1520WsdlParser::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();
1546WsdlParser::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;
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);
#define FEATURE_PROCESS_NAMESPACES
std::string getLocalName(void) const
void setNamespace(std::string uri)
std::string getPrefix(void) const
std::string getNamespace(void) const
std::string getNamespace(void) const
void setUri(const std::string &u)
bool addImport(std::string ns, std::string location="")
void addOpBinding(int index, int oBn)
void setPortType(const PortType *pt)
void addOutputBinding(int index, int opBn)
void addFaultBinding(int index, int fBn)
void setBindingMethod(const std::string &ns)
void addInputBinding(int index, int ipBn)
std::list< Binding * >::const_iterator cBindingIterator
void setBindingInfo(int id)
int addOperation(const Operation *op)
std::vector< Operation * >::const_iterator cOpIterator
const Operation * getOperation(int index) const
std::list< PortType * >::const_iterator cPortTypeIterator
bool getOperations(Operation::cOpIterator &start, Operation::cOpIterator &finish) const
int getNumOps(void) const
void setDocumentation(std::string *s)
void setName(std::string nam)
std::string getName() const
virtual std::string getNamespace() const =0
const PortType * getPortType()
const Service * getService()
WsdlExtension * getExtensibilityHandler(const std::string &ns)
int getNumSchemas() const
static bool useLocalSchema_
void getSchemaParsers(std::vector< SchemaParser * >::iterator &from, std::vector< SchemaParser * >::iterator &to)
void addExtensibilityHandler(WsdlExtension *ext)
std::list< Service * >::iterator ServiceIterator
std::string getNamespace(void)
const SchemaParser * getSchemaParser(std::string targetNamespace) const
void getServices(ServiceIterator &from, ServiceIterator &to)
bool getBindings(Binding::cBindingIterator &begin, Binding::cBindingIterator &end) const
const Binding * getBinding()
WsdlParser(std::istream &in=std::cin, std::ostream &out=std::cout, const std::string &schemaPath="")
bool getPortTypes(PortType::cPortTypeIterator &begin, PortType::cPortTypeIterator &end) const
const Message * getMessage()
bool getOperations(const Qname &portType, Operation::cOpIterator &begin, Operation::cOpIterator &end)
const Operation * getOperation(const Qname &portType, const Qname &q)
void setSchemaPath(const std::string &schemaPath)
void require(int type, std::string ns, std::string name)
std::string getNamespace(std::string prefix)
std::string getAttributeValue(int index)
std::string getAttributePrefix(int index)
std::string getAttributeName(int index)
void setFeature(std::string feature, bool value)
const std::string SchemaUri
bool isValidWsdlElement(int id)
const std::string wsdlUri
bool WSDLPULL_EXPORT fetchUri(std::string uri, std::string &path)