Fix bare raw pointers (switch to *const T)

cadencemarseille · cadencemarseille · commit d3079a1857bd · 2014-06-29T18:27:04.000-04:00
diff --git a/pkg.rs b/pkg.rs
@@ -116,11 +116,11 @@ struct pcre_extra;
 
 #[link(name = \"pcre\")]
 extern {{
-    static pcre_free: extern \"C\" fn(ptr: *c_void);
+    static pcre_free: extern \"C\" fn(ptr: *const c_void);
 
-    fn pcre_compile(pattern: *c_char, options: options, errptr: *mut *c_char, erroffset: *mut c_int, tableptr: *c_uchar) -> *pcre;
-    fn pcre_exec(code: *pcre, extra: *pcre_extra, subject: *c_char, length: c_int, startoffset: c_int, options: options, ovector: *mut c_int, ovecsize: c_int) -> c_int;
-    fn pcre_version() -> *c_char;
+    fn pcre_compile(pattern: *const c_char, options: options, errptr: *mut *const c_char, erroffset: *mut c_int, tableptr: *const c_uchar) -> *const pcre;
+    fn pcre_exec(code: *const pcre, extra: *const pcre_extra, subject: *const c_char, length: c_int, startoffset: c_int, options: options, ovector: *mut c_int, ovecsize: c_int) -> c_int;
+    fn pcre_version() -> *const c_char;
 }}
 
 fn main () {{
@@ -130,7 +130,7 @@ fn main () {{
 
         let pattern = \"^\\\\d+\\\\.\\\\d+\";
         pattern.with_c_str(|pattern_c_str| {{
-            let mut err: *c_char = ptr::null();
+            let mut err: *const c_char = ptr::null();
             let mut erroffset: c_int = 0;
             let code = pcre_compile(pattern_c_str, 0, &mut err, &mut erroffset, ptr::null());
             if code.is_null() {{
@@ -155,7 +155,7 @@ fn main () {{
                 print!(\"{{}}\", version_str.as_slice().slice_to(*ovector.get(1) as uint));
             }});
 
-            pcre_free(code as *c_void);
+            pcre_free(code as *const c_void);
         }});
     }}
 }}
diff --git a/src/pcre/detail/mod.rs b/src/pcre/detail/mod.rs
@@ -37,10 +37,10 @@ pub static PCRE_INFO_NAMEENTRYSIZE: fullinfo_field = 7;
 pub static PCRE_INFO_NAMECOUNT: fullinfo_field = 8;
 pub static PCRE_INFO_NAMETABLE: fullinfo_field = 9;
 
-pub unsafe fn pcre_compile(pattern: *c_char, options: &EnumSet<::CompileOption>, tableptr: *c_uchar) -> Result<*mut pcre, (Option<String>, c_int)> {
+pub unsafe fn pcre_compile(pattern: *const c_char, options: &EnumSet<::CompileOption>, tableptr: *const c_uchar) -> Result<*mut pcre, (Option<String>, c_int)> {
     assert!(pattern.is_not_null());
     let converted_options = options.iter().fold(0, |converted_options, option| converted_options | (option as compile_options)) | PCRE_UTF8 | PCRE_NO_UTF8_CHECK;
-    let mut err: *c_char = ptr::null();
+    let mut err: *const c_char = ptr::null();
     let mut erroffset: c_int = 0;
     let code = native::pcre_compile(pattern, converted_options, &mut err, &mut erroffset, tableptr);
 
@@ -64,7 +64,7 @@ pub unsafe fn pcre_compile(pattern: *c_char, options: &EnumSet<::CompileOption>,
     }
 }
 
-pub unsafe fn pcre_exec(code: *pcre, extra: *::PcreExtra, subject: *c_char, length: c_int, startoffset: c_int, options: &EnumSet<::ExecOption>, ovector: *mut c_int, ovecsize: c_int) -> c_int {
+pub unsafe fn pcre_exec(code: *const pcre, extra: *const ::PcreExtra, subject: *const c_char, length: c_int, startoffset: c_int, options: &EnumSet<::ExecOption>, ovector: *mut c_int, ovecsize: c_int) -> c_int {
     assert!(code.is_not_null());
     assert!(ovecsize >= 0 && ovecsize % 3 == 0);
     let converted_options = options.iter().fold(0, |converted_options, option| converted_options | (option as compile_options)) | PCRE_NO_UTF8_CHECK;
@@ -86,7 +86,7 @@ pub unsafe fn pcre_free_study(extra: *mut ::PcreExtra) {
     native::pcre_free_study(extra);
 }
 
-pub unsafe fn pcre_fullinfo(code: *pcre, extra: *::PcreExtra, what: fullinfo_field, where: *mut c_void) {
+pub unsafe fn pcre_fullinfo(code: *const pcre, extra: *const ::PcreExtra, what: fullinfo_field, where: *mut c_void) {
     assert!(code.is_not_null());
     let rc = native::pcre_fullinfo(code, extra, what, where);
     if rc < 0 && rc != PCRE_ERROR_NULL {
@@ -105,10 +105,10 @@ pub unsafe fn pcre_refcount(code: *mut ::detail::pcre, adjust: c_int) -> c_int {
     native::pcre_refcount(code, adjust)
 }
 
-pub unsafe fn pcre_study(code: *::detail::pcre, options: &EnumSet<::StudyOption>) -> *mut ::PcreExtra {
+pub unsafe fn pcre_study(code: *const ::detail::pcre, options: &EnumSet<::StudyOption>) -> *mut ::PcreExtra {
     assert!(code.is_not_null());
     let converted_options = options.iter().fold(0, |converted_options, option| converted_options | (option as study_options));
-    let mut err: *c_char = ptr::null();
+    let mut err: *const c_char = ptr::null();
     let extra = native::pcre_study(code, converted_options, &mut err);
     // "The third argument for pcre_study() is a pointer for an error message. If
     // studying succeeds (even if no data is returned), the variable it points to is
diff --git a/src/pcre/detail/native.rs b/src/pcre/detail/native.rs
@@ -12,12 +12,12 @@ use libc::{c_char, c_int, c_uchar, c_void};
 extern {
     pub static pcre_free: extern "C" fn(ptr: *mut c_void);
 
-    pub fn pcre_compile(pattern: *c_char, options: ::detail::compile_options, errptr: *mut *c_char, erroffset: *mut c_int, tableptr: *c_uchar) -> *mut ::detail::pcre;
-    pub fn pcre_exec(code: *::detail::pcre, extra: *::PcreExtra, subject: *c_char, length: c_int, startoffset: c_int, options: ::detail::exec_options, ovector: *mut c_int, ovecsize: c_int) -> c_int;
+    pub fn pcre_compile(pattern: *const c_char, options: ::detail::compile_options, errptr: *mut *const c_char, erroffset: *mut c_int, tableptr: *const c_uchar) -> *mut ::detail::pcre;
+    pub fn pcre_exec(code: *const ::detail::pcre, extra: *const ::PcreExtra, subject: *const c_char, length: c_int, startoffset: c_int, options: ::detail::exec_options, ovector: *mut c_int, ovecsize: c_int) -> c_int;
     pub fn pcre_free_study(extra: *mut ::PcreExtra);
-    pub fn pcre_fullinfo(code: *::detail::pcre, extra: *::PcreExtra, what: ::detail::fullinfo_field, where: *mut c_void) -> c_int;
+    pub fn pcre_fullinfo(code: *const ::detail::pcre, extra: *const ::PcreExtra, what: ::detail::fullinfo_field, where: *mut c_void) -> c_int;
     // Note: libpcre's pcre_refcount() function is not thread-safe.
     pub fn pcre_refcount(code: *mut ::detail::pcre, adjust: c_int) -> c_int;
-    pub fn pcre_study(code: *::detail::pcre, options: ::detail::study_options, errptr: *mut *c_char) -> *mut ::PcreExtra;
-    pub fn pcre_version() -> *c_char;
+    pub fn pcre_study(code: *const ::detail::pcre, options: ::detail::study_options, errptr: *mut *const c_char) -> *mut ::PcreExtra;
+    pub fn pcre_version() -> *const c_char;
 }
diff --git a/src/pcre/mod.rs b/src/pcre/mod.rs
@@ -110,7 +110,7 @@ pub struct CompilationError {
 #[deriving(Show)]
 pub struct Pcre {
 
-    code: *detail::pcre,
+    code: *const detail::pcre,
 
     extra: *mut PcreExtra,
 
@@ -127,7 +127,7 @@ pub struct PcreExtra {
     study_data: *mut c_void,
     match_limit_: c_ulong,
     callout_data: *mut c_void,
-    tables: *c_uchar,
+    tables: *const c_uchar,
     match_limit_recursion_: c_ulong,
     mark: *mut *mut c_uchar,
     executable_jit: *mut c_void
@@ -148,9 +148,9 @@ pub struct Match<'a> {
 /// Iterator type for iterating matches within a subject string.
 pub struct MatchIterator<'a> {
 
-    code: *detail::pcre,
+    code: *const detail::pcre,
 
-    extra: *PcreExtra,
+    extra: *const PcreExtra,
 
     capture_count: c_int,
 
@@ -353,22 +353,22 @@ impl Pcre {
         pattern.with_c_str(|pattern_c_str| {
             unsafe {
                 // Use the default character tables.
-                let tableptr: *c_uchar = ptr::null();
+                let tableptr: *const c_uchar = ptr::null();
                 match detail::pcre_compile(pattern_c_str, options, tableptr) {
                     Err((opt_err, erroffset)) => Err(CompilationError {
                         opt_err: opt_err,
                         erroffset: erroffset
                     }),
                     Ok(mut_code) => {
-                        let code = mut_code as *detail::pcre;
+                        let code = mut_code as *const detail::pcre;
                         assert!(code.is_not_null());
                         // Take a reference.
                         detail::pcre_refcount(code as *mut detail::pcre, 1);
 
                         let extra: *mut PcreExtra = ptr::mut_null();
 
                         let mut capture_count: c_int = 0;
-                        detail::pcre_fullinfo(code, extra as *PcreExtra, detail::PCRE_INFO_CAPTURECOUNT, 
+                        detail::pcre_fullinfo(code, extra as *const PcreExtra, detail::PCRE_INFO_CAPTURECOUNT, 
                             &mut capture_count as *mut c_int as *mut c_void);
 
                         Ok(Pcre {
@@ -492,7 +492,7 @@ impl Pcre {
 
         unsafe {
             subject.with_c_str_unchecked(|subject_c_str| -> Option<Match<'a>> {
-                let rc = detail::pcre_exec(self.code, self.extra as *PcreExtra, subject_c_str, subject.len() as c_int, startoffset as c_int, options, ovector.as_mut_ptr(), ovecsize as c_int);
+                let rc = detail::pcre_exec(self.code, self.extra as *const PcreExtra, subject_c_str, subject.len() as c_int, startoffset as c_int, options, ovector.as_mut_ptr(), ovecsize as c_int);
                 if rc >= 0 {
                     Some(Match {
                         subject: subject,
@@ -519,8 +519,8 @@ impl Pcre {
                 None
             } else {
                 let slice: Slice<c_uchar> = Slice {
-                    data: self.mark_ as *c_uchar,
-                    len: libc::strlen(self.mark_ as *c_char) as uint
+                    data: self.mark_ as *const c_uchar,
+                    len: libc::strlen(self.mark_ as *const c_char) as uint
                 };
                 Some(mem::transmute(slice))
             }
@@ -551,7 +551,7 @@ impl Pcre {
             let ovecsize = (self.capture_count_ + 1) * 3;
             MatchIterator {
                 code: { detail::pcre_refcount(self.code as *mut detail::pcre, 1); self.code },
-                extra: self.extra as *PcreExtra,
+                extra: self.extra as *const PcreExtra,
                 capture_count: self.capture_count_,
                 subject: subject,
                 subject_cstring: subject.to_c_str_unchecked(), // the subject string can contain NUL bytes
@@ -566,7 +566,7 @@ impl Pcre {
     pub fn name_count(&self) -> uint {
         unsafe {
             let mut name_count: c_int = 0;
-            detail::pcre_fullinfo(self.code, self.extra as *PcreExtra, detail::PCRE_INFO_NAMECOUNT, &mut name_count as *mut c_int as *mut c_void);
+            detail::pcre_fullinfo(self.code, self.extra as *const PcreExtra, detail::PCRE_INFO_NAMECOUNT, &mut name_count as *mut c_int as *mut c_void);
             name_count as uint
         }
     }
@@ -580,17 +580,17 @@ impl Pcre {
     pub fn name_table(&self) -> TreeMap<String, Vec<uint>> {
         unsafe {
             let name_count = self.name_count();
-            let mut tabptr: *c_uchar = ptr::null();
-            detail::pcre_fullinfo(self.code, self.extra as *PcreExtra, detail::PCRE_INFO_NAMETABLE, &mut tabptr as *mut *c_uchar as *mut c_void);
+            let mut tabptr: *const c_uchar = ptr::null();
+            detail::pcre_fullinfo(self.code, self.extra as *const PcreExtra, detail::PCRE_INFO_NAMETABLE, &mut tabptr as *mut *const c_uchar as *mut c_void);
             let mut name_entry_size: c_int = 0;
-            detail::pcre_fullinfo(self.code, self.extra as *PcreExtra, detail::PCRE_INFO_NAMEENTRYSIZE, &mut name_entry_size as *mut c_int as *mut c_void);
+            detail::pcre_fullinfo(self.code, self.extra as *const PcreExtra, detail::PCRE_INFO_NAMEENTRYSIZE, &mut name_entry_size as *mut c_int as *mut c_void);
 
             let mut name_table: TreeMap<String, Vec<uint>> = TreeMap::new();
 
             let mut i = 0u;
             while i < name_count {
                 let n: uint = (ptr::read(tabptr) as uint << 8) | (ptr::read(tabptr.offset(1)) as uint);
-                let name_cstring = c_str::CString::new(tabptr.offset(2) as *c_char, false);
+                let name_cstring = c_str::CString::new(tabptr.offset(2) as *const c_char, false);
                 let name: String = name_cstring.as_str().unwrap().to_owned();
                 // TODO Avoid the double lookup.
                 // https://github.com/mozilla/rust/issues/9068
