Merge pull request tectonic-typesetting#93 from burrbull/lookup

use `Into<Vec<u8>>` instead of `&str`

Author: crlf0710

dpx/src/dpx_otl_conf.rs

@@ -96,9 +96,9 @@ unsafe extern "C" fn parse_uc_coverage(
                 let mut i: i32 = 0;
                 let mut size: i32 = 0;
                 *pp = (*pp).offset(1);
-                let glyphclass = CStr::from_ptr(parse_c_ident(pp, endptr)).to_str().unwrap();
-                let cvalues = pdf_lookup_dict(gclass, glyphclass)
-                    .expect(&format!("{} not defined...", glyphclass));
+                let glyphclass = CStr::from_ptr(parse_c_ident(pp, endptr));
+                let cvalues = pdf_lookup_dict(gclass, glyphclass.to_bytes())
+                    .expect(&format!("{} not defined...", glyphclass.display()));
                 size = pdf_array_length(cvalues) as i32;
                 i = 0i32;
                 while i < size {
@@ -169,13 +169,10 @@ unsafe extern "C" fn add_rule(
     let mut i: i32 = 0;
     let mut n_unicodes: i32 = 0;
     if *first.offset(0) as i32 == '@' as i32 {
-        let s = CStr::from_ptr(first.offset(1)).to_str().unwrap();
-        let glyph1_opt = pdf_lookup_dict(gclass, s);
+        let s = CStr::from_ptr(first.offset(1));
+        let glyph1_opt = pdf_lookup_dict(gclass, s.to_bytes());
         if glyph1_opt.is_none() {
-            warn!(
-                "No glyph class \"{}\" found.",
-                s,
-            );
+            warn!("No glyph class \"{}\" found.", s.display());
             return;
         }
         glyph1 = glyph1_opt.unwrap();
@@ -219,14 +216,10 @@ unsafe extern "C" fn add_rule(
         }
     }
     if *second.offset(0) as i32 == '@' as i32 {
-        let s = CStr::from_ptr(second.offset(1)).to_str().unwrap();
-        let glyph2_opt =
-            pdf_lookup_dict(gclass, s);
+        let s = CStr::from_ptr(second.offset(1));
+        let glyph2_opt = pdf_lookup_dict(gclass, s.to_bytes());
         if glyph2_opt.is_none() {
-            warn!(
-                "No glyph class \"{}\" found.",
-                s,
-            );
+            warn!("No glyph class \"{}\" found.", s.display(),);
             return;
         }
         glyph2 = glyph2_opt.unwrap();
@@ -462,13 +455,13 @@ unsafe extern "C" fn parse_block(
                 });
                 skip_white(pp, endptr);
                 tmp = parse_c_ident(pp, endptr);
-                let tmp_s = CStr::from_ptr(tmp).to_str().unwrap();
+                let tmp_s = CStr::from_ptr(tmp);
                 if verbose > 0i32 {
-                    info!("otl_conf>> Reading option \"{}\"\n", tmp_s,);
+                    info!("otl_conf>> Reading option \"{}\"\n", tmp_s.display(),);
                 }
                 skip_white(pp, endptr);
                 opt_rule = parse_block(gclass, pp, endptr);
-                pdf_add_dict(opt_dict, tmp_s, opt_rule);
+                pdf_add_dict(opt_dict, tmp_s.to_bytes(), opt_rule);
                 free(tmp as *mut libc::c_void);
             } else if token_s == "prefered" || token_s == "required" || token_s == "optional" {
                 let mut rule_block: *mut pdf_obj = 0 as *mut pdf_obj;
@@ -604,8 +597,7 @@ pub unsafe extern "C" fn otl_conf_find_opt(
     let mut options: *mut pdf_obj = 0 as *mut pdf_obj;
     assert!(!conf.is_null());
     if let Some(options) = pdf_lookup_dict(conf, "option").filter(|_| !opt_tag.is_null()) {
-        pdf_lookup_dict(options, CStr::from_ptr(opt_tag).to_str().unwrap())
-            .unwrap_or(0 as *mut pdf_obj)
+        pdf_lookup_dict(options, CStr::from_ptr(opt_tag).to_bytes()).unwrap_or(0 as *mut pdf_obj)
     } else {
         0 as *mut pdf_obj
     }

dpx/src/dpx_pdfdoc.rs

@@ -525,7 +525,7 @@ unsafe extern "C" fn pdf_doc_close_docinfo(mut p: *mut pdf_doc) {
     ];
     let mut value: *mut pdf_obj = 0 as *mut pdf_obj;
     for key in KEYS.iter() {
-        if let Some(value) = pdf_lookup_dict(docinfo, key) {
+        if let Some(value) = pdf_lookup_dict(docinfo, *key) {
             if !(pdf_obj_typeof(value) == PdfObjType::STRING) {
                 warn!("\"{}\" in DocInfo dictionary not string type.", key,);
                 pdf_remove_dict(docinfo, key);
@@ -607,22 +607,22 @@ pub unsafe extern "C" fn pdf_doc_add_page_resource(
         resource_ref = pdf_ref_obj(resource_ref)
         /* leak */
     }
-    let resource_name = CStr::from_ptr(resource_name).to_str().unwrap();
+    let resource_name = CStr::from_ptr(resource_name);
     resources = pdf_doc_get_page_resources(p, category);
-    if pdf_lookup_dict(resources, resource_name)
+    if pdf_lookup_dict(resources, resource_name.to_bytes())
         .filter(|duplicate| pdf_compare_reference(*duplicate, resource_ref) != 0)
         .is_some()
     {
         warn!(
             "Conflicting page resource found (page: {}, category: {}, name: {}).",
             pdf_doc_current_page_number(),
             category,
-            resource_name,
+            resource_name.display(),
         );
         warn!("Ignoring...");
         pdf_release_obj(resource_ref);
     } else {
-        pdf_add_dict(resources, resource_name, resource_ref);
+        pdf_add_dict(resources, resource_name.to_bytes(), resource_ref);
     };
 }
 unsafe extern "C" fn doc_flush_page(

dpx/src/dpx_pdfobj.rs

@@ -1152,15 +1152,17 @@ pub unsafe extern "C" fn pdf_set_string(
     };
 }
 /* Name does *not* include the /. */
-pub unsafe fn pdf_new_name(name: &str) -> *mut pdf_obj {
+pub unsafe fn pdf_new_name<K>(name: K) -> *mut pdf_obj
+where
+    K: Into<Vec<u8>>,
+{
     let mut result: *mut pdf_obj = 0 as *mut pdf_obj;
     let mut data: *mut pdf_name = 0 as *mut pdf_name;
     result = pdf_new_obj(PdfObjType::NAME);
     data = new(::std::mem::size_of::<pdf_name>() as u32) as *mut pdf_name;
     (*result).data = data as *mut libc::c_void;
-    let length = name.len();
     let name = CString::new(name).unwrap();
-    if length != 0 {
+    if name.to_bytes().len() != 0 {
         (*data).name = name.into_raw();
     } else {
         (*data).name = 0 as *mut i8
@@ -1447,12 +1449,10 @@ unsafe extern "C" fn release_dict(mut data: *mut pdf_dict) {
 }
 /* Array is ended by a node with NULL this pointer */
 /* pdf_add_dict returns 0 if the key is new and non-zero otherwise */
-#[no_mangle]
-pub unsafe extern "C" fn pdf_add_dict(
-    mut dict: *mut pdf_obj,
-    key: &str,
-    mut value: *mut pdf_obj,
-) -> i32 {
+pub unsafe fn pdf_add_dict<K>(mut dict: *mut pdf_obj, key: K, mut value: *mut pdf_obj) -> i32
+where
+    K: Into<Vec<u8>> + AsRef<[u8]>,
+{
     let mut data: *mut pdf_dict = 0 as *mut pdf_dict;
     let mut new_node: *mut pdf_dict = 0 as *mut pdf_dict;
     if dict.is_null() || !(*dict).is_dict() {
@@ -1470,7 +1470,7 @@ pub unsafe extern "C" fn pdf_add_dict(
     /* If this key already exists, simply replace the value */
     data = (*dict).data as *mut pdf_dict;
     while !(*data).key.is_null() {
-        if key == pdf_name_value(&*(*data).key).to_string_lossy() {
+        if key.as_ref() == pdf_name_value(&*(*data).key).to_bytes() {
             /* Release the old value */
             pdf_release_obj((*data).value);
             (*data).value = value;
@@ -1526,7 +1526,7 @@ pub unsafe extern "C" fn pdf_merge_dict(mut dict1: *mut pdf_obj, mut dict2: *mut
         pdf_add_dict(
             dict1,
             //pdf_link_obj((*data).key),
-            pdf_name_value(&*(*data).key).to_str().unwrap(),
+            pdf_name_value(&*(*data).key).to_bytes(),
             pdf_link_obj((*data).value),
         );
         data = (*data).next
@@ -1558,11 +1558,11 @@ pub unsafe extern "C" fn pdf_foreach_dict(
     }
     error
 }
-#[no_mangle]
-pub unsafe extern "C" fn pdf_lookup_dict(
-    mut dict: *mut pdf_obj,
-    name: &str,
-) -> Option<*mut pdf_obj> {
+
+pub unsafe fn pdf_lookup_dict<K>(mut dict: *mut pdf_obj, name: K) -> Option<*mut pdf_obj>
+where
+    K: AsRef<[u8]>,
+{
     let mut data: *mut pdf_dict = 0 as *mut pdf_dict;
     if dict.is_null() || !(*dict).is_dict() {
         panic!(
@@ -1574,7 +1574,7 @@ pub unsafe extern "C" fn pdf_lookup_dict(
     }
     data = (*dict).data as *mut pdf_dict;
     while !(*data).key.is_null() {
-        if name == pdf_name_value(&*(*data).key).to_string_lossy() {
+        if name.as_ref() == pdf_name_value(&*(*data).key).to_bytes() {
             return Some((*data).value);
         }
         data = (*data).next
@@ -1605,8 +1605,11 @@ pub unsafe extern "C" fn pdf_dict_keys(mut dict: *mut pdf_obj) -> *mut pdf_obj {
     }
     keys
 }
-#[no_mangle]
-pub unsafe extern "C" fn pdf_remove_dict(mut dict: *mut pdf_obj, name: &str) {
+
+pub unsafe fn pdf_remove_dict<K>(mut dict: *mut pdf_obj, name: K)
+where
+    K: AsRef<[u8]>,
+{
     let mut data: *mut pdf_dict = 0 as *mut pdf_dict;
     let mut data_p: *mut *mut pdf_dict = 0 as *mut *mut pdf_dict;
     if dict.is_null() || !(*dict).is_dict() {
@@ -1621,8 +1624,8 @@ pub unsafe extern "C" fn pdf_remove_dict(mut dict: *mut pdf_obj, name: &str) {
     data_p = &mut (*dict).data as *mut *mut libc::c_void as *mut libc::c_void as *mut *mut pdf_dict;
     while !(*data).key.is_null() {
         if !(*data).key.is_null()
-            && (CStr::from_ptr((*((*(*data).key).data as *mut pdf_name)).name).to_string_lossy()
-                == name)
+            && (CStr::from_ptr((*((*(*data).key).data as *mut pdf_name)).name).to_bytes()
+                == name.as_ref())
         {
             pdf_release_obj((*data).key);
             pdf_release_obj((*data).value);
@@ -4533,7 +4536,7 @@ unsafe extern "C" fn import_dict(
     if tmp.is_null() {
         return -1i32;
     }
-    pdf_add_dict(copy, pdf_name_value(&*key).to_str().unwrap(), tmp); // TODO: check
+    pdf_add_dict(copy, pdf_name_value(&*key).to_bytes(), tmp); // TODO: check
     0i32
 }
 static mut loop_marker: pdf_obj = {

dpx/src/dpx_pdfparse.rs

@@ -744,7 +744,7 @@ pub unsafe extern "C" fn parse_pdf_dict(
             warn!("Could not find a value in dictionary object.");
             return 0 as *mut pdf_obj;
         }
-        pdf_add_dict(result, pdf_name_value(&*key).to_str().unwrap(), value); // TODO: check
+        pdf_add_dict(result, pdf_name_value(&*key).to_bytes(), value);
         skip_white(&mut p, endptr);
     }
     if p.offset(2) > endptr

dpx/src/dpx_pkfont.rs

@@ -774,7 +774,7 @@ pub unsafe extern "C" fn pdf_font_load_pkfont(mut font: *mut pdf_font) -> i32 {
                 }
                 pdf_add_dict(
                     charprocs,
-                    CStr::from_ptr(charname).to_str().unwrap(),
+                    CStr::from_ptr(charname).to_bytes(),
                     pdf_ref_obj(charproc),
                 );
                 pdf_release_obj(charproc);

dpx/src/specials/html.rs

@@ -29,9 +29,9 @@ unused_assignments,
 unused_mut
 )]
 
-use std::ffi::{CStr, CString};
-use crate::DisplayExt;
 use crate::dpx_error::dpx_warning;
+use crate::DisplayExt;
+use std::ffi::{CStr, CString};
 
 use crate::dpx_pdfdraw::{pdf_dev_concat, pdf_dev_transform};
 use crate::dpx_pdfximage::{
@@ -52,9 +52,9 @@ use crate::dpx_pdfdoc::{
 };
 use crate::dpx_pdfdraw::{pdf_dev_grestore, pdf_dev_gsave, pdf_dev_rectclip};
 use crate::dpx_pdfobj::{
-    pdf_add_array, pdf_add_dict, pdf_link_obj, pdf_lookup_dict, pdf_new_array,
-    pdf_new_boolean, pdf_new_dict, pdf_new_name, pdf_new_null, pdf_new_number, pdf_new_string,
-    pdf_obj, pdf_obj_typeof, pdf_ref_obj, pdf_release_obj, pdf_string_value, PdfObjType,
+    pdf_add_array, pdf_add_dict, pdf_link_obj, pdf_lookup_dict, pdf_new_array, pdf_new_boolean,
+    pdf_new_dict, pdf_new_name, pdf_new_null, pdf_new_number, pdf_new_string, pdf_obj,
+    pdf_obj_typeof, pdf_ref_obj, pdf_release_obj, pdf_string_value, PdfObjType,
 };
 use crate::mfree;
 use crate::streq_ptr;
@@ -244,7 +244,7 @@ unsafe extern "C" fn read_html_tag(
             }
             pdf_add_dict(
                 attr,
-                CStr::from_ptr(kp).to_str().unwrap(), // TODO: check
+                CStr::from_ptr(kp).to_bytes(),
                 pdf_new_string(vp as *const libc::c_void, strlen(vp).wrapping_add(1) as _),
             );
             free(kp as *mut libc::c_void);

dpx/src/specials/pdfm.rs

@@ -30,6 +30,7 @@
 )]
 
 use crate::warn;
+use crate::DisplayExt;
 use crate::TTInputFormat;
 use crate::{streq_ptr, strstartswith};
 
@@ -294,11 +295,14 @@ unsafe extern "C" fn safeputresdent(
     mut dp: *mut libc::c_void,
 ) -> i32 {
     assert!(!kp.is_null() && !vp.is_null() && !dp.is_null());
-    let key = pdf_name_value(&*kp).to_str().unwrap();
-    if pdf_lookup_dict(dp as *mut pdf_obj, key).is_some() {
-        warn!("Object \"{}\" already defined in dict! (ignored)", key);
+    let key = pdf_name_value(&*kp);
+    if pdf_lookup_dict(dp as *mut pdf_obj, key.to_bytes()).is_some() {
+        warn!(
+            "Object \"{}\" already defined in dict! (ignored)",
+            key.display()
+        );
     } else {
-        pdf_add_dict(dp as *mut pdf_obj, key, pdf_link_obj(vp));
+        pdf_add_dict(dp as *mut pdf_obj, key.to_bytes(), pdf_link_obj(vp));
     }
     0i32
 }
@@ -309,10 +313,10 @@ unsafe extern "C" fn safeputresdict(
 ) -> i32 {
     let mut key: *mut i8 = 0 as *mut i8;
     assert!(!kp.is_null() && !vp.is_null() && !dp.is_null());
-    let key = pdf_name_value(&*kp).to_str().unwrap();
-    let dict = pdf_lookup_dict(dp as *mut pdf_obj, key);
+    let key = pdf_name_value(&*kp);
+    let dict = pdf_lookup_dict(dp as *mut pdf_obj, key.to_bytes());
     if (*vp).is_indirect() {
-        pdf_add_dict(dp as *mut pdf_obj, key, pdf_link_obj(vp));
+        pdf_add_dict(dp as *mut pdf_obj, key.to_bytes(), pdf_link_obj(vp));
     } else if pdf_obj_typeof(vp) == PdfObjType::DICT {
         if let Some(dict) = dict {
             pdf_foreach_dict(
@@ -328,12 +332,12 @@ unsafe extern "C" fn safeputresdict(
                 dict as *mut libc::c_void,
             );
         } else {
-            pdf_add_dict(dp as *mut pdf_obj, key, pdf_link_obj(vp));
+            pdf_add_dict(dp as *mut pdf_obj, key.to_bytes(), pdf_link_obj(vp));
         }
     } else {
         warn!(
             "Invalid type (not DICT) for page/form resource dict entry: key=\"{}\"",
-            key,
+            key.display(),
         );
         return -1i32;
     }

dpx/src/specials/tpic.rs

@@ -51,9 +51,9 @@ use crate::dpx_pdfdraw::{
     pdf_dev_setmiterlimit,
 };
 use crate::dpx_pdfobj::{
-    pdf_add_dict, pdf_foreach_dict, pdf_get_version, pdf_lookup_dict,
-    pdf_name_value, pdf_new_boolean, pdf_new_dict, pdf_new_name, pdf_new_number, pdf_new_string,
-    pdf_obj, pdf_obj_typeof, pdf_ref_obj, pdf_release_obj, pdf_string_value, PdfObjType,
+    pdf_add_dict, pdf_foreach_dict, pdf_get_version, pdf_lookup_dict, pdf_name_value,
+    pdf_new_boolean, pdf_new_dict, pdf_new_name, pdf_new_number, pdf_new_string, pdf_obj,
+    pdf_obj_typeof, pdf_ref_obj, pdf_release_obj, pdf_string_value, PdfObjType,
 };
 use crate::dpx_pdfparse::parse_val_ident;
 use libc::{atof, free, memcmp, sprintf, strlen};
@@ -821,19 +821,15 @@ unsafe extern "C" fn spc_parse_kvpairs(mut ap: *mut spc_arg) -> *mut pdf_obj {
                 } else {
                     pdf_add_dict(
                         dict,
-                        CStr::from_ptr(kp).to_str().unwrap(),
+                        CStr::from_ptr(kp).to_bytes(),
                         pdf_new_string(vp as *const libc::c_void, strlen(vp).wrapping_add(1) as _),
                     );
                     free(vp as *mut libc::c_void);
                 }
             }
         } else {
             /* Treated as 'flag' */
-            pdf_add_dict(
-                dict,
-                CStr::from_ptr(kp).to_str().unwrap(),
-                pdf_new_boolean(1_i8),
-            );
+            pdf_add_dict(dict, CStr::from_ptr(kp).to_bytes(), pdf_new_boolean(1_i8));
         }
         free(kp as *mut libc::c_void);
         if error == 0 {