API tools faq
paste
Advertisement
Guest User

XUP x86

a guest
Aug 26th, 2017
117
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
PureBasic 21.58 KB | None | 0 0
raw download clone embed print report
  1. ; ********************************************************************************
  2. ; XUP_x86.dll v2.6.5.1 (x86) [ eXtended UnPack Library ]
  3. ; --------------------------------------------------------------------------------
  4. ; Coded ® 29-12-2011 by Peace^TST (PB 4.51) - build: 27-08-2017 (PB 5.44 LTS)
  5. ; Unpack:   PP20, FIMP, XPK->SQSH|PWPK|IMPL|BZP2|GZIP|NONE, ICE!|ATM5, JCalG1, ZIP
  6. ; Pack:     ZIP
  7. ; ********************************************************************************
  8.  
  9. Enumeration ; *** Errors
  10.     #XUPERR_OK  =   0
  11.     #XUPERR_FILE
  12.     #XUPERR_UNPACK
  13.     #XUPERR_NOTPACKED
  14.     #XUPERR_UNKNOWN
  15. EndEnumeration
  16.  
  17. CompilerIf  Defined(RS_XUP, #PB_Structure)  =   0
  18.     Structure   RS_XUP
  19.         *IN_Ptr     ;*Ptr to packed data or @Filename
  20.         IN_Len.i        ;iSize of packed data or NULL if Filename
  21.         *OUT_Ptr        ;*Ptr to unpacked data
  22.         OUT_Len.i   ;iSize of unpacked data
  23.         PK_Mode.i   ;iMode of packing (Zip/JCalG1)
  24.         PK_Level.i  ;iEfficiency (0-9)
  25.         Error.i     ;Errorcode <> #NUL when error/unpacked
  26.         Flags.i     ;Private! (If not NULL, *IN_Ptr init by XUP_Unpack)
  27.     EndStructure    ;:  Global  XUP.RS_XUP
  28. CompilerEndIf
  29.  
  30. DeclareModule   XUP
  31. Declare Free(*RS)
  32. Declare Unpack(*RS)
  33. EndDeclareModule
  34.  
  35. Module  XUP
  36.  
  37. #XUP_WINAPI =   1   ; Windows API ->    0 = off / 1 = on
  38.  
  39. ; *************************************************************************************************************
  40. ; i_XUP.pbi     :   Main-Structure
  41. ; *************************************************************************************************************
  42. Structure   RS_XUP
  43.     *IN_Ptr     ;*Ptr to packed data or @Filename
  44.     IN_Len.i        ;iSize of packed data or NULL if Filename
  45.     *OUT_Ptr        ;*Ptr to unpacked data
  46.     OUT_Len.i   ;iSize of unpacked data
  47.     PK_Mode.i   ;iMode of packing (Zip/JCalG1)
  48.     PK_Level.i  ;iEfficiency (0-9)
  49.     Error.i     ;Errorcode <> #NUL when error/unpacked
  50.     Flags.i     ;Private! (If not NULL, *IN_Ptr init by XUP_Unpack)
  51. EndStructure    ;:  Global  XUP.RS_XUP
  52.  
  53. ; *************************************************************************************************************
  54. ; i_XUP.pbi     :   Macros
  55. ; *************************************************************************************************************
  56. CompilerIf  #XUP_WINAPI
  57.  
  58.     Macro   MA_MemAlloc(SIZE)               :   GlobalAlloc_(#GMEM_ZEROINIT, SIZE)  :   EndMacro
  59.     Macro   MA_MemFree(PTR)             :   GlobalFree_(PTR)                            :   EndMacro
  60.     Macro   MA_MemSize(PTR)             :   GlobalSize_(PTR)                            :   EndMacro
  61.     Macro   MA_MemMove(SRC, DST, SIZE)  :   MoveMemory_(DST, SRC, SIZE)         :   EndMacro
  62.     Macro   MA_MemCopy(SRC, DST, SIZE)  :   CopyMemory_(DST, SRC, SIZE)         :   EndMacro
  63.     Macro   MA_MemFill(PTR, SIZE, VAL)  :   FillMemory_(PTR, SIZE, VAL)         :   EndMacro
  64.  
  65.     Macro   MA_FileOpen(FILENAME)
  66.         CreateFile_(FILENAME, #GENERIC_READ, #FILE_SHARE_READ, #NUL, #OPEN_EXISTING, #FILE_ATTRIBUTE_NORMAL, #NUL)
  67.     EndMacro
  68.     Macro   MA_FileSize(HFILE)              :   GetFileSize_(HFILE, #NUL)                       :   EndMacro
  69.     Macro   MA_FileRead(HFILE, PTR, SIZE)   :   ReadFile_(HFILE, PTR, SIZE, @SIZE, #NUL)    :   EndMacro
  70.     Macro   MA_FileClose(HFILE)             :   CloseHandle_(HFILE)                             :   EndMacro
  71.  
  72. CompilerElse
  73.  
  74.     Macro   MA_MemAlloc(SIZE)               :   AllocateMemory(SIZE)            :   EndMacro
  75.     Macro   MA_MemFree(PTR)             :   FreeMemory(PTR)             :   EndMacro
  76.     Macro   MA_MemSize(PTR)             :   MemorySize(PTR)             :   EndMacro
  77.     Macro   MA_MemMove(SRC, DST, SIZE)  :   MoveMemory(SRC, DST, SIZE)  :   EndMacro
  78.     Macro   MA_MemCopy(SRC, DST, SIZE)  :   CopyMemory(SRC, DST, SIZE)  :   EndMacro
  79.     Macro   MA_MemFill(PTR, SIZE, VAL)  :   FillMemory(PTR, SIZE, VAL)  :   EndMacro
  80.  
  81.     Macro   MA_FileOpen(FILENAME)           :   ReadFile(#PB_Any, PeekS(FILENAME))  :   EndMacro
  82.     Macro   MA_FileSize(HFILE)              :   Lof(HFILE)                                  :   EndMacro
  83.     Macro   MA_FileRead(HFILE, PTR, SIZE)   :   ReadData(HFILE, PTR, SIZE)              :   EndMacro
  84.     Macro   MA_FileClose(HFILE)             :   CloseFile(HFILE)                            :   EndMacro
  85.  
  86. CompilerEndIf
  87.  
  88. Macro   MA_Error(VAL)
  89.     If  *RS\OUT_Len <=  #Null
  90.         *RS\Error   =   VAL
  91.     Else
  92.         *RS\Error   =   #XUPERR_OK
  93.     EndIf
  94.     ProcedureReturn *RS\Error
  95. EndMacro
  96.  
  97. Macro   UINT32(a)
  98.     ((((a)&$FF)<<24)|(((a)&$FF00)<<8)|(((a)>>8)&$FF00)|(((a)>>24)&$FF))
  99. EndMacro
  100.  
  101. Macro   ID_LONG(a,b,c,d)
  102.     (a)|(b<<8)|(c<<16)|(d<<24)
  103. EndMacro
  104. Macro   ID_WORD(a,b)
  105.     (a)|(b<<8)
  106. EndMacro
  107.  
  108. ; *************************************************************************************************************
  109. ; i_XUP.pbi     :   Enumeration
  110. ; *************************************************************************************************************
  111. Enumeration ; *** Errors
  112.     #XUPERR_OK  =   0
  113.     #XUPERR_FILE
  114.     #XUPERR_UNPACK
  115.     #XUPERR_NOTPACKED
  116.     #XUPERR_UNKNOWN
  117. EndEnumeration
  118.  
  119. EnumerationBinary   ; *** Flags
  120.     #XUPFLG_MEMORY
  121.     #XUPFLG_FILE
  122. EndEnumeration
  123.  
  124. ; *************************************************************************************************************
  125. ; i_XUP.pbi     :   #XUP_MODE   =   1<<?    or  #NUL
  126. ; *************************************************************************************************************
  127. EnumerationBinary   ; *** UnPack Bitwise Modes
  128.     #XUP_PP20       ; Amiga PowerPacker
  129.     #XUP_FIMP       ; Amiga FileImploder
  130.     #XUP_XPKF       ; Amiga XPK [SQSH|PWPK|IMPL|BZP2|GZIP|NONE]
  131.     #XUP_NONE       ; Amiga XPK NONE
  132.     #XUP_JCAL       ; JCalG1
  133.     #XUP_BZP2       ; BZip2
  134.     #XUP_GZIP       ; GZip & Zip
  135.     #XUP_NPKZ       ; NoisePlug Zip
  136.     #XUP_ICEI       ; ICE! & ATOMIK
  137.     #XUP_PACK       ; Allow compression
  138. EndEnumeration
  139.  
  140. #XUP_MC68   =   #XUP_PP20|#XUP_FIMP|#XUP_NONE|#XUP_XPKF ; *** Small AMIGA unpacker only
  141. ;#XUP_MODE  =   #XUP_MC68|#XUP_JCAL|#XUP_BZP2|#XUP_GZIP ; *** Used unpacker
  142.  
  143. CompilerIf  Defined(XUP_MODE,       #PB_Constant)   =   0
  144.     #XUP_MODE   =   $FFFFFFFF!(#XUP_PACK);|#XUP_JCAL|#XUP_ICEI) ; All unpackers but no JCalG1/ICEI and no packing (Default)
  145. CompilerEndIf
  146. CompilerIf  Defined(NUL,            #PB_Constant)   =   0
  147.     #NUL    =   0
  148. CompilerEndIf
  149. CompilerIf  Defined(XUP_PATH$,  #PB_Constant)   =   0
  150.     #XUP_PATH$  =   #PB_Compiler_FilePath + "Include\"
  151. CompilerEndIf
  152.  
  153. ; NoisePlug JCalG1 + Zipped
  154. #XUPID_JCAL =   ID_WORD('J','C')    ;'CJ'       ; NoisePlug JCalG1
  155. #XUPID_NPKZ =   ID_WORD('Z','C')    ;'CZ'       ; NoisePlug Zipped
  156.  
  157. ; PP20
  158. #XUPID_PP10 =   ID_LONG('P','P','1','0')    ;'01PP' ; PowerPacker v1.0
  159. #XUPID_PP11 =   ID_LONG('P','P','1','1')    ;'11PP' ; PowerPacker v1.1
  160. #XUPID_PP15 =   ID_LONG('P','P','1','5')    ;'51PP' ; PowerPacker v1.5
  161. #XUPID_PP20 =   ID_LONG('P','P','2','0')    ;'02PP' ; PowerPacker v2.0+
  162. #XUPID_PPLS =   ID_LONG('P','P','L','S')    ;'SLPP' ; PowerPacker LoadSeg
  163. #XUPID_PPBK =   ID_LONG('P','P','b','k')    ;'kbPP' ; PowerPacker AMOSPro PPBank
  164.  
  165. ; FIMP
  166. #XUPID_FIMP =   ID_LONG('I','M','P','!')    ;'!PMI'
  167. #XUPID_MADE =   ID_LONG('M','A','D','E')    ;'EDAM'
  168. #XUPID_IFHC =   ID_LONG('I','F','H','C')    ;'CHFI'
  169. #XUPID_PARA =   ID_LONG('P','A','R','A')    ;'ARAP'
  170. #XUPID_9CDR =   ID_LONG('9','C','D','R')    ;'RDC9'
  171. #XUPID_FLTI =   ID_LONG('F','L','T','!')    ;'!TLF'
  172. #XUPID_DUPA =   ID_LONG('D','u','p','a')    ;'apuD'
  173.  
  174. ; XPK Compressors
  175. #XUPID_XPKF =   ID_LONG('X','P','K','F')    ;'FKPX'
  176. #XUPID_SQSH =   ID_LONG('S','Q','S','H')    ;'HSQS'
  177. #XUPID_PWPK =   ID_LONG('P','W','P','K')    ;'KPWP'
  178. #XUPID_BZP2 =   ID_LONG('B','Z','P','2')    ;'2PZB'
  179. #XUPID_NONE =   ID_LONG('N','O','N','E')    ;'ENON'
  180. #XUPID_GZIP =   ID_LONG('G','Z','I','P')    ;'PIZG'
  181. #XUPID_IMPL =   ID_LONG('I','M','P','L')    ;'LPMI' ; XPKF -> IMPL = Bug > 64Kb
  182. #XUPID_RLEN =   ID_LONG('R','L','E','N')    ;'NELR'
  183.  
  184. ; ICE & ATOMIK (Atari)
  185. #XUPID_IC21 =   ID_LONG('I','c','e','!')    ;'!ecI' ; ICE Packer 2.1
  186. #XUPID_IC24 =   ID_LONG('I','C','E','!')    ;'!ECI' ; ICE Packer 2.4
  187. #XUPID_ATM5 =   ID_LONG('A','T','M','5')    ;'5MTA' ; Atomik Packer 3.5
  188.  
  189. #XUPPAK_JCAL    =   1<<0    ; JCalG1 CompressMem
  190. #XUPPAK_ZIPM    =   1<<1    ; Zip CompressMem
  191.  
  192. ; *************************************************************************************************************
  193. ; i_XUP.pbi     :   Includelibs
  194. ; *************************************************************************************************************
  195. #XUPLIB_BZP2$   =   "bzip2_x86.lib"
  196. #XUPLIB_GZIP$   =   "zlib_x86.lib"
  197. #XUPLIB_PP20$   =   "pp20_x86.lib"
  198. #XUPLIB_FIMP$   =   "fimp_x86.lib"
  199. #XUPLIB_SQSH$   =   "xpk_sqsh_x86.a"
  200. #XUPLIB_JCAL$   =   "jcalg1_static_x86.lib"
  201. #XUPLIB_ICEI$   =   "unicelib_x86.lib"
  202.  
  203. CompilerIf  #XUP_MODE   &   #XUP_PP20
  204.     ; *** Amiga PowerPacker Data (PP20)
  205.     ImportC #XUPLIB_PP20$
  206.         PPK_GetSize(*src, srclen)                           As  "_ppGetDecrunchSize"
  207.         PPK_Decrunch(*src, *dest, srclen, destlen)  As  "_ppDecrunchMemory"
  208.     EndImport
  209. CompilerEndIf
  210. CompilerIf  #XUP_MODE   &   #XUP_FIMP
  211.     ; *** Amiga FileImploder (FImp)
  212.     ImportC #XUPLIB_FIMP$
  213.         IMP_GetSize(*src)                                       As  "_impGetExplodeSize"
  214.         IMP_Decrunch(*src, srclen, *dest, destlen)  As  "_impExplode"
  215.     EndImport
  216. CompilerEndIf
  217. CompilerIf  #XUP_MODE   &   #XUP_XPKF
  218.     ; *** Amiga eXtendedPacKer (XPK\compressors)
  219.     ImportC #XUPLIB_SQSH$
  220.         XPK_Check(*src, *srclen, *dstlen)   As  "__Z9xpk_checkPhS_S_"
  221.         XPK_Unpack(*src, *dst)                  As  "__Z10xpk_unpackPhS_"
  222.         ;XPK_GetSize(*src)          As  "_XPK_Length"
  223.         ;XPK_Decrunch(*src, *dest)  As  "_XPK_Unpack"
  224.     EndImport
  225. CompilerEndIf
  226. CompilerIf  #XUP_MODE   &   #XUP_JCAL
  227.     Import  #XUPLIB_JCAL$
  228.         JCA_Decrunch(*src, *dest)   As  "_JCALG1_Decompress_Fast@8"
  229.         ;JCA_Decrunch(*src, *dest)  As  "_JCALG1_Decompress_Small@8"
  230.         ;JCA_Crunch(*src, srclen, *dest, Windowsize.l, *pAlloc, *pDealloc, *pCallback, bDisableChecksum.l)  As  _JCALG1_Compress@32
  231.     EndImport
  232. CompilerEndIf
  233. CompilerIf  #XUP_MODE   &   #XUP_BZP2
  234.     ; *** BZip2
  235.     Import  #XUPLIB_BZP2$
  236.         BZ2_Decrunch(*DestBuff, *DestSize, *SourceBuff, iSourceSize, small, verbosity)  As  "_BZ2_bzBuffToBuffDecompress@24"
  237.         ;BZ2_bzBuffToBuffCompress.i (*DestBuff, *DestSize, *SourceBuff, iSourceSize, iBlockSize, verbosity, workFactor)
  238.         ;BZ2_bzBuffToBuffDecompress.i (*DestBuff, *DestSize, *SourceBuff, iSourceSize, small, verbosity)
  239.     EndImport
  240. CompilerEndIf
  241. CompilerIf  #XUP_MODE   &   (#XUP_GZIP  |   #XUP_NPKZ)
  242.     ; *** Zip
  243.     ImportC #XUPLIB_GZIP$
  244.         ZIP_Decrunch(*DestBuff, *iDestSize, *SourceBuff, iSourceSize)                           As  "_uncompress"
  245.         CompilerIf  #XUP_MODE&#XUP_PACK
  246.             ZIP_Crunch(*DestBuff, *iDestSize, *SourceBuff, iSourceSize, iCompressionLevel)  As  "_compress2"
  247.         CompilerEndIf
  248.         ;compress2.i(*DestBuff, *iDestSize, *SourceBuff, iSourceSize, iCompressionLevel)
  249.         ;uncompress.i(*DestBuff, *iDestSize, *SourceBuff, iSourceSize)
  250.     EndImport
  251. CompilerEndIf
  252. CompilerIf  #XUP_MODE   &   #XUP_ICEI
  253.     ; *** Atari ICE! & Atomik Unpacker
  254.     ImportC #XUPLIB_ICEI$
  255.         ; Atomik Packer 3.5
  256.         ; atm_35_get_long()         As  "_atm_35_get_long"
  257.         ; atm_35_getbits()          As  "_atm_35_getbits"
  258.         atm_35_header(*src)         As  "_atm_35_header"
  259.         atm_35_packedsize(*src)     As  "_atm_35_packedsize"
  260.         atm_35_origsize(*src)       As  "_atm_35_origsize"
  261.         atm_35_depack(*src, *dest)  As  "_atm_35_depack"
  262.  
  263.         ; Pack Ice 2.1
  264.         ; get_long()                    As  "_get_long"
  265.         ; ice_get_long()                As  "_ice_get_long"
  266.         ; ice_getbits()             As  "_ice_getbits"
  267.         ice_21_header(*src)         As  "_ice_21_header"
  268.         ice_21_packedsize(*src)     As  "_ice_21_packedsize"
  269.         ice_21_origsize(*src)       As  "_ice_21_origsize"
  270.         ice_21_depack(*src, *dest)  As "_ice_21_depack"
  271.  
  272.         ; Pack Ice 2.4
  273.         ; get24_long()                  As  "_get24_long"
  274.         ; ice24_get_long()          As  "_ice24_get_long"
  275.         ; ice24_getbits()               As  "_ice24_getbits"
  276.         ice_24_header(*src)         As  "_ice_24_header"
  277.         ice_24_packedsize(*src)     As  "_ice_24_packedsize"
  278.         ice_24_origsize(*src)       As  "_ice_24_origsize"
  279.         ice_24_depack(*src, *dest)  As  "_ice_24_depack"
  280.     EndImport
  281. CompilerEndIf
  282.  
  283. ; *************************************************************************************************************
  284. ; i_XUP.pbi     :   Functions(struc RS_XUP)
  285. ; *************************************************************************************************************
  286. Procedure   Free(*RS.RS_XUP)
  287.  
  288.     ; Should be called before or after unpacking (free intern memory allocation)
  289.  
  290.     With    *RS
  291.  
  292.         If  \OUT_Ptr    >   #Null
  293.             If  \OUT_Ptr    <>  \IN_Ptr
  294.                 MA_MemFree(\OUT_Ptr)
  295.             EndIf
  296.         EndIf
  297.  
  298.         If  \Flags  &   #XUPFLG_FILE
  299.             If  \IN_Ptr >   #Null
  300.                 MA_MemFree(\IN_Ptr)
  301.             EndIf
  302.             \IN_Ptr =   #Null
  303.             \IN_Len =   #Null
  304.         EndIf
  305.  
  306.         \OUT_Ptr    =   #Null
  307.         \OUT_Len    =   #Null
  308.  
  309.         \Flags  =   #Null
  310.         \Error  =   #Null
  311.  
  312.         ;ClearStructure(@*RS, RS_XUP)
  313.  
  314.     EndWith
  315.  
  316. EndProcedure
  317. Procedure   Unpack(*RS.RS_XUP)
  318.  
  319.     ; *********************************************************************************
  320.     ; In:       RS\IN_Ptr   ->  *Ptr to membuf of packed data -> or *StrPtr of @Filename$
  321.     ;           RS\IN_Len   ->  Size of packed membuf. If *Ptr = @Filename$ MUST! be #NULL
  322.     ;
  323.     ; Out:  RS\OUT_Ptr  ->  *Ptr to unpacked data
  324.     ;           RS\OUT_Len  ->  Size of unpacked membuf -> NUL if error
  325.     ;
  326.     ; Pack: RS\PK_Mode  ->  Unpack = *Ptr to Suffix / Pack = Mode (JC/ZC)
  327.     ;           RS\PK_Level ->  Level of pack-effiziency (0-9)
  328.     ;
  329.     ; Misc: RS\Error        ->  <> NUL = Error when packing
  330.     ;           RS\Flags        ->  #XUP_FLAG_FILE -> IN_Ptr = @Filename$ (free intern memory)
  331.     ; *********************************************************************************
  332.  
  333.     Protected   i, hFile
  334.  
  335.     With    *RS
  336.        
  337.         ; ******************************************************************
  338.         ; * IN_LEN <= 0 then -> IN_PTR = @Filename$ -> Flag = #XUP_FLAG_FILE
  339.         ; ******************************************************************
  340.         If  \IN_Len <=  #Null
  341.             hFile   =   MA_FileOpen(\IN_Ptr)
  342.             If  hFile
  343.                 \Flags  =   #XUPFLG_FILE    ; s. XUP_Free()
  344.                 \IN_Len =   MA_FileSize(hFile)
  345.                 \IN_Ptr =   MA_MemAlloc(\IN_Len+SizeOf(Long))   ; Add long if text (zero-ending)
  346.                 MA_FileRead(hFile, \IN_Ptr, \IN_Len)
  347.                 MA_FileClose(hFile)
  348.             Else
  349.                 \Error  =   #XUPERR_FILE
  350.                 ProcedureReturn \Error
  351.             EndIf
  352.         EndIf
  353.  
  354.         If  \IN_Len >   #NUL
  355.  
  356.             \OUT_Ptr    =   \IN_Ptr
  357.             \OUT_Len    =   \IN_Len
  358.  
  359.             ;*********************************************
  360.             ;* NPK Z -> ZC
  361.             ;*********************************************
  362.             CompilerIf  #XUP_MODE   &   #XUP_NPKZ
  363.                 If  PeekW(\IN_Ptr)  =   #XUPID_NPKZ
  364.                     \OUT_Len    =   PeekL(\IN_Ptr+SizeOf(Word))
  365.                     If  \OUT_Len    >   0   And \OUT_Len    <   $FFFFF
  366.                         For i   =   \IN_Len - 32    To  \IN_Len
  367.                             If  PeekL(\IN_Ptr + i)  =   'DIPN'  ;NPID TAG -> iNPID+lSIZE+szEXT$
  368.                                 \PK_Mode    =   \IN_Ptr + i
  369.                                 \IN_Len =   i
  370.                                 Break
  371.                             EndIf
  372.                         Next
  373.                         \OUT_Ptr    =   MA_MemAlloc(\OUT_Len)
  374.                         If  ZIP_Decrunch(\OUT_Ptr, @\OUT_Len, \IN_Ptr+6, \IN_Len)
  375.                             MA_MemFree(\OUT_Ptr)
  376.                             \OUT_Ptr    =   #NUL
  377.                             \OUT_Len    =   #NUL
  378.                         EndIf
  379.                     EndIf
  380.                     MA_Error(#XUPERR_UNPACK)
  381.                 EndIf
  382.             CompilerEndIf
  383.  
  384.             ;*********************************************
  385.             ;* NPK JCalG1 -> JC
  386.             ;*********************************************
  387.             CompilerIf  #XUP_MODE   &   #XUP_JCAL
  388.                 If  PeekW(\IN_Ptr)  =   #XUPID_JCAL
  389.                     \OUT_Len    =   PeekL(\IN_Ptr+SizeOf(Word))
  390.                     If  \OUT_Len    >   0   And \OUT_Len    <   $FFFFF
  391.                         For i   =   \IN_Len - 32    To  \IN_Len
  392.                             If  PeekL(\IN_Ptr + i)  =   'DIPN'  ;NPID (NoisePlug)
  393.                                 \PK_Mode    =   \IN_Ptr + i
  394.                                 \IN_Len =   i
  395.                                 Break
  396.                             EndIf
  397.                         Next
  398.                         If  \PK_Mode
  399.                             \OUT_Ptr    =   MA_MemAlloc(\OUT_Len)
  400.                             If  \OUT_Ptr
  401.                                 \OUT_Len    =   JCA_Decrunch(\IN_Ptr, \OUT_Ptr) ; \OUT_Len  =   UnpackMemory(\IN_Ptr, \OUT_Ptr)
  402.                                 If  \OUT_Len    =   #NUL
  403.                                     MA_MemFree(\OUT_Ptr)
  404.                                     \OUT_Ptr    =   #NUL
  405.                                 EndIf
  406.                             Else
  407.                                 \OUT_Len    =   #NUL
  408.                             EndIf
  409.                         Else
  410.                             \OUT_Len    =   #NUL
  411.                         EndIf
  412.                     EndIf
  413.                     MA_Error(#XUPERR_UNPACK)
  414.                 EndIf
  415.             CompilerEndIf
  416.  
  417.             ;*********************************************
  418.             ;* Amiga XPKF -> PWPK|IMPL|SQSH|BZP2|GZIP|NONE
  419.             ;*********************************************
  420.             CompilerIf  #XUP_MODE   &   #XUP_XPKF
  421.                 If  PeekL(\IN_Ptr)  =   #XUPID_XPKF
  422.                     Select  PeekL(\IN_Ptr+8)
  423.  
  424.                             CompilerIf  #XUP_MODE   &   #XUP_PP20
  425.                             Case    #XUPID_PWPK ;Convert XPKF -> PWPK = PP20...
  426.                                 Select  PeekB(\IN_Ptr+\IN_Len-13)
  427.                                     Case    0   :   i   =   $09090909
  428.                                     Case    1   :   i   =   $0A0A0A09   ;01010100
  429.                                     Case    2   :   i   =   $0B0B0A09   ;02020100
  430.                                     Case    3   :   i   =   $0C0C0A09   ;03030200
  431.                                     Default :   i   =   $0D0C0A09   ;04030100
  432.                                 EndSelect
  433.                                 MA_MemMove(\IN_Ptr + $30, \IN_Ptr + $8, \IN_Len - $38)
  434.                                 PokeL(\IN_Ptr, #XUPID_PP20)
  435.                                 PokeL(\IN_Ptr + 4, i)
  436.                                 \IN_Len -   $38
  437.                             CompilerEndIf
  438.  
  439.                             CompilerIf  #XUP_MODE   &   (#XUP_BZP2  |   #XUP_GZIP)
  440.                             Case    #XUPID_BZP2, #XUPID_GZIP    ;Convert XPKF -> BZP2 = BZ / GZIP = ZIP...
  441.                                 MA_MemMove(\IN_Ptr + $2C, \IN_Ptr, \IN_Len - $2C)
  442.                                 \OUT_Len    =   PeekI(\IN_Ptr)
  443.                                 \OUT_Len    =   UINT32(\OUT_Len)
  444.                                 PokeI(\IN_Ptr, \OUT_Len)
  445.                                 \IN_Len -   $38
  446.                             CompilerEndIf
  447.  
  448.                             CompilerIf  #XUP_MODE   &   #XUP_NONE
  449.                             Case    #XUPID_NONE ;Unpack XPKF -> NONE
  450.                                 \OUT_Len    =   \IN_Len -   $2C
  451.                                 \OUT_Ptr    =   MA_MemAlloc(\OUT_Len)   ; Important: Packed IN_Len > Unpacked OUT_Len
  452.                                 MA_MemCopy(\IN_Ptr + $2C, \OUT_Ptr, \OUT_Len)
  453.                                 ProcedureReturn #XUPERR_OK
  454.                             CompilerEndIf
  455.  
  456.                             CompilerIf  #XUP_MODE   &   #XUP_FIMP
  457.                             Case    #XUPID_IMPL ;Convert XPKF = IMPL -> IMP!...
  458.                                 MA_MemMove(\IN_Ptr + $30, \IN_Ptr, \IN_Len - $30)
  459.                                 \IN_Len -   $36
  460.                             CompilerEndIf
  461.  
  462.                         Case    #XUPID_SQSH ;Unpack XPKF -> SQSH / Bug? in returned \OUT_Len, must! calculated
  463.                             If  XPK_Check(\IN_Ptr, @\IN_Len, @\OUT_Len) >   #NUL
  464.                                 \OUT_Len    =   PeekL(\IN_Ptr   +   $C)
  465.                                 \OUT_Len    =   UINT32(\OUT_Len)
  466.                                 \OUT_Ptr    =   MA_MemAlloc(\OUT_Len * 2)
  467.                                 If  XPK_Unpack(\IN_Ptr, \OUT_Ptr)   <   #NUL
  468.                                     MA_MemFree(\OUT_Ptr)
  469.                                     \OUT_Ptr    =   #NUL
  470.                                     \OUT_Len    =   #NUL
  471.                                 EndIf
  472.                             EndIf
  473.  
  474.                             MA_Error(#XUPERR_UNPACK)    ; If ERROR then EndProcedure
  475.  
  476.                     EndSelect
  477.                 EndIf
  478.             CompilerEndIf
  479.  
  480.             ;*********************************************
  481.             ;* Amiga PowerPacker PP20|PP11|PPLS|PPbk
  482.             ;*********************************************
  483.             CompilerIf  #XUP_MODE   &   #XUP_PP20
  484.                 Select  PeekL(\IN_Ptr)
  485.                     Case    #XUPID_PP20,#XUPID_PPBK,#XUPID_PP10,#XUPID_PP11,#XUPID_PP15,#XUPID_PPLS
  486.                         \OUT_Len    =   PPK_GetSize(\IN_Ptr, \IN_Len)
  487.                         If  \OUT_Len    >   0
  488.                             \OUT_Ptr    =   MA_MemAlloc(\OUT_Len)
  489.                             If  PPK_Decrunch(\IN_Ptr, \OUT_Ptr, \IN_Len, \OUT_Len)  >=  #NUL
  490.                                 If  PeekL(\IN_Ptr)  =   #XUPID_PPBK ;AMOSPro Bank? ID="Work"+SPC[4]
  491.                                     MA_MemMove(\OUT_Ptr+8, \OUT_Ptr, \OUT_Len-8)
  492.                                     \OUT_Len    -   8
  493.                                 EndIf
  494.                             Else
  495.                                 MA_MemFree(\OUT_Ptr)
  496.                                 \OUT_Len    =   #NUL
  497.                                 \OUT_Ptr    =   #NUL
  498.                             EndIf
  499.                         EndIf
  500.                         MA_Error(#XUPERR_UNPACK)    ; If ERROR then EndProcedure
  501.                 EndSelect
  502.             CompilerEndIf
  503.  
  504.             ;*********************************************
  505.             ;* Amiga FileImploder (FImp) IMP!
  506.             ;*********************************************
  507.             CompilerIf  #XUP_MODE   &   #XUP_FIMP
  508.                 Select  PeekL(\IN_Ptr)
  509.                     Case    #XUPID_FIMP,#XUPID_MADE,#XUPID_IFHC,#XUPID_PARA,#XUPID_9CDR,#XUPID_FLTI,#XUPID_DUPA
  510.                         \OUT_Len    =   IMP_GetSize(\IN_Ptr)
  511.                         If  \OUT_Len    >   0
  512.                             \OUT_Ptr    =   MA_MemAlloc(\OUT_Len * 2)
  513.                             If  IMP_Decrunch(\IN_Ptr, \IN_Len, \OUT_Ptr, \OUT_Len)  <   #NUL    ;ERROR?
  514.                                 MA_MemFree(\OUT_Ptr)
  515.                                 \OUT_Ptr    =   #NUL
  516.                                 \OUT_Len    =   #NUL
  517.                             EndIf
  518.                         EndIf
  519.                         MA_Error(#XUPERR_UNPACK)    ; If ERROR then EndProcedure
  520.                 EndSelect
  521.             CompilerEndIf
  522.  
  523.             ;*********************************************
  524.             ;* Atari ICE! & ATOMIK -> Ice!|ICE!|ATM5
  525.             ;*********************************************
  526.             CompilerIf  #XUP_MODE   &   #XUP_ICEI
  527.                 Select  PeekL(\IN_Ptr)
  528.                     Case    #XUPID_IC21,#XUPID_IC24,#XUPID_ATM5
  529.                         Select  PeekL(\IN_Ptr)
  530.                             Case    #XUPID_IC21 :   \OUT_Len    =   ice_21_origsize(\IN_Ptr)
  531.                             Case    #XUPID_IC24 :   \OUT_Len    =   ice_24_origsize(\IN_Ptr)
  532.                             Case    #XUPID_ATM5 :   \OUT_Len    =   atm_35_origsize(\IN_Ptr)
  533.                         EndSelect
  534.                         If  \OUT_Len    >   0
  535.                             \OUT_Ptr    =   MA_MemAlloc(\OUT_Len)
  536.                             Select  PeekL(\IN_Ptr)
  537.                                 Case    #XUPID_IC21 :   \OUT_Len    =   ice_21_depack(\IN_Ptr, \OUT_Ptr)
  538.                                 Case    #XUPID_IC24 :   \OUT_Len    =   ice_24_depack(\IN_Ptr, \OUT_Ptr)
  539.                                 Case    #XUPID_ATM5 :   \OUT_Len    =   atm_35_depack(\IN_Ptr, \OUT_Ptr)
  540.                             EndSelect
  541.                             If  \OUT_Len    <=  #NUL    ;ERROR
  542.                                 MA_MemFree(\OUT_Ptr)
  543.                                 \OUT_Ptr    =   #NUL
  544.                                 \OUT_Len    =   #NUL
  545.                             EndIf
  546.                         EndIf
  547.                         MA_Error(#XUPERR_UNPACK)    ; If ERROR then EndProcedure
  548.                 EndSelect
  549.             CompilerEndIf
  550.  
  551.             ;*********************************************
  552.             ;* BZip2 (Buffer)
  553.             ;*********************************************
  554.             CompilerIf  #XUP_MODE   &   #XUP_BZP2
  555.                 If  PeekW(\IN_Ptr+SizeOf(Long)) =   'ZB'
  556.                     \OUT_Len    =   PeekL(\IN_Ptr)
  557.                     \OUT_Ptr    =   MA_MemAlloc(\OUT_Len)
  558.                     If  BZ2_Decrunch(\OUT_Ptr, @\OUT_Len, \IN_Ptr + SizeOf(Long), \IN_Len - SizeOf(Long), 0, 0)
  559.                         MA_MemFree(\OUT_Ptr)
  560.                         \OUT_Ptr    =   #NUL
  561.                         \OUT_Len    =   #NUL
  562.                     EndIf
  563.                     MA_Error(#XUPERR_UNPACK)    ; If ERROR then EndProcedure
  564.                 EndIf
  565.             CompilerEndIf
  566.  
  567.             ;*********************************************
  568.             ;* GZip (Buffer)
  569.             ;*********************************************
  570.             CompilerIf  #XUP_MODE   &   #XUP_GZIP
  571.                 If  PeekB(\IN_Ptr+SizeOf(Long)) =   'x'
  572.                     \OUT_Len    =   PeekL(\IN_Ptr)
  573.                     \OUT_Ptr    =   MA_MemAlloc(\OUT_Len)
  574.                     If  ZIP_Decrunch(\OUT_Ptr, @\OUT_Len, \IN_Ptr + SizeOf(Long), \IN_Len - SizeOf(Long))
  575.                         MA_MemFree(\OUT_Ptr)
  576.                         \OUT_Ptr    =   #NUL
  577.                         \OUT_Len    =   #NUL
  578.                     EndIf
  579.                     MA_Error(#XUPERR_UNPACK)    ; If ERROR then EndProcedure
  580.                 EndIf
  581.             CompilerEndIf
  582.  
  583.         EndIf
  584.  
  585.         If  \IN_Len =   \OUT_Len    Or  \IN_Ptr =   \OUT_Ptr
  586.             ProcedureReturn #XUPERR_NOTPACKED
  587.         EndIf
  588.  
  589.     EndWith
  590.  
  591.     ProcedureReturn #XUPERR_OK  ; All OK, return #NULL
  592.  
  593. EndProcedure
  594.  
  595. ;{ *** XUP PackMemory not used yet *** }
  596. CompilerIf  0
  597.     CompilerIf  #XUP_MODE   &   #XUP_PACK
  598.         Procedure   Pack(*RS.RS_XUP)
  599.  
  600.             Protected   hFile
  601.  
  602.             With    *RS
  603.  
  604.                 ;If not IN_LEN -> IN_PTR = @Filename$ -> Flag = True
  605.                 If  \IN_Len <=  #NUL
  606.                     hFile   =   CreateFile_(\IN_Ptr, #GENERIC_READ, #FILE_SHARE_READ, #NUL, #OPEN_EXISTING, #FILE_ATTRIBUTE_NORMAL, #NUL)
  607.                     If  hFile   <>  #INVALID_HANDLE_VALUE
  608.                         \Flags  =   #True   ; Memory must be free by XUP
  609.                         \IN_Len =   GetFileSize_(hFile, #NUL)
  610.                         \IN_Ptr =   MA_MemAlloc(\IN_Len)
  611.                         ReadFile_(hFile, \IN_Ptr, \IN_Len, @\IN_Len, #NUL)
  612.                         CloseHandle_(hFile)
  613.                     EndIf
  614.                 EndIf
  615.  
  616.                 If  \IN_Len >   #NUL
  617.                     \OUT_Len    =   \IN_Len * 2
  618.                     \OUT_Ptr    =   MA_MemAlloc(\OUT_Len)
  619.                     Select  \PK_Mode
  620.                         Case    #XUPPAK_ZIPM
  621.                             \Error  =   ZIP_Crunch(\OUT_Ptr, @\OUT_Len, \IN_Ptr, \IN_Len, \PK_Level)
  622.                     EndSelect
  623.                 EndIf
  624.  
  625.             EndWith
  626.  
  627.             ProcedureReturn *RS
  628.  
  629.         EndProcedure
  630.         ;
  631.     CompilerEndIf
  632. CompilerEndIf
  633. ;}
  634.  
  635. EndModule
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!