posted July 07, 2001 01:15 AM            

   ' OutBuf is not necessary to allocate
   ' $CRLF after each nGroups per 3 input bytes
   Function Encode_BASE64(InBuf As String, ByVal nGroups As Long, OutBuf As String) As Long
      #Register None
      OutBuf = Space$(4 * Fix((Len(InBuf) + 2) / 3) + 2 * Fix(Len(InBuf) / (3 * nGroups)))
      ! PUSH EBX
      ! LEA EBX, Encode_BASE64_Trt
      ! MOV EDI, OutBuf
      ! MOV EDI, [EDI]                    ' StrPtr(OutBuf)
      ! MOV ESI, InBuf
      ! MOV ESI, [ESI]                    ' StrPtr(InBuf)
      ! MOV EDX, ESI
      ! SUB EDX, 4
      ! MOV EDX, [EDX]                    ' Len(InBuf)
      ! MOV ECX, nGroups
 Encode_BASE64_Lb1:
      ! CMP EDX, 0
      ! JLE Encode_BASE64_Lb4
      ! MOV AL, [ESI]
      ! SHR AL, 2
      ! XLATB
      ! MOV [EDI], AL
      ! INC EDI
      ! MOV AL, [ESI + 1]
      ! MOV AH, [ESI]
      ! SHR AX, 4
      ! AND AL, &H3F
      ! XLATB
      ! MOV [EDI], AL
      ! INC EDI
      ! CMP EDX, 1
      ! JNE Encode_BASE64_Lb2
      ! MOV AL, 61                        ' Add ==
      ! MOV [EDI], AL
      ! INC EDI
      ! MOV [EDI], AL
      ! INC EDI
      ! JMP Encode_BASE64_Lb4
 Encode_BASE64_Lb2:
      ! MOV AL, [ESI + 2]
      ! MOV AH, [ESI + 1]
      ! SHR AX, 6
      ! AND AL, &H3F
      ! XLATB
      ! MOV [EDI], AL
      ! INC EDI
      ! CMP EDX, 2
      ! JNE Encode_BASE64_Lb3
      ! MOV AL, 61                        ' Add =
      ! MOV [EDI], AL
      ! INC EDI
      ! JMP Encode_BASE64_Lb4
 Encode_BASE64_Lb3:
      ! MOV AL, [ESI + 2]
      ! AND AL, &H3F
      ! XLATB
      ! MOV [EDI], AL
      ! INC EDI
      ! ADD ESI, 3
      ! SUB EDX, 3
      ! DEC ECX
      ! CMP ECX, 0
      ! JNE Encode_BASE64_Lb1
      ! MOV AL, 13                         ' Add $CRLF
      ! MOV [EDI], AL
      ! MOV AL, 10
      ! MOV [EDI + 1], AL
      ! ADD EDI, 2
      ! MOV ECX, nGroups
      ! JMP Encode_BASE64_Lb1
 Encode_BASE64_Lb4:
      ! POP EBX
      Exit Function
 Encode_Base64_Trt:
      ! DB 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90
      ! DB 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122
      ! DB 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47
   End Function
   ' OutBuf is not necessary to allocate
   ' Function = offset in InBuf for last not recognized character
   Function Decode_Base64(ByVal InBuf As Dword, OutBuf As String) As Long
      #Register None
      Dim i As Long
      ! MOV EDI, 0
      ! MOV AH, 0
 Decode_BASE64_Lb1:
      ! PUSH EBX
      ! LEA EBX, i
      ! MOV ESI, InBuf
      ! PUSH ESI
      ! MOV CL, 0
 Decode_BASE64_Lb2:
      ! MOV AL, [ESI]
      ! CMP AL, 13                         ' Pass $CRLF
      ! JE Decode_BASE64_Lb15
      ! CMP AL, 10
      ! JE Decode_BASE64_Lb15
      ! CMP AL, 65                         ' A .. Z
      ! JL Decode_BASE64_Lb3
      ! CMP AL, 90
      ! JG Decode_BASE64_Lb3
      ! SUB AL, 65
      ! JMP Decode_BASE64_Lb8
 Decode_BASE64_Lb3:
      ! CMP AL, 97                         ' a .. z
      ! JL Decode_BASE64_Lb4
      ! CMP AL, 122
      ! JG Decode_BASE64_Lb4
      ! SUB AL, 71
      ! JMP Decode_BASE64_Lb8
 Decode_BASE64_Lb4:
      ! CMP AL, 48                         ' 0 .. 9
      ! JL Decode_BASE64_Lb5
      ! CMP AL, 57
      ! JG Decode_BASE64_Lb5
      ! ADD AL, 4
      ! JMP Decode_BASE64_Lb8
 Decode_BASE64_Lb5:
      ! CMP AL, 43                         ' +
      ! JNE Decode_BASE64_Lb6
      ! MOV AL, 62
      ! JMP Decode_BASE64_Lb8
 Decode_BASE64_Lb6:
      ! CMP AL, 47                         ' /
      ! JNE Decode_BASE64_Lb7
      ! MOV AL, 63
      ! JMP Decode_BASE64_Lb8
 Decode_BASE64_Lb7:
      ! CMP AL, 61                         ' =
      ! JNE Decode_BASE64_Lb18
      ! MOV AL, 255
 Decode_BASE64_Lb8:
      ! INC CL
      ! CMP CL, 1
      ! JNE Decode_BASE64_Lb9
      ! MOV [EBX], AL
      ! JMP Decode_BASE64_Lb15
 Decode_BASE64_Lb9:
      ! CMP CL, 2
      ! JNE Decode_BASE64_Lb10
      ! MOV [EBX + 1], AL
      ! JMP Decode_BASE64_Lb15
 Decode_BASE64_Lb10:
      ! CMP CL, 3
      ! JNE Decode_BASE64_Lb11
      ! MOV [EBX + 2], AL
      ! JMP Decode_BASE64_Lb15
 Decode_BASE64_Lb11:
      ! MOV [EBX + 3], AL
      ! MOV CL, [EBX]
      ! SHL CL, 2
      ! MOV CH, [EBX + 1]
      ! SHR CH, 4
      ! OR  CL, CH
      ! CMP AH, 0
      ! JE Decode_BASE64_Lb12
      ! MOV [EDI], CL
 Decode_BASE64_Lb12:
      ! MOV CL, [EBX + 2]
      ! CMP CL, 255
      ! JE  Decode_BASE64_Lb17
      ! MOV CL, [EBX + 1]
      ! SHL CL, 4
      ! MOV CH, [EBX + 2]
      ! SHR CH, 2
      ! OR  CL, CH
      ! CMP AH, 0
      ! JE Decode_BASE64_Lb13
      ! MOV [EDI + 1], CL
 Decode_BASE64_Lb13:
      ! MOV CL, [EBX + 3]
      ! CMP CL, 255
      ! JE  Decode_BASE64_Lb16
      ! MOV CL, [EBX + 2]
      ! SHL CL, 6
      ! MOV CH, [EBX + 3]
      ! OR  CL, CH
      ! CMP AH, 0
      ! JE Decode_BASE64_Lb14
      ! MOV [EDI + 2], CL
 Decode_BASE64_Lb14:
      ! ADD EDI, 3
      ! MOV CL, 0
 Decode_BASE64_Lb15:
      ! INC ESI
      ! JMP Decode_BASE64_Lb2

 Decode_BASE64_Lb16:
      ! INC EDI
 Decode_BASE64_Lb17:
      ! INC EDI
 Decode_BASE64_Lb18:
      ! MOV ECX, ESI
      ! POP ESI
      ! SUB ECX, ESI
      ! MOV Function, ECX
      ! POP EBX
      ! CMP AH, 0
      ! JNE Decode_BASE64_Lb19
      ! MOV AH, 1
      ! MOV i, EDI
      OutBuf = Space$(i)
      ! MOV EDI, OutBuf
      ! MOV EDI, [EDI]
      ! JMP Decode_BASE64_Lb1
 Decode_BASE64_Lb19:
      Exit Function
   End Function