libcef:

- change 'void *' arguments to 'void* ' to match style requirements.

translator:
- add support for const virtual methods. (Issue # 36)
- output const vector argument types as 'struct _class_t* const*' (cons array, non-const members) instead of 'const struct _class_t**' (non-const array, const members) (Issue # 36)
- always add the 'enum' qualifier when outputting C API enum attribute types. (Issue # 38)
- update translated files.

git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@31 5089003a-bbd8-11dd-ad1f-f1f9622dbc98

include/cef.h

@@ -729,7 +729,7 @@ public:
   // Read up to |size| bytes into |bytes| and return the number of bytes
   // actually read.
   /*--cef()--*/
-  virtual size_t GetBytes(size_t size, void *bytes) =0;
+  virtual size_t GetBytes(size_t size, void* bytes) =0;
 };
 
 
@@ -742,11 +742,11 @@ public:
   /*--cef()--*/
   static CefRefPtr<CefStreamReader> CreateForFile(const std::wstring& fileName);
   /*--cef()--*/
-  static CefRefPtr<CefStreamReader> CreateForData(void *data, size_t size);
+  static CefRefPtr<CefStreamReader> CreateForData(void* data, size_t size);
 
   // Read raw binary data.
   /*--cef()--*/
-  virtual size_t Read(void *ptr, size_t size, size_t n) =0;
+  virtual size_t Read(void* ptr, size_t size, size_t n) =0;
 	
   // Seek to the specified offset position. |whence| may be any one of
   // SEEK_CUR, SEEK_END or SEEK_SET.
@@ -770,7 +770,7 @@ class CefStreamWriter : public CefBase
 public:
   // Write raw binary data.
   /*--cef()--*/
-  virtual size_t Write(const void *ptr, size_t size, size_t n) =0;
+  virtual size_t Write(const void* ptr, size_t size, size_t n) =0;
 	
   // Seek to the specified offset position. |whence| may be any one of
   // SEEK_CUR, SEEK_END or SEEK_SET.

include/cef_capi.h

@@ -352,7 +352,7 @@ typedef struct _cef_handler_t
   enum cef_retval_t (CEF_CALLBACK *handle_before_browse)(
       struct _cef_handler_t* self, struct _cef_browser_t* browser,
       struct _cef_frame_t* frame, struct _cef_request_t* request,
-      cef_handler_navtype_t navType, int isRedirect);
+      enum cef_handler_navtype_t navType, int isRedirect);
 
   // Event called when the browser begins loading a page.  The |frame| pointer
   // will be NULL if the event represents the overall load status and not the
@@ -375,7 +375,7 @@ typedef struct _cef_handler_t
   // Otherwise, return RV_CONTINUE for the default error text.
   enum cef_retval_t (CEF_CALLBACK *handle_load_error)(
       struct _cef_handler_t* self, struct _cef_browser_t* browser,
-      struct _cef_frame_t* frame, cef_handler_errorcode_t errorCode,
+      struct _cef_frame_t* frame, enum cef_handler_errorcode_t errorCode,
       const wchar_t* failedUrl, cef_string_t* errorText);
 
   // Event called before a resource is loaded.  To allow the resource to load
@@ -401,13 +401,13 @@ typedef struct _cef_handler_t
   // alternate text.  The return value is currently ignored.
   enum cef_retval_t (CEF_CALLBACK *handle_get_menu_label)(
       struct _cef_handler_t* self, struct _cef_browser_t* browser,
-      cef_handler_menuid_t menuId, cef_string_t* label);
+      enum cef_handler_menuid_t menuId, cef_string_t* label);
 
   // Event called when an option is selected from the default context menu.
   // Return RV_HANDLED to cancel default handling of the action.
   enum cef_retval_t (CEF_CALLBACK *handle_menu_action)(
       struct _cef_handler_t* self, struct _cef_browser_t* browser,
-      cef_handler_menuid_t menuId);
+      enum cef_handler_menuid_t menuId);
 
   // Event called to format print headers and footers.  |printInfo| contains
   // platform-specific information about the printer context.  |url| is the URL
