CHANGE: enbase using line breaks by default; new enbase/flat for old behavior.

Also molded binary now does not add a line break before closing bracket!

Author: Oldes

src/boot/natives.reb

@@ -406,6 +406,7 @@ enbase: native [
 	/url  {Base 64 Encoding with URL and Filename Safe Alphabet}
 	/part {Limit the length of the input}
 	limit [integer! binary! any-string!]
+	/flat {Base 64 Encoding without line breaks}
 ]
 
 decloak: native [

src/core/f-enbase.c

@@ -891,7 +891,7 @@ static REBU64 base36_powers[BASE36_LENGTH] = {
 	}
 	*p = 0;
 
-	if (*(p-1) != LF && len > 9 && brk) *p++ = LF;
+	//if (*(p-1) != LF && len > 9 && brk) *p++ = LF; // adds LF before closing bracket
 
 	SERIES_TAIL(series) = DIFF_PTRS(p, series->data);
 	return series;
@@ -923,7 +923,7 @@ static REBU64 base36_powers[BASE36_LENGTH] = {
 		if (brk && ((count % 32) == 0)) *bp++ = LF;
 	}
 
-	if ((len >= 32) && brk && *(bp-1) != LF) *bp++ = LF;
+	//if ((len >= 32) && brk && *(bp-1) != LF) *bp++ = LF; // adds LF before closing bracket
 	*bp = 0;
 
 	SERIES_TAIL(series) = DIFF_PTRS(bp, series->data);
@@ -980,7 +980,7 @@ static REBU64 base36_powers[BASE36_LENGTH] = {
 		p++;
 	}
 
-	if (*(p-1) != LF && x > 49 && brk) *p++ = LF;
+	//if (*(p-1) != LF && x > 49 && brk) *p++ = LF; // adds LF before closing bracket
 	*p = 0;
 
 	SERIES_TAIL(series) = DIFF_PTRS(p, series->data); /* 4 * (int) (len % 3 ? (len / 3) + 1 : len / 3); */

src/core/n-strings.c

@@ -515,6 +515,7 @@ static struct digest {
 	REBINT base = VAL_INT32(D_ARG(2));
 	REBCNT limit = NO_LIMIT;
 	REBVAL *part = D_ARG(5);
+	REBOOL brk = !D_REF(6);
 
 	if (D_REF(4)) {
 		limit = Partial(arg, 0, part, 0); // Can modify value index.
@@ -529,13 +530,13 @@ static struct digest {
 
 	switch (base) {
 	case 64:
-		ser = Encode_Base64(arg, 0, limit, FALSE, D_REF(3));
+		ser = Encode_Base64(arg, 0, limit, brk, D_REF(3));
 		break;
 	case 16:
-		ser = Encode_Base16(arg, 0, limit, FALSE);
+		ser = Encode_Base16(arg, 0, limit, brk);
 		break;
 	case 2:
-		ser = Encode_Base2(arg, 0, limit, FALSE);
+		ser = Encode_Base2(arg, 0, limit, brk);
 		break;
 	case 85:
 #ifdef INCLUDE_BASE85

src/mezz/prot-smtp.reb

@@ -196,7 +196,7 @@ sync-smtp-handler: function [event][
 											smtp-port/state: 'PLAIN
 											write client to binary! ajoin [
 												"AUTH PLAIN "
-												enbase ajoin [spec/user #"^@" spec/user #"^@" spec/pass] 64
+												enbase/flat ajoin [spec/user #"^@" spec/user #"^@" spec/pass] 64
 												CRLF
 											]
 											return false
@@ -232,12 +232,12 @@ sync-smtp-handler: function [event][
 						find/part response "334 VXNlcm5hbWU6" 16 [ ;enbased "Username:"
 							; username being requested
 							sys/log/more 'SMTP "Client: ***user-name***"
-							write client to binary! ajoin [enbase spec/user 64 CRLF]
+							write client to binary! ajoin [enbase/flat spec/user 64 CRLF]
 						]
 						find/part response "334 UGFzc3dvcmQ6" 16 [ ;enbased "Password:"
                             ; pass being requested
                             sys/log/more 'SMTP "Client: ***user-pass***"
-							write client to binary! ajoin [enbase spec/pass 64 CRLF]
+							write client to binary! ajoin [enbase/flat spec/pass 64 CRLF]
 							smtp-port/state: 'PASSWORD
 						]
 						true [
@@ -252,7 +252,7 @@ sync-smtp-handler: function [event][
 						; compute challenge response
 						auth-key: checksum/with auth-key 'md5 spec/pass
 						sys/log/more 'SMTP "Client: ***auth-key***"
-						write client to binary! ajoin [enbase ajoin [spec/user #" " lowercase enbase auth-key 16] 64 CRLF]
+						write client to binary! ajoin [enbase/flat ajoin [spec/user #" " lowercase enbase auth-key 16] 64 CRLF]
 						smtp-port/state: 'PASSWORD
 						false
 					][

src/tests/units/enbase-test.r3

@@ -35,6 +35,34 @@ Rebol [
 	--test-- "enbase-64" --assert #{00FF00} = debase enbase next bin 64 64
 ===end-group===
 
+===start-group=== "enbase/flat"
+	bin: read/binary %units/files/rbgw.gif
+	--test-- "enbase/flat 2"
+		--assert (enbase bin 2) == {
+0100011101001001010001100011100000110111011000010000001000000000
+0000001000000000111100100000000000000000110010000000000000000000
+0000000000000000110010000000000011001000000000001111111111111111
+1111111100100110010001011100100100100110010001011100100100100110
+0100010111001001001001100100010111001001001000011111100100000100
+0000000100000000000000000000010000000000001011000000000000000000
+0000000000000000000000100000000000000010000000000000000000000011
+000000110000100000100001100100110000000000111011}
+		--assert (enbase/flat bin 2) == {0100011101001001010001100011100000110111011000010000001000000000000000100000000011110010000000000000000011001000000000000000000000000000000000001100100000000000110010000000000011111111111111111111111100100110010001011100100100100110010001011100100100100110010001011100100100100110010001011100100100100001111110010000010000000001000000000000000000000100000000000010110000000000000000000000000000000000000000100000000000000010000000000000000000000011000000110000100000100001100100110000000000111011}
+	
+	--test-- "enbase/flat 16"
+		--assert (enbase bin 16) == {
+47494638376102000200F20000C800000000C800C800FFFFFF2645C92645C926
+45C92645C921F90401000004002C0000000002000200000303082193003B}
+		--assert (enbase/flat bin 16) == {47494638376102000200F20000C800000000C800C800FFFFFF2645C92645C92645C92645C921F90401000004002C0000000002000200000303082193003B}
+	
+	--test-- "enbase/flat 64"
+		--assert (enbase bin 64) == {
+R0lGODdhAgACAPIAAMgAAAAAyADIAP///yZFySZFySZFySZFySH5BAEAAAQALAAA
+AAACAAIAAAMDCCGTADs=}
+		--assert (enbase/flat bin 64) == {R0lGODdhAgACAPIAAMgAAAAAyADIAP///yZFySZFySZFySZFySH5BAEAAAQALAAAAAACAAIAAAMDCCGTADs=}
+
+===end-group===
+
 ===start-group=== "debase 64"
 	--test-- "debase 64 1"          
 		--assert strict-equal? "A simple string" to string! debase "QSBzaW1wbGUgc3RyaW5n" 64