basis/base64/base64.factor

   1 ! Copyright (C) 2008 Doug Coleman, Daniel Ehrenberg.
   2 ! See http://factorcode.org/license.txt for BSD license.
   3 USING: combinators fry io io.binary io.encodings.binary
   4 io.streams.byte-array kernel math namespaces sbufs
   5 sequences strings ;
   6 IN: base64
   7
   8 ERROR: malformed-base64 ;
   9
  10 <PRIVATE
  11
  12 : read1-ignoring ( ignoring stream -- ch )
  13     dup stream-read1 pick dupd member?
  14     [ drop read1-ignoring ] [ 2nip ] if ; inline recursive
  15
  16 : push-ignoring ( accum ch -- accum )
  17     dup { f 0 } member-eq? [ drop ] [ over push ] if ; inline
  18
  19 : read-ignoring ( n ignoring stream -- str/f )
  20     [ [ <sbuf> ] keep ] 2dip
  21     '[ _ _ read1-ignoring push-ignoring ] times
  22     [ f ] [ "" like ] if-empty ; inline
  23
  24 : ch>base64 ( ch -- ch )
  25     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
  26     nth ; inline
  27
  28 : base64>ch ( ch -- ch )
  29     {
  30         f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f f
  31         f f f f f f f f f f 62 f f f 63 52 53 54 55 56 57 58 59 60 61 f f
  32         f 0 f f f 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
  33         22 23 24 25 f f f f f f 26 27 28 29 30 31 32 33 34 35 36 37 38 39
  34         40 41 42 43 44 45 46 47 48 49 50 51
  35     } nth [ malformed-base64 ] unless* ; inline
  36
  37 SYMBOL: column
  38
  39 : write1-lines ( column/f ch stream -- column' )
  40     [ stream-write1 ] keep swap [
  41         1 + swap
  42         '[ 76 = [ B{ CHAR: \r CHAR: \n } _ stream-write ] when ]
  43         [ 76 mod ] bi
  44     ] [ drop f ] if* ;
  45
  46 : write-lines ( str -- )
  47     column output-stream get '[
  48         swap [ _ write1-lines ] each
  49     ] change ;
  50
  51 : encode3 ( seq -- )
  52     column output-stream get '[
  53         swap be> { -18 -12 -6 0 } [
  54             shift 0x3f bitand ch>base64 _ write1-lines
  55         ] with each
  56     ] change ; inline
  57
  58 : encode-pad ( seq n -- )
  59     [ 3 0 pad-tail binary [ encode3 ] with-byte-writer ]
  60     [ 1 + ] bi* head-slice 4 CHAR: = pad-tail write-lines ; inline
  61
  62 : decode4 ( seq -- )
  63     [ 0 [ base64>ch swap 6 shift bitor ] reduce 3 >be ]
  64     [ [ CHAR: = = ] count ] bi head-slice*
  65     output-stream get '[ _ stream-write1 ] each ; inline
  66
  67 : (encode-base64) ( stream -- )
  68     3 over stream-read dup length {
  69         { 0 [ 2drop ] }
  70         { 3 [ encode3 (encode-base64) ] }
  71         [ encode-pad (encode-base64) ]
  72     } case ;
  73
  74 PRIVATE>
  75
  76 : encode-base64 ( -- )
  77     input-stream get (encode-base64) ;
  78
  79 : encode-base64-lines ( -- )
  80     0 column [ encode-base64 ] with-variable ;
  81
  82 <PRIVATE
  83
  84 : (decode-base64) ( stream -- )
  85     4 "\n\r" pick read-ignoring dup length {
  86         { 0 [ 2drop ] }
  87         { 4 [ decode4 (decode-base64) ] }
  88         [ malformed-base64 ]
  89     } case ;
  90
  91 PRIVATE>
  92
  93 : decode-base64 ( -- )
  94     input-stream get (decode-base64) ;
  95
  96 : >base64 ( seq -- base64 )
  97     binary [ binary [ encode-base64 ] with-byte-reader ] with-byte-writer ;
  98
  99 : base64> ( base64 -- seq )
 100     binary [ binary [ decode-base64 ] with-byte-reader ] with-byte-writer ;
 101
 102 : >base64-lines ( seq -- base64 )
 103     binary [ binary [ encode-base64-lines ] with-byte-reader ] with-byte-writer ;