Command line parsing improvements (ruby#197)

XrXr · web-flow · commit 7e95ae9e571e · 2022-02-26T12:13:56.000-05:00
* Accept when user passes exactly "--yjit"

* Refactor command line parsing

 - Use an `Option(())` so we could use the `?` operator instead of having
  to type out `return false;`
 - Use an exhaustive match instead of repeating similar if-elses
 - Return parse failure instead of panicking when input is not utf8
 - Remove unnecessary `str.to_owned()` which allocates and copies the
   string.

* Explicit matchinig instead of Result.map
diff --git a/yjit/src/options.rs b/yjit/src/options.rs
@@ -47,39 +47,45 @@ macro_rules! get_option {
 }
 pub(crate) use get_option;
 
-pub fn parse_option(str_ptr: *const std::os::raw::c_char) -> bool
+/// Expected to receive what comes after the third dash in "--yjit-*".
+/// Empty string means user passed only "--yjit". C code rejects when
+/// they pass exact "--yjit-".
+pub fn parse_option(str_ptr: *const std::os::raw::c_char) -> Option<()>
 {
     let c_str: &CStr = unsafe { CStr::from_ptr(str_ptr) };
-    let str_slice: &str = c_str.to_str().unwrap();
-    let opt_str: String = str_slice.to_owned();
+    let opt_str: &str = c_str.to_str().ok()?;
     //println!("{}", opt_str);
 
     // Split the option name and value strings
     // Note that some options do not contain an assignment
     let parts = opt_str.split_once("=");
-    let opt_name = if parts.is_some() { parts.unwrap().0 } else { &opt_str };
-    let opt_val = if parts.is_some() { parts.unwrap().1 } else { "" };
+    let (opt_name, opt_val) = match parts {
+        Some((before_eq, after_eq)) => (before_eq, after_eq),
+        None => (opt_str, "")
+    };
 
     // Match on the option name and value strings
     match (opt_name, opt_val) {
+        ("", "") => (), // Simply --yjit
+
         ("exec-mem-size", _) => {
             match opt_val.parse::<usize>() {
-                Ok(n) => { unsafe { OPTIONS.exec_mem_size = n }}
-                Err(e) => { return false; }
+                Ok(n) => unsafe { OPTIONS.exec_mem_size = n },
+                Err(_) => { return None; }
             }
         },
 
         ("call-threshold", _) => {
             match opt_val.parse::<usize>() {
-                Ok(n) => { unsafe { OPTIONS.call_threshold = n }}
-                Err(e) => { return false; }
+                Ok(n) => unsafe { OPTIONS.call_threshold = n },
+                Err(_) => { return None; }
             }
         },
 
         ("max-versions", _) => {
             match opt_val.parse::<usize>() {
-                Ok(n) => { unsafe { OPTIONS.max_versions = n }}
-                Err(e) => { return false; }
+                Ok(n) => unsafe { OPTIONS.max_versions = n },
+                Err(_) => { return None; }
             }
         },
 
@@ -89,10 +95,12 @@ pub fn parse_option(str_ptr: *const std::os::raw::c_char) -> bool
 
         // Option name not recognized
         _ => {
-            return false;
+            return None;
         }
     }
 
+    // dbg!(unsafe {OPTIONS});
+
     // Option successfully parsed
-    return true;
+    return Some(());
 }
diff --git a/yjit/src/yjit.rs b/yjit/src/yjit.rs
@@ -16,7 +16,7 @@ static YJIT_ENABLED: AtomicBool = AtomicBool::new(false);
 #[no_mangle]
 pub extern "C" fn rb_yjit_parse_option(str_ptr: *const raw::c_char) -> bool
 {
-    return parse_option(str_ptr);
+    return parse_option(str_ptr).is_some();
 }
 
 /// Is YJIT on? The interpreter uses this function to decide whether to increment

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ static YJIT_ENABLED: AtomicBool = AtomicBool::new(false);`
`16`	`16`	`#[no_mangle]`
`17`	`17`	`pub extern "C" fn rb_yjit_parse_option(str_ptr: *const raw::c_char) -> bool`
`18`	`18`	`{`
`19`		`- return parse_option(str_ptr);`
	`19`	`+ return parse_option(str_ptr).is_some();`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`/// Is YJIT on? The interpreter uses this function to decide whether to increment`