@@ -584,7 +584,7 @@ typedef struct _cef_post_data_element_t
   // Read up to |size| bytes into |bytes| and return the number of bytes
   // actually read.
   size_t (CEF_CALLBACK *get_bytes)(struct _cef_post_data_element_t* self,
-      size_t size, void *bytes);
+      size_t size, void* bytes);
 
 } cef_post_data_element_t;
 
@@ -600,7 +600,7 @@ typedef struct _cef_stream_reader_t
   cef_base_t base;
 
   // Read raw binary data.
-  size_t (CEF_CALLBACK *read)(struct _cef_stream_reader_t* self, void *ptr,
+  size_t (CEF_CALLBACK *read)(struct _cef_stream_reader_t* self, void* ptr,
       size_t size, size_t n);
 
   // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
@@ -620,7 +620,7 @@ typedef struct _cef_stream_reader_t
 // Create a new cef_stream_reader_t object.
 CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_file(
     const wchar_t* fileName);
-CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_data(void *data,
+CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_data(void* data,
     size_t size);
 
 
@@ -632,7 +632,7 @@ typedef struct _cef_stream_writer_t
 
   // Write raw binary data.
   size_t (CEF_CALLBACK *write)(struct _cef_stream_writer_t* self,
-      const void *ptr, size_t size, size_t n);
+      const void* ptr, size_t size, size_t n);
 
   // Seek to the specified offset position. |whence| may be any one of SEEK_CUR,
   // SEEK_END or SEEK_SET.
@@ -658,7 +658,7 @@ typedef struct _cef_v8handler_t
   // if the function was handled.
   int (CEF_CALLBACK *execute)(struct _cef_v8handler_t* self,
       const wchar_t* name, struct _cef_v8value_t* object, size_t argumentCount,
-      const struct _cef_v8value_t** arguments, struct _cef_v8value_t** retval,
+      struct _cef_v8value_t* const* arguments, struct _cef_v8value_t** retval,
       cef_string_t* exception);
 
 } cef_v8handler_t;
@@ -747,7 +747,7 @@ typedef struct _cef_v8value_t
   // Execute the function.
   int (CEF_CALLBACK *execute_function)(struct _cef_v8value_t* self,
       struct _cef_v8value_t* object, size_t argumentCount,
-      const struct _cef_v8value_t** arguments, struct _cef_v8value_t** retval,
+      struct _cef_v8value_t* const* arguments, struct _cef_v8value_t** retval,
       cef_string_t* exception);
 
 } cef_v8value_t;

libcef/request_impl.cc

@@ -324,7 +324,7 @@ size_t CefPostDataElementImpl::GetBytesCount()
   return size;
 }
 
