From e990ea0cef935f9a0ea7d8615e8d8b5a23147255 Mon Sep 17 00:00:00 2001 From: Simon Morlat Date: Fri, 20 Sep 2013 10:08:16 +0200 Subject: [PATCH] wrapper generator in progress --- COPYING | 12 +- coreapi/address.c | 10 +- coreapi/help/Doxyfile.in | 2 +- coreapi/linphonecall.c | 21 +- coreapi/linphonecore.h | 22 +- mediastreamer2 | 2 +- tools/Makefile.am | 2 +- tools/genwrappers.cc | 615 ++++++++++++++++++++++++++++++++++++--- 8 files changed, 612 insertions(+), 74 deletions(-) diff --git a/COPYING b/COPYING index d60c31a97..b18ab0474 100644 --- a/COPYING +++ b/COPYING @@ -55,8 +55,8 @@ patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. - - GNU GENERAL PUBLIC LICENSE + + GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains @@ -110,7 +110,7 @@ above, provided that you also meet all of these conditions: License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) - + These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in @@ -168,7 +168,7 @@ access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. - + 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is @@ -225,7 +225,7 @@ impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. - + 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License @@ -278,7 +278,7 @@ PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS - + How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest diff --git a/coreapi/address.c b/coreapi/address.c index 7f1971abe..15f3a4062 100644 --- a/coreapi/address.c +++ b/coreapi/address.c @@ -171,13 +171,15 @@ void linphone_address_destroy(LinphoneAddress *u){ sal_address_unref(u); } +/** + * Get port number as an integer value. + */ +/** + * Get port number, 0 if not present. + */ int linphone_address_get_port(const LinphoneAddress *u) { -#ifdef USE_BELLESIP return sal_address_get_port(u); -#else - return sal_address_get_port_int(u); -#endif } /** @} */ diff --git a/coreapi/help/Doxyfile.in b/coreapi/help/Doxyfile.in index dce1804b2..27068c53d 100644 --- a/coreapi/help/Doxyfile.in +++ b/coreapi/help/Doxyfile.in @@ -190,7 +190,7 @@ EXPAND_ONLY_PREDEF = NO SEARCH_INCLUDES = YES INCLUDE_PATH = . INCLUDE_FILE_PATTERNS = *.h -PREDEFINED = DOXYGEN +PREDEFINED = DOXYGEN MS2_PUBLIC= LINPHONE_PUBLIC= EXPAND_AS_DEFINED = SKIP_FUNCTION_MACROS = YES #--------------------------------------------------------------------------- diff --git a/coreapi/linphonecall.c b/coreapi/linphonecall.c index 335e49dc7..cf6233546 100644 --- a/coreapi/linphonecall.c +++ b/coreapi/linphonecall.c @@ -1203,16 +1203,31 @@ void _linphone_call_params_copy(LinphoneCallParams *ncp, const LinphoneCallParam if (cp->custom_headers) ncp->custom_headers=sal_custom_header_clone(cp->custom_headers); } +/** + * @ingroup call_control + * Set requested level of privacy for the call. + * \xmlonly javascript \endxmlonly + * @param params the call parameters to be modified + * @param LinphonePrivacy to configure privacy + * */ void linphone_call_params_set_privacy(LinphoneCallParams *params, LinphonePrivacyMask privacy) { params->privacy=privacy; } + +/** + * @ingroup call_control + * Get requested level of privacy for the call. + * @param params the call parameters + * @return Privacy mode + * */ LinphonePrivacyMask linphone_call_params_get_privacy(const LinphoneCallParams *params) { return params->privacy; } - - - +/** + * @ingroup call_control + * @return string value of LinphonePrivacy enum + **/ const char* linphone_privacy_to_string(LinphonePrivacy privacy) { switch(privacy) { case LinphonePrivacyDefault: return "LinphonePrivacyDefault"; diff --git a/coreapi/linphonecore.h b/coreapi/linphonecore.h index 57bab7181..a7d8cc793 100644 --- a/coreapi/linphonecore.h +++ b/coreapi/linphonecore.h @@ -182,9 +182,6 @@ const char *linphone_address_get_scheme(const LinphoneAddress *u); LINPHONE_PUBLIC const char *linphone_address_get_display_name(const LinphoneAddress* u); LINPHONE_PUBLIC const char *linphone_address_get_username(const LinphoneAddress *u); LINPHONE_PUBLIC const char *linphone_address_get_domain(const LinphoneAddress *u); -/** - * Get port number as an integer value, -1 if not set. - */ LINPHONE_PUBLIC int linphone_address_get_port(const LinphoneAddress *u); LINPHONE_PUBLIC void linphone_address_set_display_name(LinphoneAddress *u, const char *display_name); LINPHONE_PUBLIC void linphone_address_set_username(LinphoneAddress *uri, const char *username); @@ -371,24 +368,9 @@ typedef enum _LinphonePrivacy { * */ typedef unsigned int LinphonePrivacyMask; -/** - * @ingroup call_control - * @return string value of LinphonePrivacy enum - * */ -const char* linphone_privacy_to_string(LinphonePrivacy privacy); -/** - * @ingroup call_control - * Set requested level of privacy for the call. - * @param params the call parameters to be modified - * @param LinphonePrivacy to configure privacy - * */ + +LINPHONE_PUBLIC const char* linphone_privacy_to_string(LinphonePrivacy privacy); LINPHONE_PUBLIC void linphone_call_params_set_privacy(LinphoneCallParams *params, LinphonePrivacyMask privacy); -/** - * @ingroup call_control - * Get requested level of privacy for the call. - * @param params the call parameters - * @return Privacy mode - * */ LINPHONE_PUBLIC LinphonePrivacyMask linphone_call_params_get_privacy(const LinphoneCallParams *params); diff --git a/mediastreamer2 b/mediastreamer2 index ac5233ae1..56128aa7e 160000 --- a/mediastreamer2 +++ b/mediastreamer2 @@ -1 +1 @@ -Subproject commit ac5233ae16394d59cf4d9783a229f2adc2111b12 +Subproject commit 56128aa7e5e613708cd8a35beb5d2643dc4dae67 diff --git a/tools/Makefile.am b/tools/Makefile.am index 9f8233a80..169fda781 100644 --- a/tools/Makefile.am +++ b/tools/Makefile.am @@ -12,7 +12,7 @@ COMMON_CFLAGS=\ $(STRICT_OPTIONS) \ $(LIBXML2_CFLAGS) -AM_CXXFLAGS=$(LIBXML2_CFLAGS) +AM_CXXFLAGS=$(LIBXML2_CFLAGS) $(STRICT_OPTIONS) EXTRA_DIST=xml2lpc_jni.cc lpc2xml_jni.cc diff --git a/tools/genwrappers.cc b/tools/genwrappers.cc index c506f6f71..3508937db 100644 --- a/tools/genwrappers.cc +++ b/tools/genwrappers.cc @@ -23,9 +23,14 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include #include #include +#include +#include #include #include +#include +#include +#include using namespace::std; @@ -33,19 +38,41 @@ using namespace::std; class Type{ public: enum BasicType{ + Void, + Boolean, Integer, + Float, String, - Klass + Enum, + Class }; + static Type* addType(BasicType bt, const string &name){ + Type* ret; + if ((ret=mTypes[name])==0){ + cout<<"Adding new "<<(bt==Enum ? "enum" : "class")<<" type '"<mBasic=Enum; + } + return ret; + } static Type *getType(const std::string &tname){ if (strstr(tname.c_str(),"char")!=0 && strchr(tname.c_str(),'*')!=0){ return &sStringType; - }else if (strcmp(tname.c_str(),"int")==0){ + }else if (tname.find("int")==0){ return &sIntegerType; - }else{ - Type* ret; + }else if (tname.find("float")==0){ + return &sFloatType; + }else if (tname.find("bool_t")==0){ + return &sBooleanType; + }else if (tname.find("void")!=string::npos){ + return &sVoidType; + }else if (tname.find("enum")==0){ + return addType(Enum,tname.c_str()+strlen("enum ")); + }else{/*an object?*/ + string tmp=tname; - ssize_t pos; + size_t pos; /*really ugly and slow*/ @@ -60,19 +87,17 @@ public: while ((pos=tmp.find(' '))!=string::npos){ tmp.erase(pos,1); } - - if ((ret=mTypes[tmp])==0){ - cout<<"Adding new class type '"< mTypes; }; Type Type::sStringType(Type::String); Type Type::sIntegerType(Type::Integer); +Type Type::sVoidType(Type::Void); +Type Type::sBooleanType(Type::Boolean); +Type Type::sFloatType(Type::Float); std::map Type::mTypes; class Argument{ public: - Argument(Type *type, const string &argname, bool isConst) : mType(type), mName(argname), mConst(isConst){ + Argument(Type *type, const string &argname, bool isConst, bool isPointer) : mType(type), mName(argname), mConst(isConst), mPointer(isPointer){ + if (!isPointer) mConst=false; } Type *getType()const{ return mType; } + bool isConst()const{ + return mConst; + } + const string &getName()const{ + return mName; + } + bool isPointer()const{ + return mPointer; + } + const string &getHelp()const{ + return mHelp; + } private: - bool mConst; + Type *mType; string mName; string mHelp; + bool mConst; + bool mPointer; }; class Method{ public: - Method(const std::string &uid, Argument* return_arg, const std::string &name, const list &args){ + enum PropertyBehaviour{ + None, + Read, + Write + }; + Method(const std::string &uid, Argument* return_arg, const std::string &name, const list &args, bool isConst, bool isStatic){ mUid=uid; mReturn=return_arg; mName=name; mArgs=args; + mConst=isConst; + mStatic=isStatic; + analyseProperties(); } void setHelp(const std::string &help){ mHelp=help; } + Argument *getReturnArg()const{ + return mReturn; + } + const string &getName()const{ + return mName; + } + const list &getArgs()const { + return mArgs; + } + bool isConst()const{ + return mConst; + } + bool isStatic()const{ + return mStatic; + } + const string &getHelp(){ + return mHelp; + } + PropertyBehaviour getPropertyBehaviour()const{ + return mPropertyBehaviour; + } + const string &getPropertyName()const{ + return mPropertyName; + } private: + void analyseProperties(){ + size_t enabled_pos; + mPropertyBehaviour=None; + + if (mName.find("get")==0 && mArgs.size()==0){ + mPropertyName=mName.substr(3,string::npos); + if (!mPropertyName.empty()){ + mPropertyName[0]=tolower(mPropertyName[0]); + mPropertyBehaviour=Read; + } + }else if (mName.find("enable")==0 && mArgs.size()==1){ + mPropertyName=mName.substr(6,string::npos); + if (!mPropertyName.empty()){ + mPropertyName[0]=tolower(mPropertyName[0]); + mPropertyBehaviour=Write; + } + }else if (mName.find("set")==0 && mArgs.size()==1){ + mPropertyName=mName.substr(3,string::npos); + if (!mPropertyName.empty()){ + mPropertyName[0]=tolower(mPropertyName[0]); + mPropertyBehaviour=Write; + } + }else if ((enabled_pos=mName.rfind("Enabled"))!=string::npos && mArgs.size()==0){ + size_t goodpos=mName.size()-7; + if (enabled_pos==goodpos){ + mPropertyName=mName.substr(0,goodpos); + if (!mPropertyName.empty()){ + mPropertyBehaviour=Read; + } + } + } + if (mPropertyBehaviour==None) + mPropertyName=""; + } string mUid; Argument *mReturn; string mName; list mArgs; string mHelp; + string mPropertyName; /*if it can be a property*/ + PropertyBehaviour mPropertyBehaviour; + bool mConst; + bool mStatic; }; +class Property{ +public: + enum Attribute{ + ReadOnly, + ReadWrite + }; + Property(Attribute attr, const string &name, Type *type, const string &help) : mAttr(attr), mName(name), mType(type), mHelp(help){ + } + const string &getName()const{ + return mName; + } + const string &getHelp()const{ + return mHelp; + } + void setHelp(const string &help){ + mHelp=help; + } + Attribute getAttribute()const{ + return mAttr; + } + void setAttribute(Attribute attr){ + mAttr=attr; + } + Type* getType()const{ + return mType; + } +private: + Attribute mAttr; + string mName; + Type *mType; + string mHelp; +}; + +/*actually a class or an enum*/ class Class{ public: Class(const std::string &name): mName(name){ } + Type::BasicType getType(){ + return Type::getType(mName)->getBasicType(); + } void addMethod(Method *method){ - mMethods.push_back(method); + if (mMethods.find(method->getName())==mMethods.end()) + mMethods.insert(make_pair(method->getName(),method)); } void setHelp(const std::string &help){ mHelp=help; } + const list getMethods()const{ + list ret; + map::const_iterator it; + for(it=mMethods.begin();it!=mMethods.end();++it){ + ret.push_back((*it).second); + } + return ret; + } + const string &getName()const{ + return mName; + } + const string &getHelp()const{ + return mHelp; + } + const list getProperties(){ + list ret; + map::const_iterator it; + for(it=mProperties.begin();it!=mProperties.end();++it){ + ret.push_back((*it).second); + } + return ret; + } + void computeProperties(){ + map::const_iterator it; + Property *prop; + for (it=mMethods.begin();it!=mMethods.end();++it){ + Method *m=(*it).second; + if (m->getPropertyBehaviour()==Method::Read){ + prop=mProperties[m->getPropertyName()]; + if (prop==NULL){ + prop=new Property(Property::ReadOnly,m->getPropertyName(),m->getReturnArg()->getType(), m->getHelp()); + mProperties[m->getPropertyName()]=prop; + } + }else if (m->getPropertyBehaviour()==Method::Write){ + prop=mProperties[m->getPropertyName()]; + if (prop==NULL){ + prop=new Property(Property::ReadWrite,m->getPropertyName(),m->getArgs().front()->getType(), m->getHelp()); + mProperties[m->getPropertyName()]=prop; + }else{ + prop->setHelp(m->getHelp()); + prop->setAttribute(Property::ReadWrite); + } + } + } + } private: - list mMethods; + map mMethods; + map mProperties; string mName; string mHelp; }; class Project{ public: + Project(const string &name="wrapper") : mName(name){ + } Class *getClass(const std::string &name){ Class *ret; if ((ret=mClasses[name])==NULL){ @@ -145,8 +347,280 @@ public: } return ret; } + list getClasses()const{ + list ret; + map::const_iterator it; + for(it=mClasses.begin();it!=mClasses.end();++it){ + ret.push_back((*it).second); + } + return ret; + } + const string &getName()const{ + return mName; + } + void analyse(){ + list classes=getClasses(); + for_each(classes.begin(),classes.end(),mem_fun(&Class::computeProperties)); + } private: map mClasses; + string mName; +}; + +class OutputGenerator{ +public: + virtual void generate(Project *proj)=0; +}; + +class CplusplusGenerator : public OutputGenerator{ +public: + CplusplusGenerator(){ + } + virtual void generate(Project *proj){ + list classes=proj->getClasses(); + mCurProj=proj; +#ifndef WIN32 + mkdir(proj->getName().c_str(),S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IROTH); +#else + _mkdir(proj->getName().c_str()); +#endif + for_each(classes.begin(),classes.end(),bind1st(mem_fun(&CplusplusGenerator::writeClass),this)); + } +private: + void writeClass(Class *klass){ + ostringstream filename; + + if (klass->getType()!=Type::Class) return; + filename<getName()<<"/"<getName()<<".hh"; + mOutfile.open(filename.str().c_str()); + if (!mOutfile.is_open()){ + cerr<<"Could not write into "< &methods=klass->getMethods(); + mCurClass=klass; + mOutfile<<"/* Wrapper generated by lp-gen-wrappers, do not edit*/"<"<getName().empty()) + mOutfile<<"namespace "<getName()<<"{"<getName()<<"{"<getName().empty()) + mOutfile<<"} //end of namespace "<getName()<getType(); + + if (type->getBasicType()==Type::Class){ + if (arg->isConst()){ + mOutfile<<"const "; + } + mOutfile<getName(); + if (arg->isPointer()) + mOutfile<<"*"; + }else if (type->getBasicType()==Type::Integer){ + mOutfile<<"int"; + }else if (type->getBasicType()==Type::Enum){ + mOutfile<getName(); + }else if (type->getBasicType()==Type::String){ + if (!isReturn) + mOutfile<<"const std::string &"; + else + mOutfile<<"std::string"; + }else if (type->getBasicType()==Type::Void){ + mOutfile<<"void"; + }else if (type->getBasicType()==Type::Boolean){ + mOutfile<<"bool"; + } + if (!isReturn && !arg->getName().empty()) + mOutfile<<" "<getName(); + } + void writeTabs(int ntabs){ + int i; + for(i=0;i100 && comment[i]==' ')){ + mOutfile<getReturnArg(); + const list &args=method->getArgs(); + list::const_iterator it; + + writeTabs(1); + mOutfile<<"/**"<getHelp(),1); + mOutfile<getName()<<"("; + + for(it=args.begin();it!=args.end();++it){ + if (it!=args.begin()) mOutfile<<", "; + writeArgument(*it); + } + mOutfile<<")"; + if (method->isConst()) mOutfile<<"const"; + mOutfile<<";"< classes=proj->getClasses(); + mCurProj=proj; +#ifndef WIN32 + mkdir(proj->getName().c_str(),S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IROTH); +#else + _mkdir(proj->getName().c_str()); +#endif + for_each(classes.begin(),classes.end(),bind1st(mem_fun(&JavascriptGenerator::writeClass),this)); + } +private: + void writeClass(Class *klass){ + ostringstream filename; + + if (klass->getType()!=Type::Class) return; + filename<getName()<<"/"<getName()<<".js"; + mOutfile.open(filename.str().c_str()); + if (!mOutfile.is_open()){ + cerr<<"Could not write into "< &methods=klass->getMethods(); + mCurClass=klass; + mOutfile<<"/* Wrapper generated by lp-gen-wrappers, do not edit*/"<getName().empty()) + // mOutfile<<"namespace "<getName()<<"{"<getName()<getHelp()< properties=klass->getProperties(); + for_each(properties.begin(),properties.end(),bind1st(mem_fun(&JavascriptGenerator::writeProperty),this)); + mOutfile<getName().empty()) + // mOutfile<<"} //end of namespace "<getName()<getBasicType()){ + case Type::Float: + case Type::Integer: + mOutfile<<"number"; + break; + case Type::String: + mOutfile<<"string"; + break; + case Type::Boolean: + mOutfile<<"boolean"; + break; + case Type::Class: + case Type::Enum: + mOutfile<<"external:"<getName(); + break; + case Type::Void: + mOutfile<<"void"; + break; + } + } + void writeArgument(Argument *arg, bool isReturn=false){ + if (!isReturn){ + mOutfile<<" * @param {"; + writeType(arg->getType()); + mOutfile<<"} "<getName()<<" - "<getHelp()<getType()); + mOutfile<<"} "<getHelp()<100 && comment[i]==' ')){ + mOutfile<getHelp(),0); + mOutfile<getType()); + mOutfile<<"} external:"<getName()<<"#"<getName()<getAttribute()==Property::ReadOnly) + mOutfile<<" * @readonly"<getReturnArg(); + const list &args=method->getArgs(); + list::const_iterator it; + + if (method->getPropertyBehaviour()!=Method::None) return; + if (method->getName()=="ref" || method->getName()=="unref") return; + + mOutfile<<"/**"<getHelp(),1); + mOutfile<getName()<<"#"<getName()<getBasicType()<<" "<getName()< args; + string help; for (cur_node = node->children; cur_node != NULL ; cur_node = cur_node->next){ if (strcmp((const char*)cur_node->name,"name")==0){ @@ -265,19 +754,42 @@ static void parseFunction(Project *proj, xmlNode *node){ name=(const char*)content; xmlFree(content); }else if (strcmp((const char*)cur_node->name,"param")==0){ - if (first_arg==NULL){ - first_arg=parseArgument(cur_node); - } + Argument *a=parseArgument(cur_node,false); + if (a) args.push_back(a); + else return; + }else if (strcmp((const char*)cur_node->name,"detaileddescription")==0){ + help=findChildContent(cur_node,"para"); } } + retarg=parseArgument(node,true); + if (!retarg){ + cerr<<"Could not parse return argument of function "<getType()->getBasicType()!=Type::Class) return; className=first_arg->getType()->getName(); methodName=extractMethodName(name,className); - if (!methodName.empty()){ + if (!methodName.empty() && methodName!="destroy"){ cout<<"Found "<isConst(),false); + method->setHelp(help); + proj->getClass(className)->addMethod(method); + delete first_arg; + } +} + +static void parseTypedef(Project *proj, xmlNode *node){ + string typecontent=findChildContent(node,"type"); + string name=findChildContent(node,"name"); + if (typecontent.find("enum")==0){ + Type::addType(Type::Enum,name); } } @@ -293,9 +805,13 @@ static void parseMemberDef(Project *proj, xmlNode *node){ return; kind=xmlGetProp(node,(const xmlChar*)"kind"); - //cout<<"Kind="<<(const char*)kind< files; + list::iterator it; LIBXML_TEST_VERSION for(i=1;ianalyse(); + gen->generate(proj); return 0; -} \ No newline at end of file +}