make improvements

Author: anonrig

src/checkers.rs

@@ -132,19 +132,20 @@ const PATH_SIG_TABLE: [u8; 256] = {
     t
 };
 
-/// Compute a path-signature byte via an unrolled table lookup — branch-free.
-/// Returns a bitmask of the flags above.
+/// Compute a path-signature byte via Ada's exact 8-at-a-time unrolled lookup.
+///
+/// Ada C++ uses `for (; i + 7 < size; i += 8)` — we match that exactly.
 pub fn path_signature(input: &str) -> u8 {
     let b = input.as_bytes();
     let mut acc = 0u8;
     let mut i = 0;
-    // Unrolled 4-at-a-time — same as Ada C++ style
-    while i + 4 <= b.len() {
-        acc |= PATH_SIG_TABLE[b[i]   as usize]
-             | PATH_SIG_TABLE[b[i+1] as usize]
-             | PATH_SIG_TABLE[b[i+2] as usize]
-             | PATH_SIG_TABLE[b[i+3] as usize];
-        i += 4;
+    // 8-at-a-time — Ada C++ uses this exact unroll factor
+    while i + 8 <= b.len() {
+        acc |= PATH_SIG_TABLE[b[i  ] as usize] | PATH_SIG_TABLE[b[i+1] as usize]
+             | PATH_SIG_TABLE[b[i+2] as usize] | PATH_SIG_TABLE[b[i+3] as usize]
+             | PATH_SIG_TABLE[b[i+4] as usize] | PATH_SIG_TABLE[b[i+5] as usize]
+             | PATH_SIG_TABLE[b[i+6] as usize] | PATH_SIG_TABLE[b[i+7] as usize];
+        i += 8;
     }
     while i < b.len() { acc |= PATH_SIG_TABLE[b[i] as usize]; i += 1; }
     acc

src/helpers.rs

@@ -66,6 +66,7 @@ pub fn remove_ascii_tab_or_newline(s: &mut String) {
 /// Trim leading and trailing C0 control characters and ASCII space.
 /// Returns a `&str` slice into the original — **zero allocation**.
 #[inline]
+#[allow(dead_code)]
 pub fn trim_c0_whitespace(s: &str) -> &str {
     let start = s
         .as_bytes()

src/parser.rs

@@ -18,8 +18,11 @@ use crate::helpers::{
     find_authority_delimiter, find_authority_delimiter_special, get_host_delimiter_location,
     shorten_path, strip_tabs_newlines, trim_c0_whitespace,
 };
-use crate::scheme::SchemeType as Scheme;
-use crate::unicode::{is_alnum_plus, percent_encode};
+use crate::scheme::{get_scheme_type_lower, SchemeType as Scheme};
+use crate::unicode::{
+    contains_xn_prefix_pub, is_alnum_plus,
+    percent_encode,
+};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum State {
@@ -54,23 +57,29 @@ pub fn parse_url(user_input: &str, base: Option<&Url>) -> Option<Url> {
             return None;
         }
 
-    // Strip tabs/newlines — CoW: zero allocation when none present (common case)
-    let stripped = strip_tabs_newlines(user_input);
-
-    // Trim C0 whitespace — borrow from the (possibly borrowed) cow, no allocation
-    let url_data = trim_c0_whitespace(&stripped);
+    // ── Fast path ─────────────────────────────────────────────────────────
+    // For absolute URLs without a base we try the ultra-fast path BEFORE
+    // any pre-processing.  It inlines C0 trim, tab detection, fragment split,
+    // host validation, and buffer build in a single forward scan, saving the
+    // three separate pre-processing passes that the slow path performs.
+    if base.is_none()
+        && let Some(url) = try_parse_absolute_fast(user_input) {
+        return Some(url);
+    }
 
-    // Extract fragment — split in-place, no allocation (fragment borrows from url_data)
-    let (url_data, fragment) = match url_data.find('#') {
-        None    => (url_data, None),
-        Some(p) => (&url_data[..p], Some(&url_data[p + 1..])),
+    // ── Slow path: full pre-processing + state machine ────────────────────
+    let stripped = strip_tabs_newlines(user_input);
+    let trimmed = trim_c0_whitespace(&stripped);
+    let (url_data, fragment): (&str, Option<&str>) = match trimmed.find('#') {
+        None    => (trimmed, None),
+        Some(p) => (&trimmed[..p], Some(&trimmed[p + 1..])),
     };
 
     let input_size = url_data.len();
     let b = url_data.as_bytes();
 
     let mut url = Url::empty();
-    url.buffer.reserve(input_size + 16);
+    url.buffer.reserve(input_size + 4);
 
     let mut state = State::SchemeStart;
     let mut pos: usize = 0;
@@ -542,3 +551,248 @@ pub fn parse_url(user_input: &str, base: Option<&Url>) -> Option<Url> {
     }
     Some(url)
 }
+
+// =============================================================================
+// Fast-path builder for absolute special URLs
+// =============================================================================
+//
+// Handles the overwhelmingly common case: an absolute URL like
+//   `https://hostname/path?query`
+// with no base, no credentials, ASCII-only lowercase host, and no path dots.
+//
+// Single forward scan replaces the full state-machine loop.  Falls back to
+// `None` for anything unusual so the slow path covers all edge cases.
+
+/// Try to parse `url_data` (already C0-trimmed, tab/newline-free, fragment-stripped)
+/// as a simple absolute special URL without invoking the state machine.
+/// Fast-path builder for absolute special URLs — takes RAW (unprocessed) input.
+///
+/// Inlines C0 trim, tab/newline detection, fragment split, host validation,
+/// and buffer construction into a minimal number of forward scans.
+/// Falls back to `None` (→ state machine) for anything unusual.
+#[inline]
+pub(crate) fn try_parse_absolute_fast(raw_input: &str) -> Option<Url> {
+    use crate::{HostKind, OMITTED};
+    use crate::character_sets::FRAGMENT_PERCENT_ENCODE;
+    use crate::unicode::DOMAIN_CHECK;
+
+    let raw = raw_input.as_bytes();
+
+    // ── C0 whitespace trim (branchless for typical URLs with none) ─────────
+    let start = if !raw.is_empty() && raw[0] <= b' ' {
+        raw.iter().position(|&b| b > b' ')?
+    } else { 0 };
+    let end = if !raw.is_empty() && raw[raw.len()-1] <= b' ' {
+        raw.iter().rposition(|&b| b > b' ').map(|i| i + 1)?
+    } else { raw.len() };
+    if start >= end { return None; }
+    let b = &raw[start..end];
+
+    // ── Scheme detection (≤ 6 bytes) ──────────────────────────────────────
+    if b.is_empty() || !is_alpha(b[0]) { return None; }
+
+    let colon = {
+        let mut i = 1usize;
+        loop {
+            if i >= b.len().min(7) { return None; }
+            match b[i] {
+                b':' => break i,
+                c if !is_alnum_plus(c) => return None, // invalid scheme char (incl. \t\n\r)
+                _ => i += 1,
+            }
+        }
+    };
+
+    // Perfect-hash scheme type (no string comparison)
+    let scheme_bytes = &b[..colon];
+    let scheme = {
+        let s = unsafe { core::str::from_utf8_unchecked(scheme_bytes) };
+        let t = get_scheme_type_lower(s);
+        if t == Scheme::NotSpecial { crate::scheme::get_scheme_type(s) } else { t }
+    };
+    if !scheme.is_special() || scheme == Scheme::File { return None; }
+
+    // ── Require "://" ──────────────────────────────────────────────────────
+    if b.len() < colon + 3 || b[colon+1] != b'/' || b[colon+2] != b'/' { return None; }
+    let auth_start = colon + 3;
+
+    // ── Single-pass authority scan ─────────────────────────────────────────
+    // Simultaneously: find auth end, detect '@' / tabs / non-ASCII / uppercase,
+    // IPv4 flag (only digits+dots), xn-- flag ('x' present), forbidden chars.
+    let mut auth_end = auth_start;
+    let mut port_colon: Option<usize> = None;
+    let mut has_x = false; // xn-- candidate ('x' seen in host)
+
+    while auth_end < b.len() {
+        let c = b[auth_end];
+        match c {
+            b'/' | b'?' | b'#' | b'\\' => break,
+            b'@' => return None,
+            b':' if port_colon.is_none() => { port_colon = Some(auth_end); auth_end += 1; }
+            b'\t' | b'\n' | b'\r' => return None,
+            c if c >= 0x80 => return None,
+            b'0'..=b'9' | b'.' => { auth_end += 1; }
+            c => {
+                if c == b'x' { has_x = true; }
+                if DOMAIN_CHECK[c as usize] != 0 { return None; }
+                auth_end += 1;
+            }
+        }
+    }
+
+    let host_end_in_input = port_colon.unwrap_or(auth_end);
+    let host = &b[auth_start..host_end_in_input];
+    if host.is_empty() { return None; }
+
+    // IPv4 quick-filter: check the last *significant* (non-dot) byte of the host.
+    // is_ipv4 strips trailing dots internally, so we mirror that here.
+    // For TLD hostnames (.com/.org/.net) the last letter is 'm','g','t' — never
+    // in {0-9, a-f, x} — so is_ipv4 is not called for typical domain names.
+    {
+        let last_sig = host.iter().rev().find(|&&c| c != b'.').copied().unwrap_or(0);
+        let maybe_ipv4 = last_sig.is_ascii_digit()
+            || matches!(last_sig, b'a'..=b'f')
+            || last_sig == b'x';
+        if maybe_ipv4 {
+            let host_str = unsafe { core::str::from_utf8_unchecked(host) };
+            if crate::checkers::is_ipv4(host_str) { return None; }
+        }
+    }
+
+    // xn-- check: only if 'x' was seen (zero cost for typical .com/.org hosts)
+    if has_x {
+        let host_str = unsafe { core::str::from_utf8_unchecked(host) };
+        if contains_xn_prefix_pub(host_str) { return None; }
+    }
+
+    // ── Port ────────────────────────────────────────────────────────────────
+    let port_val: u32 = if let Some(pc) = port_colon {
+        let port_bytes = &b[pc + 1..auth_end];
+        if port_bytes.is_empty() {
+            OMITTED
+        } else {
+            if !port_bytes.iter().all(|&c| c.is_ascii_digit()) { return None; }
+            let n: u32 = port_bytes.iter().fold(0u32, |a, &c| a * 10 + (c - b'0') as u32);
+            if n > 65535 { return None; }
+            let def = scheme.default_port();
+            if def != 0 && n as u16 == def { OMITTED } else { n }
+        }
+    } else {
+        OMITTED
+    };
+
+    // ── Path + query + fragment scan ───────────────────────────────────────
+    let path_start = auth_end;
+    let mut query_start: Option<usize> = None;
+    let mut frag_start:  Option<usize> = None;
+    let path_end: usize;
+
+    {
+        let mut i = path_start;
+        loop {
+            if i >= b.len() { path_end = i; break; }
+            match b[i] {
+                b'?' => { path_end = i; query_start = Some(i); break; }
+                b'#' => { path_end = i; frag_start  = Some(i); break; }
+                b'\\' => return None, // backslash needs normalisation
+                _ => {}
+            }
+            i += 1;
+        }
+    }
+
+    // Path: use path_signature to detect encoding needs + dot-segments.
+    let path_bytes = &b[path_start..path_end];
+    let path_sig = crate::checkers::path_signature(
+        unsafe { core::str::from_utf8_unchecked(path_bytes) }
+    );
+    if path_sig & 0x0B != 0 { return None; } // needs encoding / backslash / percent
+    if path_sig & 0x04 != 0 {
+        // Has a dot — check for actual dot-segments (SIMD str::contains)
+        let path_str = unsafe { core::str::from_utf8_unchecked(path_bytes) };
+        if path_str.contains("/.") { return None; }
+    }
+
+    // Query: check for characters needing encoding
+    let query_end = frag_start.unwrap_or(b.len());
+    if let Some(qs) = query_start {
+        let qbytes = &b[qs + 1..query_end];
+        let encode_set = if scheme.default_port() != 0 {
+            &crate::character_sets::SPECIAL_QUERY_PERCENT_ENCODE
+        } else {
+            &crate::character_sets::QUERY_PERCENT_ENCODE
+        };
+        if crate::unicode::percent_encode_index(
+            unsafe { core::str::from_utf8_unchecked(qbytes) },
+            encode_set,
+        ) != qbytes.len() {
+            return None; // query needs encoding
+        }
+    }
+
+    // Fragment from '#' in the URL (may be None if no '#')
+    let fragment: Option<&str> = frag_start.map(|fs| {
+        unsafe { core::str::from_utf8_unchecked(&b[fs + 1..]) }
+    });
+
+    // ── Build URL buffer in a single forward write pass ────────────────────
+    let total = colon + 1 + 2 // scheme:   //
+        + host.len()
+        + if port_val != OMITTED { 6 } else { 0 }  // :NNNNN
+        + (path_end - path_start).max(1)
+        + query_start.map_or(0, |qs| query_end - qs)
+        + fragment.map_or(0, |f| f.len() + 1);
+
+    let mut url = Url::empty();
+    url.scheme = scheme;
+    url.buffer.reserve(total + 4);
+
+    // Scheme (lowercase) + ':'
+    for &c in scheme_bytes { url.buffer.push((c | 0x20) as char); }
+    url.buffer.push(':');
+    url.components.protocol_end = url.buffer.len() as u32;
+
+    // "//"
+    url.buffer.push('/');
+    url.buffer.push('/');
+    url.components.username_end = url.buffer.len() as u32;
+    url.components.host_start   = url.buffer.len() as u32;
+
+    // Host (already validated: lowercase ASCII, no forbidden chars)
+    url.buffer.push_str(unsafe { core::str::from_utf8_unchecked(host) });
+    url.components.host_end = url.buffer.len() as u32;
+
+    // Port
+    if port_val != OMITTED {
+        url.buffer.push(':');
+        let mut tmp = [0u8; 5]; let mut n = port_val; let mut len = 0usize;
+        loop { tmp[len] = b'0' + (n % 10) as u8; n /= 10; len += 1; if n == 0 { break; } }
+        for k in (0..len).rev() { url.buffer.push(tmp[k] as char); }
+        url.components.port = port_val;
+    }
+    url.components.pathname_start = url.buffer.len() as u32;
+
+    // Path
+    if path_bytes.is_empty() {
+        url.buffer.push('/');
+    } else {
+        url.buffer.push_str(unsafe { core::str::from_utf8_unchecked(path_bytes) });
+    }
+
+    // Query (with leading '?')
+    if let Some(qs) = query_start {
+        url.components.search_start = url.buffer.len() as u32;
+        url.buffer.push_str(unsafe { core::str::from_utf8_unchecked(&b[qs..query_end]) });
+    }
+
+    // Fragment (percent-encoded, with leading '#')
+    if let Some(frag) = fragment {
+        url.components.hash_start = url.buffer.len() as u32;
+        url.buffer.push('#');
+        let enc = percent_encode(frag, &FRAGMENT_PERCENT_ENCODE);
+        url.buffer.push_str(&enc);
+    }
+
+    url.host_kind = HostKind::Domain;
+    Some(url)
+}