-size_t CefPostDataElementImpl::GetBytes(size_t size, void *bytes)
+size_t CefPostDataElementImpl::GetBytes(size_t size, void* bytes)
 {
   Lock();
   DCHECK(type_ == PDE_TYPE_BYTES);

libcef/request_impl.h

@@ -73,7 +73,7 @@ public:
   virtual Type GetType();
   virtual std::wstring GetFile();
   virtual size_t GetBytesCount();
-  virtual size_t GetBytes(size_t size, void *bytes);
+  virtual size_t GetBytes(size_t size, void* bytes);
 
   void Set(const net::UploadData::Element& element);
   void Get(net::UploadData::Element& element);

libcef/stream_impl.cc

@@ -19,7 +19,7 @@ CefRefPtr<CefStreamReader> CefStreamReader::CreateForFile(const std::wstring& fi
   return reader;
 }
 
-CefRefPtr<CefStreamReader> CefStreamReader::CreateForData(void *data, size_t size)
+CefRefPtr<CefStreamReader> CefStreamReader::CreateForData(void* data, size_t size)
 {
   DCHECK(data != NULL);
   DCHECK(size > 0);
@@ -45,7 +45,7 @@ CefFileReader::~CefFileReader()
   Unlock();
 }
 
-size_t CefFileReader::Read(void *ptr, size_t size, size_t n)
+size_t CefFileReader::Read(void* ptr, size_t size, size_t n)
 {
   Lock();
   size_t rv = fread(ptr, size, n, file_);
@@ -93,7 +93,7 @@ CefFileWriter::~CefFileWriter()
   Unlock();
 }
 
-size_t CefFileWriter::Write(const void *ptr, size_t size, size_t n)
+size_t CefFileWriter::Write(const void* ptr, size_t size, size_t n)
 {
   Lock();
   size_t rv = (size_t)fwrite(ptr, size, n, file_);
@@ -128,7 +128,7 @@ int CefFileWriter::Flush()
 
 // CefBytesReader
 
-CefBytesReader::CefBytesReader(void *data, long datasize, bool copy)
+CefBytesReader::CefBytesReader(void* data, long datasize, bool copy)
   : data_(NULL), datasize_(0), copy_(false), offset_(0)
 {
   SetData(data, datasize, copy);
@@ -139,7 +139,7 @@ CefBytesReader::~CefBytesReader()
   SetData(NULL, 0, false);
 }
 
-size_t CefBytesReader::Read(void *ptr, size_t size, size_t n)
+size_t CefBytesReader::Read(void* ptr, size_t size, size_t n)
 {
   Lock();
   size_t s = (datasize_ - offset_) / size;
@@ -197,7 +197,7 @@ int CefBytesReader::Eof()
   return rv;
 }
 	
-void CefBytesReader::SetData(void *data, long datasize, bool copy)
+void CefBytesReader::SetData(void* data, long datasize, bool copy)
 {
   Lock();
   if(copy_)
@@ -237,7 +237,7 @@ CefBytesWriter::~CefBytesWriter()
   Unlock();
 }
 
-size_t CefBytesWriter::Write(const void *ptr, size_t size, size_t n)
+size_t CefBytesWriter::Write(const void* ptr, size_t size, size_t n)
 {
   Lock();
   size_t rv;
@@ -309,7 +309,7 @@ size_t CefBytesWriter::Grow(size_t size)
   Lock();
   size_t rv;
   size_t s = (size > grow_ ? size : grow_);
-	void *tmp = realloc(data_, datasize_ + s);
+	void* tmp = realloc(data_, datasize_ + s);
   DCHECK(tmp != NULL);
 	if(tmp) {
 	  data_ = tmp;

libcef/stream_impl.h

@@ -15,7 +15,7 @@ public:
   CefFileReader(FILE* file, bool close);
   ~CefFileReader();
 
-  virtual size_t Read(void *ptr, size_t size, size_t n);
+  virtual size_t Read(void* ptr, size_t size, size_t n);
   virtual int Seek(long offset, int whence);
   virtual long Tell();
   virtual int Eof();
@@ -32,7 +32,7 @@ public:
   CefFileWriter(FILE* file, bool close);
   ~CefFileWriter();
 
-  virtual size_t Write(const void *ptr, size_t size, size_t n);
+  virtual size_t Write(const void* ptr, size_t size, size_t n);
   virtual int Seek(long offset, int whence);
   virtual long Tell();
   virtual int Flush();
@@ -46,21 +46,21 @@ protected:
 class CefBytesReader : public CefThreadSafeBase<CefStreamReader>
 {
 public:
-  CefBytesReader(void *data, long datasize, bool copy);
+  CefBytesReader(void* data, long datasize, bool copy);
   ~CefBytesReader();
 
-  virtual size_t Read(void *ptr, size_t size, size_t n);
+  virtual size_t Read(void* ptr, size_t size, size_t n);
   virtual int Seek(long offset, int whence);
   virtual long Tell();
   virtual int Eof();
 	
-  void SetData(void *data, long datasize, bool copy);
+  void SetData(void* data, long datasize, bool copy);
 
-  void *GetData() { return data_; }
+  void* GetData() { return data_; }
   size_t GetDataSize() { return offset_; }
 
 protected:
-	void *data_;
+	void* data_;
 	size_t datasize_;
   bool copy_;
 	size_t offset_;
@@ -73,12 +73,12 @@ public:
   CefBytesWriter(size_t grow);
   ~CefBytesWriter();
 
-  virtual size_t Write(const void *ptr, size_t size, size_t n);
+  virtual size_t Write(const void* ptr, size_t size, size_t n);
   virtual int Seek(long offset, int whence);
   virtual long Tell();
   virtual int Flush();
 
-  void *GetData() { return data_; }
+  void* GetData() { return data_; }
 	size_t GetDataSize() { return offset_; }
   std::string GetDataString();
 	
@@ -87,7 +87,7 @@ protected:
 
 protected:
   size_t grow_;
-  void *data_;
+  void* data_;
   size_t datasize_;
   size_t offset_;
 };

libcef_dll/cpptoc/handler_cpptoc.cc

@@ -118,7 +118,7 @@ enum cef_retval_t CEF_CALLBACK handler_handle_title_change(
 
 enum cef_retval_t CEF_CALLBACK handler_handle_before_browse(
     struct _cef_handler_t* self, cef_browser_t* browser, cef_frame_t* frame,
-    struct _cef_request_t* request, cef_handler_navtype_t navType,
+    struct _cef_request_t* request, enum cef_handler_navtype_t navType,
     int isRedirect)
 {
   DCHECK(self);
@@ -167,7 +167,7 @@ enum cef_retval_t CEF_CALLBACK handler_handle_load_end(
 
 enum cef_retval_t CEF_CALLBACK handler_handle_load_error(
     struct _cef_handler_t* self, cef_browser_t* browser, cef_frame_t* frame,
-    cef_handler_errorcode_t errorCode, const wchar_t* failedUrl,
+    enum cef_handler_errorcode_t errorCode, const wchar_t* failedUrl,
     cef_string_t* errorText)
 {
   DCHECK(self);
@@ -245,7 +245,7 @@ enum cef_retval_t CEF_CALLBACK handler_handle_before_menu(
 
 enum cef_retval_t CEF_CALLBACK handler_handle_get_menu_label(
     struct _cef_handler_t* self, cef_browser_t* browser,
-    cef_handler_menuid_t menuId, cef_string_t* label)
+    enum cef_handler_menuid_t menuId, cef_string_t* label)
 {
   DCHECK(self);
   DCHECK(browser);
@@ -267,7 +267,7 @@ enum cef_retval_t CEF_CALLBACK handler_handle_get_menu_label(
 
 enum cef_retval_t CEF_CALLBACK handler_handle_menu_action(
     struct _cef_handler_t* self, cef_browser_t* browser,
-    cef_handler_menuid_t menuId)
+    enum cef_handler_menuid_t menuId)
 {
   DCHECK(self);
   DCHECK(browser);

libcef_dll/cpptoc/post_data_element_cpptoc.cc

@@ -97,7 +97,7 @@ size_t CEF_CALLBACK post_data_element_get_bytes_count(
 }
 
 size_t CEF_CALLBACK post_data_element_get_bytes(
-    struct _cef_post_data_element_t* self, size_t size, void *bytes)
+    struct _cef_post_data_element_t* self, size_t size, void* bytes)
 {
   DCHECK(self);
   if(!self)

libcef_dll/cpptoc/stream_reader_cpptoc.cc

@@ -28,7 +28,7 @@ CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_file(
   return NULL;
 }
 
-CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_data(void *data,
+CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_data(void* data,
     size_t size)
 {
   CefRefPtr<CefStreamReader> impl = CefStreamReader::CreateForData(data, size);
@@ -41,7 +41,7 @@ CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_data(void *data,
 // MEMBER FUNCTIONS - Body may be edited by hand.
 
 size_t CEF_CALLBACK stream_reader_read(struct _cef_stream_reader_t* self,
-    void *ptr, size_t size, size_t n)
+    void* ptr, size_t size, size_t n)
 {
   DCHECK(self);
   if(!self)

libcef_dll/cpptoc/stream_writer_cpptoc.cc

@@ -17,7 +17,7 @@
 // MEMBER FUNCTIONS - Body may be edited by hand.
 
 size_t CEF_CALLBACK stream_writer_write(struct _cef_stream_writer_t* self,
-    const void *ptr, size_t size, size_t n)
+    const void* ptr, size_t size, size_t n)
 {
   DCHECK(self);
   if(!self)

libcef_dll/cpptoc/v8handler_cpptoc.cc

@@ -19,7 +19,7 @@
 
 int CEF_CALLBACK v8handler_execute(struct _cef_v8handler_t* self,
     const wchar_t* name, struct _cef_v8value_t* object, size_t argumentCount,
-    const struct _cef_v8value_t** arguments, struct _cef_v8value_t** retval,
+    struct _cef_v8value_t* const* arguments, struct _cef_v8value_t** retval,
     cef_string_t* exception)
 {
   DCHECK(self);
@@ -36,8 +36,7 @@ int CEF_CALLBACK v8handler_execute(struct _cef_v8handler_t* self,
 
   CefV8ValueList list;
   for(size_t i = 0; i < argumentCount; ++i) {
-    list.push_back(CefV8ValueCToCpp::Wrap(
-        const_cast<cef_v8value_t*>(arguments[i])));
+    list.push_back(CefV8ValueCToCpp::Wrap(arguments[i]));
   }
 
   CefRefPtr<CefV8Value> retValPtr;

libcef_dll/cpptoc/v8value_cpptoc.cc

@@ -396,7 +396,7 @@ cef_v8handler_t* CEF_CALLBACK v8value_get_function_handler(
 
 int CEF_CALLBACK v8value_execute_function(struct _cef_v8value_t* self,
     struct _cef_v8value_t* object, size_t argumentCount,
-    const struct _cef_v8value_t** arguments, struct _cef_v8value_t** retval,
+    struct _cef_v8value_t* const* arguments, struct _cef_v8value_t** retval,
     cef_string_t* exception)
 {
   DCHECK(self);
@@ -407,8 +407,7 @@ int CEF_CALLBACK v8value_execute_function(struct _cef_v8value_t* self,
   CefRefPtr<CefV8Value> objectPtr = CefV8ValueCppToC::Unwrap(object);
   CefV8ValueList argsList;
   for(size_t i = 0; i < argumentCount; i++) {
-    argsList.push_back(CefV8ValueCppToC::Unwrap(
-        const_cast<cef_v8value_t*>(arguments[i])));
+    argsList.push_back(CefV8ValueCppToC::Unwrap(arguments[i]));
   }
   CefRefPtr<CefV8Value> retvalPtr;
   std::wstring exceptionStr;

libcef_dll/ctocpp/post_data_element_ctocpp.cc

@@ -82,7 +82,7 @@ size_t CefPostDataElementCToCpp::GetBytesCount()
   return struct_->get_bytes_count(struct_);
 }
 
-size_t CefPostDataElementCToCpp::GetBytes(size_t size, void *bytes)
+size_t CefPostDataElementCToCpp::GetBytes(size_t size, void* bytes)
 {
   if(CEF_MEMBER_MISSING(struct_, get_bytes))
     return 0;

libcef_dll/ctocpp/post_data_element_ctocpp.h

@@ -39,7 +39,7 @@ public:
   virtual Type GetType();
   virtual std::wstring GetFile();
   virtual size_t GetBytesCount();
-  virtual size_t GetBytes(size_t size, void *bytes);
+  virtual size_t GetBytes(size_t size, void* bytes);
 };
 
 #endif // USING_CEF_SHARED

libcef_dll/ctocpp/stream_reader_ctocpp.cc

@@ -26,7 +26,7 @@ CefRefPtr<CefStreamReader> CefStreamReader::CreateForFile(
   return NULL;
 }
 
-CefRefPtr<CefStreamReader> CefStreamReader::CreateForData(void *data,
+CefRefPtr<CefStreamReader> CefStreamReader::CreateForData(void* data,
     size_t size)
 {
   cef_stream_reader_t* impl = cef_stream_reader_create_for_data(data, size);
@@ -38,7 +38,7 @@ CefRefPtr<CefStreamReader> CefStreamReader::CreateForData(void *data,
 
 // VIRTUAL METHODS - Body may be edited by hand.
 
-size_t CefStreamReaderCToCpp::Read(void *ptr, size_t size, size_t n)
+size_t CefStreamReaderCToCpp::Read(void* ptr, size_t size, size_t n)
 {
   if(CEF_MEMBER_MISSING(struct_, read))
     return 0;

libcef_dll/ctocpp/stream_reader_ctocpp.h

@@ -33,7 +33,7 @@ public:
   virtual ~CefStreamReaderCToCpp() {}
 
   // CefStreamReader methods
-  virtual size_t Read(void *ptr, size_t size, size_t n);
+  virtual size_t Read(void* ptr, size_t size, size_t n);
   virtual int Seek(long offset, int whence);
   virtual long Tell();
   virtual int Eof();

libcef_dll/ctocpp/stream_writer_ctocpp.cc

@@ -16,7 +16,7 @@
 
 // VIRTUAL METHODS - Body may be edited by hand.
 
-size_t CefStreamWriterCToCpp::Write(const void *ptr, size_t size, size_t n)
+size_t CefStreamWriterCToCpp::Write(const void* ptr, size_t size, size_t n)
 {
   if(CEF_MEMBER_MISSING(struct_, write))
     return 0;

libcef_dll/ctocpp/stream_writer_ctocpp.h

@@ -33,7 +33,7 @@ public:
   virtual ~CefStreamWriterCToCpp() {}
 
   // CefStreamWriter methods
-  virtual size_t Write(const void *ptr, size_t size, size_t n);
+  virtual size_t Write(const void* ptr, size_t size, size_t n);
   virtual int Seek(long offset, int whence);
   virtual long Tell();
   virtual int Flush();

libcef_dll/ctocpp/v8handler_ctocpp.cc

@@ -36,8 +36,7 @@ bool CefV8HandlerCToCpp::Execute(const std::wstring& name,
   cef_string_t exceptionStr = NULL;
 
   int rv = struct_->execute(struct_, name.c_str(),
-      CefV8ValueCppToC::Wrap(object), argsSize,
-      const_cast<const cef_v8value_t**>(argsStructPtr), &retvalStruct,
+      CefV8ValueCppToC::Wrap(object), argsSize, argsStructPtr, &retvalStruct,
       &exceptionStr);
   if(retvalStruct)
     retval = CefV8ValueCppToC::Unwrap(retvalStruct);

libcef_dll/ctocpp/v8value_ctocpp.cc

@@ -369,8 +369,7 @@ bool CefV8ValueCToCpp::ExecuteFunction(CefRefPtr<CefV8Value> object,
   cef_string_t exceptionStr = NULL;
 
   int rv = struct_->execute_function(struct_, CefV8ValueCToCpp::Unwrap(object),
-      argsSize, const_cast<const cef_v8value_t**>(argsStructPtr), &retvalStruct,
-      &exceptionStr);
+      argsSize, argsStructPtr, &retvalStruct, &exceptionStr);
   if(retvalStruct)
     retval = CefV8ValueCToCpp::Wrap(retvalStruct);
   if(exceptionStr) {

tools/cef_parser.py

@@ -341,6 +341,8 @@ _cre_cfname = '([A-Za-z0-9_]{1,})'
 _cre_retval = '([A-Za-z0-9_<>:,\*\&]{1,})'
 # regex for matching function return value and name combination
 _cre_func   = '([A-Za-z][A-Za-z0-9_<>:,\*\& ]{1,})'
+# regex for matching virtual function modifiers
+_cre_vfmod = '([A-Za-z0-9_]{0,})'
 # regex for matching arbitrary whitespace
 _cre_space =  '[\s]{1,}'
 
@@ -351,14 +353,14 @@ def get_function_impls(content, ident):
     the value.
     """
     # extract the functions
-    p = re.compile('\n'+_cre_func+'\((.*?)\)'
-                   + _cre_space+'\{(.*?)\n\}',
+    p = re.compile('\n'+_cre_func+'\((.*?)\)([A-Za-z0-9_\s]{0,})'+
+                   '\{(.*?)\n\}',
                    re.MULTILINE | re.DOTALL)
     list = p.findall(content)
 
     # build the function map with the function name as the key
     result = []
-    for retval, argval, body in list:
+    for retval, argval, vfmod, body in list:
         if retval.find(ident) < 0:
             # the identifier was not found
             continue
@@ -384,6 +386,7 @@ def get_function_impls(content, ident):
             'retval' : string.strip(retval),
             'name' : name,
             'args' : args,
+            'vfmod' : string.strip(vfmod),
             'body' : body
         })
     
@@ -591,22 +594,23 @@ class obj_class:
         # build the static function objects
         self.staticfuncs = []
         for attrib, retval, argval in list:
-            comment = get_comment(body, retval+'('+argval+');')
+            comment = get_comment(body, retval+'('+argval+')')
             self.staticfuncs.append(
                 obj_function_static(self, attrib, retval, argval, comment))
         
         # extract virtual functions
         p = re.compile('\n'+_cre_space+_cre_attrib+'\n'+_cre_space+'virtual'+
-                       _cre_space+_cre_func+'\((.*?)\)',
+                       _cre_space+_cre_func+'\((.*?)\)'+_cre_space+_cre_vfmod,
                        re.MULTILINE | re.DOTALL)
         list = p.findall(body)
         
         # build the virtual function objects
         self.virtualfuncs = []
-        for attrib, retval, argval in list:
-            comment = get_comment(body, retval+'('+argval+') =0;')
+        for attrib, retval, argval, vfmod in list:
+            comment = get_comment(body, retval+'('+argval+')')
             self.virtualfuncs.append(
-                obj_function_virtual(self, attrib, retval, argval, comment))
+                obj_function_virtual(self, attrib, retval, argval, comment,
+                                     vfmod))
         
     def __repr__(self):
         result = '/* '+dict_to_str(self.attribs)+' */ class '+self.name+"\n{"
@@ -791,7 +795,11 @@ class obj_function:
         
         if isinstance(self, obj_function_virtual):
             # virtual functions get themselves as the first argument
-            args.append('struct _'+self.parent.get_capi_name()+'* self')
+            str = 'struct _'+self.parent.get_capi_name()+'* self'
+            if isinstance(self, obj_function_virtual) and self.is_const():
+                # const virtual functions get const self pointers
+                str = 'const '+str
+            args.append(str)
         
         if len(self.arguments) > 0:
             for cls in self.arguments:
@@ -850,6 +858,8 @@ class obj_function:
         if not classname is None:
             result += classname+'::'
         result += parts['name']+'('+string.join(parts['args'], ', ')+')'
+        if isinstance(self, obj_function_virtual) and self.is_const():
+            result += ' const'
         return result
 
 
@@ -874,13 +884,21 @@ class obj_function_static(obj_function):
 class obj_function_virtual(obj_function):
     """ Class representing a virtual function. """
     
-    def __init__(self, parent, attrib, retval, argval, comment):
+    def __init__(self, parent, attrib, retval, argval, comment, vfmod):
         if not isinstance(parent, obj_class):
             raise Exception('Invalid parent object type')
         obj_function.__init__(self, parent, attrib, retval, argval, comment)
+        if vfmod == 'const':
+            self.isconst = True
+        else:
+            self.isconst = False
     
     def __repr__(self):
         return 'virtual '+obj_function.__repr__(self)+';'
+    
+    def is_const(self):
+        """ Returns true if the method declaration is const. """
+        return self.isconst
 
 
 class obj_argument:
@@ -1049,6 +1067,7 @@ class obj_analysis:
             'int' : 'int',
             'double' : 'double',
             'long' : 'long',
+            'unsigned long' : 'unsigned long',
             'size_t' : 'size_t',
             'bool' : 'int',
             'CefWindowHandle' : 'cef_window_handle_t'
@@ -1150,7 +1169,7 @@ class obj_analysis:
                 result += 'const '
             if not self.result_value in defined_structs:
                 result += 'struct _'
-        elif not self.has_name():
+        else:
             result += 'enum '
         result += self.result_value
         if self.is_byref() or self.is_byaddr():
@@ -1193,13 +1212,11 @@ class obj_analysis:
             result['value'] = value
         elif type == 'refptr':
             str = ''
-            if self.is_const():
-                str += 'const '
             if not value[:-1] in defined_structs:
                 str += 'struct _'
             str += value
             if self.is_const():
-                str += '*'
+                str += ' const*'
             result['value'] = str
         else:
             raise Exception('Unsupported vector type: '+type)

tools/make_ctocpp_impl.py

@@ -6,10 +6,13 @@ from cef_parser import *
 
 def make_ctocpp_impl_proto(clsname, name, func, parts):
     proto = parts['retval']+' '+clsname
+    const = ''
     if isinstance(func, obj_function_virtual):
         proto += 'CToCpp'
+        if func.is_const():
+            const = ' const'
     
-    proto += '::'+name+'('+string.join(parts['args'], ', ')+')'
+    proto += '::'+name+'('+string.join(parts['args'], ', ')+')'+const
     return wrap_code(proto)
 
 def make_ctocpp_impl_existing(clsname, name, func, impl):