@@ -1459,6 +1459,52 @@ static unsafe bool IsMboxMarker (byte[] text, bool allowMunged = false)
14591459 }
14601460 }
14611461
1462+ [ MethodImpl ( MethodImplOptions . AggressiveInlining ) ]
1463+ static unsafe byte * EndOfLine ( byte * inptr , byte * inend )
1464+ {
1465+ #if NETCOREAPP
1466+ var span = new ReadOnlySpan < byte > ( inptr , ( int ) ( inend - inptr ) ) ;
1467+
1468+ return inptr += span . IndexOf ( ( byte ) '\n ' ) ;
1469+ #else
1470+ // scan for a linefeed character until we are 4-byte aligned.
1471+ switch ( ( ( long ) inptr ) & 0x03 ) {
1472+ case 1 :
1473+ if ( * inptr == ( byte ) '\n ' )
1474+ break ;
1475+ inptr ++ ;
1476+ goto case 2 ;
1477+ case 2 :
1478+ if ( * inptr == ( byte ) '\n ' )
1479+ break ;
1480+ inptr ++ ;
1481+ goto case 3 ;
1482+ case 3 :
1483+ if ( * inptr != ( byte ) '\n ' )
1484+ inptr ++ ;
1485+ break ;
1486+ }
1487+
1488+ if ( * inptr != ( byte ) '\n ' ) {
1489+ // -funroll-loops, yippee ki-yay.
1490+ do {
1491+ uint mask = * ( ( uint * ) inptr ) ^ 0x0A0A0A0A ;
1492+ mask = ( ( mask - 0x01010101 ) & ( ~ mask & 0x80808080 ) ) ;
1493+
1494+ if ( mask != 0 )
1495+ break ;
1496+
1497+ inptr += 4 ;
1498+ } while ( true ) ;
1499+
1500+ while ( * inptr != ( byte ) '\n ' )
1501+ inptr ++ ;
1502+ }
1503+
1504+ return inptr ;
1505+ #endif
1506+ }
1507+
14621508 unsafe bool StepMboxMarkerStart ( byte * inbuf , ref bool midline )
14631509 {
14641510 byte * inptr = inbuf + inputIndex ;
@@ -1468,9 +1514,7 @@ unsafe bool StepMboxMarkerStart (byte* inbuf, ref bool midline)
14681514
14691515 if ( midline ) {
14701516 // we're in the middle of a line, so we need to scan for the end of the line
1471- // TODO: unroll this loop?
1472- while ( * inptr != ( byte ) '\n ' )
1473- inptr ++ ;
1517+ inptr = EndOfLine ( inptr , inend + 1 ) ;
14741518
14751519 if ( inptr == inend ) {
14761520 // we don't have enough input data
@@ -1492,9 +1536,7 @@ unsafe bool StepMboxMarkerStart (byte* inbuf, ref bool midline)
14921536 }
14931537
14941538 // scan for the end of the line
1495- // TODO: unroll this loop?
1496- while ( * inptr != ( byte ) '\n ' )
1497- inptr ++ ;
1539+ inptr = EndOfLine ( inptr , inend + 1 ) ;
14981540
14991541 if ( inptr == inend ) {
15001542 // we don't have enough data to check for a From line
@@ -1522,9 +1564,7 @@ unsafe bool StepMboxMarker (byte* inbuf, out int count)
15221564 * inend = ( byte ) '\n ' ;
15231565
15241566 // scan for the end of the line
1525- // TODO: unroll this loop?
1526- while ( * inptr != ( byte ) '\n ' )
1527- inptr ++ ;
1567+ inptr = EndOfLine ( inptr , inend + 1 ) ;
15281568
15291569 count = ( int ) ( inptr - start ) ;
15301570
@@ -1711,9 +1751,7 @@ unsafe bool StepHeaderValue (byte* inbuf, ref bool midline)
17111751 * inend = ( byte ) '\n ' ;
17121752
17131753 while ( inptr < inend && ( midline || IsBlank ( * inptr ) ) ) {
1714- // TODO: unroll this loop?
1715- while ( * inptr != ( byte ) '\n ' )
1716- inptr ++ ;
1754+ inptr = EndOfLine ( inptr , inend + 1 ) ;
17171755
17181756 if ( inptr == inend ) {
17191757 // We've reached the end of the input buffer, and we are currently in the middle of a line.
@@ -1775,9 +1813,7 @@ unsafe bool TryCheckBoundaryWithinHeaderBlock (byte* inbuf)
17751813
17761814 * inend = ( byte ) '\n ' ;
17771815
1778- // TODO: unroll this loop?
1779- while ( * inptr != ( byte ) '\n ' )
1780- inptr ++ ;
1816+ inptr = EndOfLine ( inptr , inend + 1 ) ;
17811817
17821818 if ( inptr == inend )
17831819 return false ;
@@ -2004,8 +2040,7 @@ unsafe bool SkipBoundaryMarkerInternal (byte* inbuf, bool endBoundary)
20042040 inptr += currentBoundary . Length ;
20052041
20062042 // skip over any trailing whitespace
2007- while ( * inptr != ( byte ) '\n ' )
2008- inptr ++ ;
2043+ inptr = EndOfLine ( inptr , inend + 1 ) ;
20092044
20102045 if ( inptr < inend ) {
20112046 inputIndex = ( int ) ( inptr - inbuf ) ;
@@ -2258,41 +2293,7 @@ unsafe bool ScanContent (byte* inbuf, ref bool midline, ref bool[] formats)
22582293 while ( inptr < inend ) {
22592294 byte * start = inptr;
22602295
2261- // Note: we can always depend on byte[] arrays being 4-byte aligned on 32bit and 64bit architectures
2262- // so we can safely use the startIndex instead of `((long) inptr) & 3` to determine the alignment.
2263- switch ( startIndex & 3 ) {
2264- case 1 :
2265- if ( * inptr = = ( byte ) '\n ' )
2266- break;
2267- inptr ++ ;
2268- goto case 2 ;
2269- case 2 :
2270- if ( * inptr = = ( byte ) '\n ' )
2271- break;
2272- inptr ++ ;
2273- goto case 3 ;
2274- case 3 :
2275- if ( * inptr ! = ( byte ) '\n ' )
2276- inptr++ ;
2277- break ;
2278- }
2279-
2280- if ( * inptr != ( byte ) '\n ') {
2281- // -funroll-loops, yippee ki-yay.
2282- do {
2283- uint mask = * ( ( uint * ) inptr ) ^ 0x0A0A0A0A ;
2284- mask = ( ( mask - 0x01010101 ) & ( ~ mask & 0x80808080 ) ) ;
2285-
2286- if ( mask != 0 )
2287- break;
2288-
2289- inptr += 4 ;
2290- } while ( true ) ;
2291-
2292- while ( * inptr != ( byte ) '\n ' )
2293- inptr ++ ;
2294- }
2295-
2296+ inptr = EndOfLine ( inptr , inend + 1 ) ;
22962297 length = ( int ) ( inptr - start ) ;
22972298
22982299 if ( inptr < inend ) {
@@ -2464,9 +2465,7 @@ unsafe int ConstructMessagePart (byte* inbuf, int depth, CancellationToken cance
24642465
24652466 * inend = ( byte ) '\n ';
24662467
2467- // TODO: unroll this loop?
2468- while ( * inptr != ( byte ) '\n ' )
2469- inptr ++ ;
2468+ inptr = EndOfLine ( inptr, inend + 1 ) ;
24702469
24712470 // Note: This isn't obvious, but if the "boundary" that was found is an Mbox "From " line, then
24722471 // either the current stream offset is >= contentEnd -or- RespectContentLength is false. It will
0 commit comments