• branch=trunk inherited from [db64082547]
• sym-trunk inherited from [db64082547]

Added ArcACE.cpp version [eeea8ebd808979ec]

            1  +
            2  +#include "stdafx.h"
            3  +#include "ArcAce.h"
            4  +#include "NoahApp.h"
            5  +
            6  +
            7  +int CArcAce::v_load()
            8  +{
            9  + if( hDLL = kiSUtil::loadLibrary("UnAceV2") )
           10  + {
           11  +  if( (aceInit = (FI)::GetProcAddress( hDLL,"ACEInitDll" ))
           12  +   && (aceHead = (FR)::GetProcAddress( hDLL,"ACEReadArchiveData" ))
           13  +   && (aceList = (FL)::GetProcAddress( hDLL,"ACEList" ))
           14  +   && (aceTest = (FT)::GetProcAddress( hDLL,"ACETest" ))
           15  +   && (aceExtr = (FE)::GetProcAddress( hDLL,"ACEExtract" )) )
           16  +  {
           17  +   tACEInitDllStruc ini;
           18  +   ki_memzero( &ini, sizeof(ini) );
           19  +
           20  +   ini.GlobalData.Obj                 = this;
           21  +   ini.GlobalData.MaxArchiveTestBytes = 0x2ffFF;
           22  +   ini.GlobalData.MaxFileBufSize      = 0x2ffFF;
           23  +   ini.GlobalData.InfoCallbackProc    = callback_info;
           24  +   ini.GlobalData.ErrorCallbackProc   = callback_error;
           25  +   ini.GlobalData.RequestCallbackProc = callback_request;
           26  +   ini.GlobalData.StateCallbackProc   = callback_state;
           27  +   ini.GlobalData.DecryptPassword     = pwdBuf;
           28  +
           29  +   if( 0 == aceInit( &ini ) )
           30  +    return aCheck|aMelt|aList|aMeltEach;
           31  +  }
           32  +
           33  +  ::FreeLibrary( hDLL );
           34  +  hDLL = NULL;
           35  + }
           36  + return 0;
           37  +}
           38  +
           39  +bool CArcAce::v_ver( kiStr& str )
           40  +{
           41  + str = "UnAceV2.dll  ";
           42  +
           43  + //-- ���݊m�F
           44  + char buf[40];
           45  + if( hDLL )
           46  +  if( GetVersionInfoStr( "UnAceV2", buf, sizeof(buf) ) )
           47  +   str += buf;
           48  +  else
           49  +   str += "OK!";
           50  + else
           51  +  str += "----";
           52  +
           53  + return true;
           54  +}
           55  +
           56  +bool CArcAce::v_check( const kiPath& aname )
           57  +{
           58  + //-- ���ɏ���ǂݍ���ł݂�
           59  + tACEReadArchiveDataStruc dt;
           60  + ki_memzero( &dt, sizeof(dt) );
           61  + return (  0==aceHead( const_cast<char*>((const char*)aname), &dt )
           62  +  && NULL!=dt.ArchiveData );
           63  +}
           64  +
           65  +bool CArcAce::v_list( const arcname& aname, aflArray& files )
           66  +{
           67  + list = &files;
           68  +
           69  + //-- ���X�e�B���O�J�n�I
           70  + tACEListStruc lst;
           71  + ki_memzero( &lst, sizeof(lst) );
           72  + lst.Files.SourceDir   = "";
           73  + lst.Files.FileList    = "*";
           74  + lst.Files.ExcludeList = "";
           75  + lst.Files.FullMatch   = FALSE;
           76  +
           77  + char anm[MAX_PATH];
           78  + ki_strcpy( anm, aname.basedir );
           79  + ki_strcat( anm, aname.lname );
           80  +
           81  + return ( 0==aceList( anm, &lst ) );
           82  +}
           83  +
           84  +int CArcAce::v_contents( const kiPath& aname, kiPath& dname )
           85  +{
           86  + list = NULL;
           87  + aCnt = aUnknown;
           88  + dName = &dname;
           89  +
           90  + //-- ���X�e�B���O�J�n�I
           91  + tACEListStruc lst;
           92  + ki_memzero( &lst, sizeof(lst) );
           93  + lst.Files.SourceDir   = "";
           94  + lst.Files.FileList    = "*";
           95  + lst.Files.ExcludeList = "";
           96  + lst.Files.FullMatch   = TRUE;
           97  + if( 0!=aceList( const_cast<char*>((const char*)aname), &lst ) )
           98  +  return aMulti;
           99  + return aCnt;
          100  +}
          101  +
          102  +int CArcAce::v_melt( const arcname& aname, const kiPath& ddir, const aflArray* files )
          103  +{
          104  + pathCheck = new CArcPathCheckDlg;
          105  +
          106  + //-- �n���t�@�C�����X�g�쐬
          107  + kiStr lst;
          108  + if( files )
          109  + {
          110  +  dlg = NULL;
          111  +  for( unsigned int i=0; i!=list->len(); i++ )
          112  +   if( (*files)[i].selected )
          113  +    lst += (*files)[i].inf.szFileName, lst += '\xd';
          114  + }
          115  + else
          116  +  lst = "*", dlg = new CArcProgressDlg( 32768 );
          117  +
          118  + //-- �W�J�J�n�I
          119  + ::SetCurrentDirectory( ddir );
          120  +
          121  + m_aname = aname.lname;
          122  + pwdBuf[0] = -1;
          123  +
          124  + tACEExtractStruc ex;
          125  + ki_memzero( &ex, sizeof(ex) );
          126  + ex.Files.SourceDir   = "";
          127  + ex.Files.FileList    = const_cast<char*>((const char*)lst);
          128  + ex.Files.ExcludeList = "";
          129  + ex.Files.FullMatch   = files==NULL;
          130  + ex.DestinationDir    = const_cast<char*>((const char*)ddir);
          131  + ex.ExcludePath       = FALSE;
          132  + ex.DecryptPassword   = "";
          133  +
          134  + char anm[MAX_PATH];
          135  + ki_strcpy( anm, aname.basedir );
          136  + ki_strcat( anm, aname.lname );
          137  +
          138  + m_bCanceled = false;
          139  + bool ans = ( 0==aceExtr( anm, &ex ) );
          140  + if( dlg && ans )
          141  + {
          142  +  dlg->change(NULL,32768);
          143  +  ::Sleep(100);
          144  + }
          145  + delete dlg;
          146  + delete pathCheck;
          147  + return ans ? 0 : (m_bCanceled?0x8020:0xffff);
          148  +}
          149  +
          150  +int __stdcall CArcAce::callback_error( pACEErrorCallbackProcStruc Error )
          151  +{
          152  + return ACE_CALLBACK_RETURN_OK;
          153  +}
          154  +
          155  +int __stdcall CArcAce::callback_info( pACEInfoCallbackProcStruc Info )
          156  +{
          157  + return ACE_CALLBACK_RETURN_OK;
          158  +}
          159  +
          160  +int __stdcall CArcAce::callback_request( pACERequestCallbackProcStruc Request )
          161  +{
          162  + // �p�X���[�h�v������ ... ArchivedFile
          163  + if( Request->Global.Code == ACE_CALLBACK_REQUEST_PASSWORD
          164  +  && Request->Global.Operation == ACE_CALLBACK_OPERATION_EXTRACT )
          165  + {
          166  +  CArcAce* ace = (CArcAce*)(Request->Global.GlobalData->Obj);
          167  +  if( ace->pwdBuf[0] == -1 )
          168  +  {
          169  +   ace->pwdBuf[0]=0;
          170  +
          171  +   CArcPwdDlg pwd( ace->dlg ? ace->dlg->hwnd() : NULL, ace->pwdBuf, 60, ace->m_aname );
          172  +   if( IDCANCEL == pwd.getEndCode() )
          173  +   {
          174  +    ace->m_bCanceled = true;
          175  +    return ACE_CALLBACK_RETURN_CANCEL;
          176  +   }
          177  +
          178  +   Request->Global.GlobalData->DecryptPassword = ace->pwdBuf;
          179  +  }
          180  + }
          181  +
          182  + if( Request->Global.Code == ACE_CALLBACK_REQUEST_CHANGEVOLUME )
          183  +  if( !kiSUtil::exist(Request->Archive.ArchiveData->ArchiveName) )
          184  +   return ACE_CALLBACK_RETURN_CANCEL;
          185  +
          186  + return ACE_CALLBACK_RETURN_OK;
          187  +}
          188  +
          189  +int __stdcall CArcAce::callback_state( pACEStateCallbackProcStruc State )
          190  +{
          191  + // �t�@�C�������J�n����or���X�g
          192  + if( State->Progress.Code == ACE_CALLBACK_STATE_STARTFILE )
          193  + {
          194  +  CArcAce* ptr = (CArcAce*)(State->ArchivedFile.GlobalData->Obj);
          195  +
          196  +  if( State->Progress.Operation == ACE_CALLBACK_OPERATION_LIST )
          197  +  {
          198  +   if( !ptr->listup( *(State->ArchivedFile.FileData) ) )
          199  +    return ACE_CALLBACK_RETURN_CANCEL;
          200  +  }
          201  +  else if( State->Progress.Operation == ACE_CALLBACK_OPERATION_EXTRACT )
          202  +  {
          203  +   if( ptr->dlg )
          204  +    ptr->dlg->change( State->ArchivedFile.FileData->SourceFileName );
          205  +   if( ptr->pathCheck )
          206  +    if( containsDangerPath( State->ArchivedFile.FileData->SourceFileName ) )
          207  +     if( ! ptr->pathCheck->is_ok_to_extract( State->ArchivedFile.FileData->SourceFileName, ptr->dlg ) )
          208  +      return ACE_CALLBACK_RETURN_CANCEL;
          209  +  }
          210  + }
          211  + // �i�W�󋵃O���t����
          212  + else if( State->Progress.Code == ACE_CALLBACK_STATE_PROGRESS )
          213  + {
          214  +  CArcAce* ptr = (CArcAce*)(State->ArchivedFile.GlobalData->Obj);
          215  +
          216  +  if( State->Progress.Operation == ACE_CALLBACK_OPERATION_EXTRACT && ptr->dlg )
          217  +  {
          218  +   unsigned long prs = (unsigned long)State->Progress.ProgressData->TotalProcessedSize;
          219  +   unsigned long ttl = (unsigned long)State->Progress.ProgressData->TotalSize;
          220  +   ptr->dlg->change( NULL, ttl ? (int)((((__int64)prs)<<15)/ttl) : 10000 );
          221  +   if( !ptr->dlg->msgloop() )
          222  +   {
          223  +    ptr->m_bCanceled = true;
          224  +    return ACE_CALLBACK_RETURN_CANCEL;
          225  +   }
          226  +  }
          227  + }
          228  + // CRC�`�F�b�N����
          229  + else if( State->Progress.Code == ACE_CALLBACK_STATE_ENDCRCCHECK )
          230  + {
          231  +  if( !State->CRCCheck.CRCOk )
          232  +   ::DeleteFile( State->CRCCheck.FileData->SourceFileName );
          233  + }
          234  +
          235  + return ACE_CALLBACK_RETURN_OK;
          236  +}
          237  +
          238  +bool CArcAce::listup( tACEFileDataStruc& f )
          239  +{
          240  + if( list ) // �S�t�@�C�����X�e�B���O���[�h
          241  + {
          242  +  arcfile x;
          243  +
          244  +  ki_strcpy( x.inf.szFileName, f.SourceFileName );
          245  +  x.isfile = ( 0== (f.Attributes & 0x10) ); //_A_SUBDIR
          246  +  x.inf.dwCompressedSize = (unsigned long)f.CompressedSize;
          247  +  x.inf.dwOriginalSize   = (unsigned long)f.Size;
          248  +  x.inf.wDate = (unsigned short)(f.Time>>16);
          249  +  x.inf.wTime = (unsigned short)(f.Time);
          250  +
          251  +  if( f.Method==0 )  ki_strcpy( x.inf.szMode, "store" );
          252  +  else if( f.Method&2 ) ki_strcpy( x.inf.szMode, "ace2" );
          253  +  else if( f.Method&1 ) ki_strcpy( x.inf.szMode, "ace1" );
          254  +  else     ki_strcpy( x.inf.szMode, "-ace-" );
          255  +
          256  +  list->add( x );
          257  +  return true;
          258  + }
          259  +
          260  + // ���ɓ��t�@�C���\���������[�h
          261  + for( const char* p=f.SourceFileName; *p; p=kiStr::next(p) )
          262  +  if( *p=='\\' || *p=='/' )
          263  +   return true; // ���[�g�̃t�@�C���̂ݏ����Ώہc
          264  +
          265  + if( aCnt != aUnknown )
          266  +  return false;
          267  +
          268  + aCnt = (f.Attributes & 0x10) ? aSingleDir : aSingleFile;
          269  + if( aCnt == aSingleDir )
          270  +  *dName = f.SourceFileName;
          271  +
          272  + return true;
          273  +}

Added ArcACE.h version [c407465455d14dd7]

            1  +#ifndef AFX_ARCACE_H__84B9CB87_29F7_428D_A3E7_F239213B127C__INCLUDED_
            2  +#define AFX_ARCACE_H__84B9CB87_29F7_428D_A3E7_F239213B127C__INCLUDED_
            3  +
            4  +#include "Archiver.h"
            5  +#include "SubDlg.h"
            6  +
            7  +#include "unacedef.h"
            8  +
            9  +class CArcAce : public CArchiver
           10  +{
           11  +public: //-- CArchiver ���� --------------------------------
           12  +
           13  + CArcAce() : CArchiver("ace."), hDLL( NULL ) {}
           14  + virtual ~CArcAce()
           15  + {
           16  +  if(hDLL)
           17  +   ::FreeLibrary(hDLL);
           18  + }
           19  +private:
           20  + int  v_load();
           21  + bool v_ver( kiStr& str );
           22  + bool v_check( const kiPath& aname );
           23  + int  v_contents( const kiPath& aname, kiPath& dname );
           24  + int  v_melt( const arcname& aname, const kiPath& ddir, const aflArray* files );
           25  + bool v_list( const arcname& aname, aflArray& files );
           26  + kiStr v_name(const char*) const { return "Unace32"; }
           27  +
           28  +private: //-- UnAceV2.DLL ���� ------------------------------
           29  +
           30  + HINSTANCE hDLL;
           31  + static int __stdcall callback_error( pACEErrorCallbackProcStruc Error );
           32  + static int __stdcall callback_request( pACERequestCallbackProcStruc Request );
           33  + static int __stdcall callback_state( pACEStateCallbackProcStruc State );
           34  + static int __stdcall callback_info( pACEInfoCallbackProcStruc Info );
           35  + bool listup( tACEFileDataStruc& f );
           36  + aflArray* list;
           37  + CArcProgressDlg* dlg;
           38  + CArcPathCheckDlg* pathCheck;
           39  + char pwdBuf[100];
           40  + const char* m_aname;
           41  + int aCnt;
           42  + kiPath* dName;
           43  + bool m_bCanceled;
           44  +
           45  +private: //-- UnAce.h ---------------------------------------
           46  +
           47  + // API
           48  + typedef int (__stdcall *FI)( pACEInitDllStruc );
           49  + typedef int (__stdcall *FR)( LPSTR, pACEReadArchiveDataStruc );
           50  + typedef int (__stdcall *FL)( LPSTR, pACEListStruc );
           51  + typedef int (__stdcall *FT)( LPSTR, pACETestStruc );
           52  + typedef int (__stdcall *FE)( LPSTR, pACEExtractStruc );
           53  + FI aceInit; FR aceHead; FL aceList; FT aceTest; FE aceExtr;
           54  +};
           55  +
           56  +#endif

Added ArcB2e.cpp version [6032eb8a0710b17d]

            1  +
            2  +#include "stdafx.h"
            3  +#include "ArcB2e.h"
            4  +#include "resource.h"
            5  +#include "NoahApp.h"
            6  +
            7  +//----------------- ArcB2e�N���X�S�̓I�ȏ��� ------------------------------
            8  +
            9  +char CArcB2e::st_base[MAX_PATH];
           10  +int  CArcB2e::st_life=0;
           11  +CArcB2e::CB2eCore* CArcB2e::rvm=NULL;
           12  +
           13  +const char* CArcB2e::init_b2e_path()
           14  +{
           15  + kiPath dir( kiPath::Exe );
           16  + ki_strcpy( st_base, dir+="b2e\\" );
           17  + return st_base;
           18  +}
           19  +
           20  +CArcB2e::CArcB2e( const char* scriptname ) : CArchiver( scriptname )
           21  +{
           22  + st_life++;
           23  + exe = NULL;
           24  + m_LstScr = m_DcEScr = m_EncScr =
           25  + m_DecScr = m_SfxScr = m_LoadScr= m_ScriptBuf = NULL;
           26  +}
           27  +
           28  +CArcB2e::~CArcB2e()
           29  +{
           30  + if( !(--st_life) )
           31  +  delete rvm;
           32  + delete [] m_ScriptBuf;
           33  +}
           34  +
           35  +//------------------- �X�N���v�g���ɂ��܂�֌W���Ȃ����� -------------------------
           36  +
           37  +bool CArcB2e::v_ver( kiStr& str )
           38  +{
           39  + if( !exe )
           40  +  return false;
           41  + exe->ver( str );
           42  +
           43  + kiStr tmp;
           44  + for( int i=0,e=m_subFile.len(); i<e; ++i )
           45  + {
           46  +  str += "\r\n";
           47  +  CArcModule(m_subFile[i]).ver( tmp );
           48  +  str += tmp;
           49  + }
           50  + return true;
           51  +}
           52  +
           53  +bool CArcB2e::v_check( const kiPath& aname )
           54  +{
           55  + return exe ? exe->chk( aname ) : false;
           56  +}
           57  +
           58  +int CArcB2e::v_contents( const kiPath& aname, kiPath& dname )
           59  +{
           60  + return exe ? exe->cnt( aname, dname ) : aUnknown;
           61  +}
           62  +
           63  +//------------------- �X�N���v�g��ǂݍ��݁�eval( load: ) -------------------
           64  +
           65  +bool CArcB2e::load_module( const char* name )
           66  +{
           67  + exe = new CArcModule( name, m_usMode );
           68  + return exe->exist();
           69  +}
           70  +
           71  +int CArcB2e::v_load()
           72  +{
           73  + //-- �g���X�N���v�g�t�@�C�����J��
           74  + kiStr fname( st_base ); fname += mlt_ext();
           75  + kiFile fp;
           76  + if( fp.open( fname ) )
           77  + {
           78  +  //-- �t�@�C���S�̂�ǂݍ���
           79  +  unsigned int ln=fp.getSize();
           80  +  m_ScriptBuf = new char[ ln+1 ];
           81  +  ln = fp.read( (unsigned char*)m_ScriptBuf, ln );
           82  +  m_ScriptBuf[ ln ] = '\0';
           83  +
           84  +  //-- section���ɐ؂蕪����
           85  +  bool pack1,chk=false;
           86  +  for( char* p=m_ScriptBuf; *p; p++ )
           87  +  {
           88  +   switch( *p )
           89  +   {
           90  +   case 'c': case 'd': case 'e': case 'l': case 's':
           91  +    if( ki_memcmp(p,"load:",5) )
           92  +     *p='\0', m_LoadScr = (p+=4)+1;
           93  +    else if( ki_memcmp(p,"encode:",7) )
           94  +     *p='\0', m_EncScr = (p+=6)+1, pack1=false;
           95  +    else if( ki_memcmp(p,"encode1:",8) )
           96  +     *p='\0', m_EncScr = (p+=7)+1, pack1=true;
           97  +    else if( ki_memcmp(p,"decode:",7) )
           98  +     *p='\0', m_DecScr = (p+=6)+1;
           99  +    else if( ki_memcmp(p,"sfx:",4) )
          100  +     *p='\0', m_SfxScr = (p+=3)+1, m_SfxDirect=false;
          101  +    else if( ki_memcmp(p,"sfxd:",5) )
          102  +     *p='\0', m_SfxScr = (p+=4)+1, m_SfxDirect=true;
          103  +    else if( ki_memcmp(p,"check:",6) )
          104  +     *p='\0', (p+=5), chk=true;
          105  +    else if( ki_memcmp(p,"decode1:",8) )
          106  +     *p='\0', m_DcEScr = (p+=7);
          107  +    else if( ki_memcmp(p,"list:",5) )
          108  +     *p='\0', m_LstScr = (p+=4);
          109  +   }
          110  +   while( *p && *p!='\n' && *p!='\r' )
          111  +    p++;
          112  +   if( *p=='\0' )
          113  +    break;
          114  +  }
          115  +
          116  +  //-- [load:]�����s�I
          117  +  if( m_LoadScr )
          118  +  {
          119  +   //-- RythpVM �N��
          120  +   if( !rvm )
          121  +    rvm = new CB2eCore;
          122  +
          123  +   //-- ������
          124  +   m_Result=0;
          125  +   rvm->setPtr( this,mLod );
          126  +
          127  +   //-- ���s
          128  +   rvm->eval( m_LoadScr );
          129  +
          130  +   //-- ����
          131  +   if( m_Result==0 )
          132  +    return (m_DecScr?aMelt|(m_DcEScr?aList|aMeltEach:0)|(chk?aCheck:0):0)
          133  +      | (m_EncScr?aCompress|(pack1?0:aArchive)|(m_SfxScr?aSfx:0):0);
          134  +  }
          135  + }
          136  + return 0;
          137  +}
          138  +
          139  +int CArcB2e::exec_script( const char* scr, scr_mode mode )
          140  +{
          141  + //-- ������
          142  + m_Result = 0;
          143  + rvm->setPtr( this, mode );
          144  +
          145  + //-- ���s
          146  + char* script = new char[ki_strlen(scr)+8];
          147  + ki_strcpy( script, "(exec " );
          148  + ki_strcat( script, scr );
          149  + ki_strcat( script, ")" );
          150  + rvm->eval( script );
          151  + delete [] script;
          152  +
          153  + //-- ����
          154  + return m_Result;
          155  +}
          156  +
          157  +//-------------------- ���X�g�A�b�v eval( list: ) -----------------------
          158  +
          159  +bool CArcB2e::v_list( const arcname& aname, aflArray& files )
          160  +{
          161  + //-- �X�N���v�g�����ʼn��Ƃ��ł���Ȃ炷��B
          162  + if( !exe )
          163  +  return false;
          164  + else if( exe->isdll() )
          165  +  return exe->lst_dll( aname, files );
          166  + else if( !m_LstScr )
          167  +  return false;
          168  +
          169  +//-- ���X�e�B���O�X�N���v�g�ɕK�v�ȃf�[�^
          170  +
          171  + // ���ɖ�
          172  + m_psArc = &aname;
          173  + // �t�@�C�����X�g
          174  + m_psAInfo = &files;
          175  +
          176  +//-- ���s�I ---------------------
          177  +
          178  + return 0==exec_script( m_LstScr, mLst );
          179  +}
          180  +
          181  +//-------------------- �W�J���� eval( decode: ) -----------------------
          182  +
          183  +int CArcB2e::v_melt( const arcname& aname, const kiPath& ddir, const aflArray* files )
          184  +{
          185  +//-- �𓀃X�N���v�g�ɕK�v�ȃf�[�^
          186  +
          187  + // �J�����g
          188  + ::SetCurrentDirectory( ddir );
          189  + // ���ɖ�
          190  + m_psArc = &aname;
          191  + // �o�͐�f�B���N�g��
          192  + m_psDir = &ddir;
          193  + // �t�@�C�����X�g
          194  + m_psAInfo = files;
          195  +
          196  +//-- ���s�I ---------------------
          197  +
          198  + return exec_script( files ? m_DcEScr : m_DecScr,
          199  +      files ? mDc1     : mDec );
          200  +}
          201  +
          202  +//-------------------- ���k���� eval( encode: sfx: ) -----------------------
          203  +
          204  +int CArcB2e::cmpr( const char* scr, const kiPath& base, const wfdArray& files, const kiPath& ddir, const int method )
          205  +{
          206  +//-- ���k�X�N���v�g�ɕK�v�ȃf�[�^
          207  +
          208  + arcname aname(
          209  +  ddir,
          210  +  files[0].cAlternateFileName,
          211  +  files[0].cFileName );
          212  + int mhd=method+1;
          213  +
          214  + // �J�����g
          215  + ::SetCurrentDirectory( base );
          216  + // ���ɖ�
          217  + m_psArc = &aname;
          218  + // �x�[�X�f�B���N�g��
          219  + m_psDir = &base;
          220  + // ���\�b�h
          221  + m_psMhd = &mhd;
          222  + // ���X�g
          223  + m_psList = &files;
          224  +
          225  +//-- ���s�I --------------------
          226  +
          227  + return exec_script( scr, mEnc );
          228  +}
          229  +
          230  +bool CArcB2e::arc2sfx( const kiPath& temp, const kiPath& dest )
          231  +{
          232  +//-- SFX�ϊ��X�N���v�g�ɕK�v�ȃf�[�^
          233  +
          234  + kiFindFile f;
          235  + WIN32_FIND_DATA fd;
          236  + kiPath wild( temp );
          237  + f.begin( wild += "*" );
          238  + if( !f.next( &fd ) )
          239  +  return false;
          240  + kiPath from, to, oldname( fd.cFileName );
          241  + arcname aname( temp, fd.cAlternateFileName[0] ? fd.cAlternateFileName : fd.cFileName, fd.cFileName );
          242  +
          243  + // �J�����g
          244  + ::SetCurrentDirectory( temp );
          245  + // ���ɖ�
          246  + m_psArc = &aname;
          247  + // �f�B���N�g��
          248  + m_psDir = &temp;
          249  +
          250  +//-- ���s�I ----------------------
          251  +
          252  + if( 0x8000<=exec_script( m_SfxScr, mSfx ) )
          253  +  return false;
          254  +
          255  +//-- �R�s�[ ----------------------
          256  +
          257  + bool skipped=false, ans=false;
          258  + f.begin( wild );
          259  + while( f.next( &fd ) )
          260  + {
          261  +  if( !skipped && oldname == fd.cFileName ) // �e���|�������ɂ̓R�s�[���Ȃ��B
          262  +  {
          263  +   skipped=true;
          264  +   continue;
          265  +  }
          266  +  from = temp, from += fd.cFileName;
          267  +  to   = dest, to   += fd.cFileName;
          268  +  if( ::CopyFile( from, to, FALSE ) )
          269  +   ans = true;
          270  + }
          271  + return ans;
          272  +}
          273  +
          274  +int CArcB2e::v_compress( const kiPath& base, const wfdArray& files, const kiPath& ddir, int method, bool sfx )
          275  +{
          276  + const char* theScript = m_EncScr;
          277  +
          278  + if( sfx )
          279  + {
          280  +  if( m_SfxDirect )
          281  +   theScript = m_SfxScr;
          282  +  else
          283  +  {
          284  +   kiPath tmp;
          285  +   myapp().get_tempdir( tmp );
          286  +
          287  +   // �e���|�����ֈ��k
          288  +   int ans = cmpr( m_EncScr, base, files, tmp, method );
          289  +   if( ans < 0x8000 )
          290  +    // �e���|�����ɗ����Ă�t�@�C����SFX�ɕϊ����R�s�[�I
          291  +    ans = (arc2sfx( tmp, ddir ) ? 0 : 0x8020);
          292  +
          293  +   // �J�����g��߂��Ă����Ȃ��ƍ폜�ł��Ȃ��c(;_;)
          294  +   ::SetCurrentDirectory( base );
          295  +   tmp.remove();
          296  +   return ans;
          297  +  }
          298  + }
          299  +
          300  + // �o�͐�֕��ʂɈ��k
          301  + return cmpr( theScript, base, files, ddir, method );
          302  +}
          303  +
          304  +//-----------------------------------------------------------------//
          305  +//-------------------- RythpVM�̕��̎��� --------------------------//
          306  +//-----------------------------------------------------------------//
          307  +
          308  +bool CArcB2e::CB2eCore::exec_function( const kiVar& name, const CharArray& a, const BoolArray& b, int c, kiVar* r )
          309  +{
          310  + bool processed = false;
          311  +
          312  + if( m_mode==mLod ){ //**���[�h����pfunctions****************************
          313  +  if( name=="name" ){
          314  +   processed=true;
          315  +
          316  +   //---------------------------//
          317  +   //-- (name module_filename)--//
          318  +   //---------------------------//
          319  +   if( c>=2 )
          320  +   {
          321  +    x->m_usMode = false;
          322  +    if( c>=3 )
          323  +    {
          324  +     getarg( a[2],b[2],&t );
          325  +     x->m_usMode = ( t=="us" );
          326  +    }
          327  +
          328  +    getarg( a[1],b[1],&t );
          329  +    if( x->load_module(t) )
          330  +     *r = "exec";
          331  +    else
          332  +     *r = "", x->m_Result=0xffff;
          333  +   }
          334  +
          335  +  }else if( name=="type" ){
          336  +   processed=true;
          337  +
          338  +   //-----------------------------------//
          339  +   //-- (type ext method1 method2 ...)--//
          340  +   //-----------------------------------//
          341  +   for( int i=1; i<c; i++ )
          342  +   {
          343  +    getarg( a[i],b[i],&t );
          344  +    if( i==1 )
          345  +     x->set_cmp_ext( t );
          346  +    else
          347  +    {
          348  +     const char* ptr=t;
          349  +     x->add_cmp_mhd( *ptr=='*' ? ptr+1 : ptr, *ptr=='*' );
          350  +    }
          351  +   }
          352  +  }else if( name=="use" ){
          353  +   processed=true;
          354  +
          355  +   //-------------------------------//
          356  +   //-- (use module1 module2 ...) --//
          357  +   //-------------------------------//
          358  +   for( int i=1; i<c; i++ )
          359  +   {
          360  +    getarg( a[i],b[i],&t );
          361  +    x->m_subFile.add( t );
          362  +   }
          363  +  }
          364  + }else{//************ ���[�h���ɂ͎g���Ȃ�functions *********************
          365  +  if( ki_memcmp( (const char*)name, "arc", 3 ) ){
          366  +   processed=true;
          367  +
          368  +   //---------------------------//
          369  +   //-- (arc[+-].xxx [slfrd]) --//
          370  +   //---------------------------//
          371  +   arc( ((const char*)name)+3, a, b, c, r );
          372  +
          373  +  }else if( ki_memcmp( (const char*)name, "list", 4 ) ){
          374  +   processed=true;
          375  +
          376  +   //----------------------------//
          377  +   //-- (list[\*|\*.*] [slfn]) --//
          378  +   //----------------------------//
          379  +   list( ((const char*)name)+4, a, b, c, r );
          380  +
          381  +  }else if( name=="method" ){
          382  +   processed=true;
          383  +
          384  +   //-------------------//
          385  +   //-- (method [no]) --//
          386  +   //-------------------//
          387  +   if( c>=2 )
          388  +   {
          389  +    getarg( a[1],b[1],&t );
          390  +    *r = t.getInt()==*x->m_psMhd ? "1" : "0";
          391  +   }
          392  +   else
          393  +    r->setInt( *x->m_psMhd );
          394  +
          395  +  }else if( name=="dir" ){
          396  +   processed=true;
          397  +
          398  +   //-----------//
          399  +   //-- (dir) --//
          400  +   //-----------//
          401  +   *r = (x->m_psDir ? *x->m_psDir : (const char*)"");
          402  +
          403  +  }else if( name=="del" ){
          404  +   processed=true;
          405  +
          406  +   //-------------------//
          407  +   //-- (del filenam) --//
          408  +   //-------------------//
          409  +   if( c>=2 )
          410  +   {
          411  +    getarg( a[1],b[1],&t );
          412  +    ::DeleteFile( kiPath( t.unquote() ) );
          413  +   }
          414  +
          415  +  }else if( ki_memcmp( (const char*)name, "resp", 4 )
          416  +   ||   ki_memcmp( (const char*)name, "resq", 4 ) ){
          417  +   processed=true;
          418  +
          419  +   //----------------------------//
          420  +   //-- (resp[@|-o] (list a)) ---//
          421  +   //----------------------------//
          422  +   resp( name[3]=='p', ((const char*)name)+4, a, b, c, r );
          423  +
          424  +  }else if( name=="cd" ){
          425  +   processed=true;
          426  +
          427  +   //-------------------//
          428  +   //-- (cd directory)--//
          429  +   //-------------------//
          430  +   if( c>=2 )
          431  +   {
          432  +    getarg( a[1],b[1],&t );
          433  +    ::SetCurrentDirectory( t.unquote() );
          434  +   }
          435  +
          436  +  }else if( name=="cmd" || name=="xcmd" ){
          437  +   processed=true;
          438  +
          439  +   //----------------------------//
          440  +   //-- (cmd command line ...)---//
          441  +   //-- (xcmd command line ...)--//
          442  +   //----------------------------//
          443  +   if( name[0]=='x' && c<2 )
          444  +    x->m_Result = 0xffff;
          445  +   else
          446  +   {
          447  +    CArcModule* xxx = x->exe;
          448  +    kiVar       cmd;
          449  +    int         i=1;
          450  +
          451  +    if( name[0] == 'x' )
          452  +    {
          453  +     kiVar mm;
          454  +     getarg( a[i],b[i],&mm );
          455  +     i++;
          456  +     xxx = new CArcModule( mm, x->m_usMode );
          457  +    }
          458  +    for( ; i<c; i++ )
          459  +     getarg( a[i],b[i],&t ), cmd+=t, cmd+=' ';
          460  +
          461  +    bool m = (mycnf().miniboot() || m_mode==mDc1);
          462  +    x->m_Result = xxx->cmd( cmd, m );
          463  +    r->setInt( x->m_Result );
          464  +
          465  +    if( name[0] == 'x' )
          466  +     delete xxx;
          467  +   }
          468  +  }else if( name=="scan" || name=="xscan" ){
          469  +   processed=true;
          470  +
          471  +   //----------------------------------------//
          472  +   //-- (scan BL BSL EL SL dx cmd...) -------//
          473  +   //-- (xscan BL BSL EL SL dx CMD cmd...) --//
          474  +   //----------------------------------------//
          475  +   if( c<6 || (name[0]=='x'&&c<7) )
          476  +    x->m_Result = 0xffff;
          477  +   else
          478  +   {
          479  +    CArcModule* xxx = x->exe;
          480  +
          481  +    kiVar BL, EL;
          482  +    getarg( a[1],b[1],&BL );
          483  +    getarg( a[2],b[2],&t );
          484  +    int BSL = t.getInt();
          485  +    getarg( a[3],b[3],&EL );
          486  +    getarg( a[4],b[4],&t );
          487  +    int SL = t.getInt();
          488  +    getarg( a[5],b[5],&t );
          489  +    int dx = t.getInt();
          490  +
          491  +    int i=6;
          492  +    if( name[0] == 'x' )
          493  +    {
          494  +     kiVar mm;
          495  +     getarg( a[i],b[i],&mm );
          496  +     i++;
          497  +     xxx = new CArcModule( mm, x->m_usMode );
          498  +    }
          499  +
          500  +    kiVar cmd;
          501  +    for( ; i<c; ++i )
          502  +     getarg( a[i],b[i],&t ), cmd+=t, cmd+=' ';
          503  +
          504  +    x->m_Result = xxx->lst_exe(
          505  +     cmd, *const_cast<aflArray*>(x->m_psAInfo),
          506  +     BL, BSL, EL, SL, dx ) ? 0 : -1;
          507  +
          508  +    if( name[0] == 'x' )
          509  +     delete xxx;
          510  +   }
          511  +  }else if( name=="input" ){
          512  +   processed=true;
          513  +
          514  +   //-------------------------//
          515  +   //-- (input MSG DEFUALT) --//
          516  +   //-------------------------//
          517  +   kiVar msg, defval;
          518  +   if( c>=2 )
          519  +    getarg( a[1],b[1],&msg );
          520  +   if( c>=3 )
          521  +    getarg( a[2],b[2],&defval );
          522  +   input( msg, defval, r );
          523  +  }else if( name=="size" ){
          524  +   processed=true;
          525  +
          526  +   //---------------------//
          527  +   //-- (size FILENAME) --//
          528  +   //---------------------//
          529  +   if( c>=2 )
          530  +   {
          531  +    kiVar fnm;
          532  +    getarg( a[1],b[1],&fnm );
          533  +    r->setInt( kiFile::getSize( fnm.unquote() ) );
          534  +   }
          535  +  }else if( name=="is_file" ){
          536  +   processed=true;
          537  +
          538  +   //---------------------//
          539  +   //-- (is_file) --------//
          540  +   //---------------------//
          541  +   if( c==1 )
          542  +    *r = (x->m_psList->len()==1
          543  +       && !kiSUtil::isdir( (*x->m_psList)[0].cFileName )) ? "1" : "0";
          544  +  }else if( name=="is_folder" ){
          545  +   processed=true;
          546  +
          547  +   //---------------------//
          548  +   //-- (is_folder) ------//
          549  +   //---------------------//
          550  +   if( c==1 )
          551  +    *r = (x->m_psList->len()==1
          552  +       && kiSUtil::isdir( (*x->m_psList)[0].cFileName )) ? "1" : "0";
          553  +  }else if( name=="is_multiple" ){
          554  +   processed=true;
          555  +
          556  +   //---------------------//
          557  +   //-- (is_multiple) ----//
          558  +   //---------------------//
          559  +   if( c==1 )
          560  +    *r = x->m_psList->len()>1 ? "1" : "0";
          561  +  }else if( name=="find" ){
          562  +   processed=true;
          563  +
          564  +   //---------------------//
          565  +   //-- (find FILENAME) --//
          566  +   //---------------------//
          567  +   if( c>=2 )
          568  +   {
          569  +    kiVar fnm;
          570  +    getarg( a[1],b[1],&fnm );
          571  +    char buf[MAX_PATH];
          572  +    if( 0==::SearchPath( NULL,fnm.unquote(),NULL,MAX_PATH,buf,NULL ) )
          573  +     *r = "";
          574  +    else
          575  +     *r = buf, r->quote();
          576  +   }
          577  +  }
          578  + }
          579  +
          580  + return processed ? true : kiRythpVM::exec_function(name,a,b,c,r);
          581  +}
          582  +
          583  +void CArcB2e::CB2eCore::arc( const char* opt, const CharArray& a, const BoolArray& b,int c, kiVar* r )
          584  +{
          585  + //---------------------------//
          586  + //-- (arc[+-].xxx [slfrd]) --//
          587  + //---------------------------//
          588  +
          589  + // �f�t�H���g�I�v�V�����ݒ�
          590  + const char* anm=x->m_psArc->lname;
          591  + enum{ full, nam, dir } part=full;
          592  + if( m_mode==mSfx ) part=nam; // sfx
          593  +
          594  + // �w�肪����Ώ㏑
          595  + if( c>=2 )
          596  + {
          597  +  getarg( a[1],b[1],&t );
          598  +  for( const char* p=t; *p; p++ )
          599  +   switch(*p)
          600  +   {
          601  +   case 's': anm=x->m_psArc->sname; break;
          602  +   case 'l': anm=x->m_psArc->lname; break;
          603  +   case 'f': part=full; break;
          604  +   case 'n': part=nam;  break;
          605  +   case 'd': part=dir;  break;
          606  +   }
          607  + }
          608  +
          609  + // �f�B���N�g������
          610  + *r = (part==nam ? (const char*)"" : x->m_psArc->basedir);
          611  +
          612  + // ���O����
          613  + if( part != dir )
          614  + {
          615  +  if( *opt=='\0' || *opt=='+' )
          616  +  {
          617  +   // (arc)       : anm�����̂܂ܕԂ�
          618  +   *r += anm;
          619  +   // (arc+XXX)   : anmXXX��Ԃ�
          620  +   if( *opt=='+' )
          621  +    *r += (opt+1);
          622  +  }
          623  +  else
          624  +  {
          625  +   const char* ext = kiPath::ext(anm);
          626  +   const char* add = "";
          627  +   if( opt[0]=='-' && opt[1]=='.' )
          628  +   {
          629  +    // (arc-.XXX) : ������.XXX��������폜�B
          630  +    //            : �����łȂ���Ό���.decompressed
          631  +    if( 0!=ki_strcmpi( ext, opt+2 ) )
          632  +     ext = anm + ki_strlen(anm), add = ".decompressed";
          633  +   }
          634  +   else if( opt[1]!='\0' )
          635  +   {
          636  +    // (arc.XXX)  : �Ō�̊g���q��.XXX�Ɏ��ւ�
          637  +    add = opt;
          638  +    switch(mycnf().extnum())
          639  +    {
          640  +    case 0: ext = anm + ::lstrlen(anm);break;
          641  +    case 1: ext = kiPath::ext(anm);    break;
          642  +    default:ext = kiPath::ext_all(anm);break;
          643  +    }
          644  +   }
          645  +   else
          646  +   {
          647  +    // (arc.)     : �g���q��S�Ď�菜��
          648  +    switch(mycnf().extnum())
          649  +    {
          650  +    case 0: ext = anm + ::lstrlen(anm);break;
          651  +    case 1: ext = kiPath::ext(anm);    break;
          652  +    default:ext = kiPath::ext_all(anm);break;
          653  +    }
          654  +   }
          655  +   if( *ext )
          656  +    ext--;
          657  +
          658  +   char buf[MAX_PATH];
          659  +   ki_memcpy( buf, anm, ext-anm );
          660  +   buf[ ext-anm ] = '\0';
          661  +   *r += buf;
          662  +   *r += add;
          663  +  }
          664  +
          665  +  // �K�v�Ȃ炭����
          666  +  if( part==full )
          667  +   r->quote();
          668  + }
          669  +}
          670  +
          671  +static void selfR(
          672  + const char* writedir, const char* fullpath, bool lfn, kiVar* r )
          673  +{
          674  + kiFindFile       f;
          675  + WIN32_FIND_DATA fd;
          676  + f.begin( kiStr(fullpath) += "\\*" );
          677  +
          678  + kiVar t, t2, t3;
          679  + while( f.next(&fd) )
          680  + {
          681  +  t = writedir;
          682  +  t+= '\\';
          683  +  t+= (lfn ? fd.cFileName : fd.cAlternateFileName);
          684  +  if( fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
          685  +  {
          686  +   t2 = t;
          687  +   t  = "";
          688  +   t3 = fullpath;
          689  +   t3+= '\\';
          690  +   t3+= (lfn ? fd.cFileName : fd.cAlternateFileName);
          691  +   selfR( t2, t3, lfn, &t );
          692  +  }
          693  +  else
          694  +  {
          695  +   if( lfn )
          696  +    t.quote();
          697  +  }
          698  +  *r += t;
          699  +  *r += ' ';
          700  + }
          701  +}
          702  +
          703  +void CArcB2e::CB2eCore::list( const char* opt, const CharArray& a, const BoolArray& b,int c, kiVar* r )
          704  +{
          705  + //---------------------------//
          706  + //-- (list[r|\*.*] [slfn]) --//
          707  + //---------------------------//
          708  +
          709  + if( m_mode!=mEnc ) // �𓀂̏ꍇ
          710  + {
          711  +  *r = "";
          712  +
          713  +  for( unsigned int i=0; i!=x->m_psAInfo->len(); i++ )
          714  +   if( (*x->m_psAInfo)[i].selected )
          715  +   {
          716  +    // - �Ŏn�܂郄�c�΍�����邩�H
          717  +    t = (*x->m_psAInfo)[i].inf.szFileName;
          718  +    t.quote();
          719  +    *r += t;
          720  +    *r += ' ';
          721  +   }
          722  + }
          723  + else // ���k�̏ꍇ
          724  + {
          725  +  // �f�t�H���g�I�v�V�����ݒ�
          726  +  bool lfn=true;
          727  +  enum{ full, nam } part=nam;
          728  +  // �w�肪����Ώ㏑
          729  +  if( c>=2 )
          730  +  {
          731  +   getarg( a[1],b[1],&t );
          732  +   for( const char* p=t; *p; p++ )
          733  +    switch(*p)
          734  +    {
          735  +    case 's': lfn=false; break;
          736  +    case 'l': lfn=true;  break;
          737  +    case 'f': part=full; break;
          738  +    case 'n': part=nam;  break;
          739  +    }
          740  +  }
          741  +  // ���O�ōċA���X�g�A�b�v���s�����ۂ�
          742  +  bool selfrecurse = (*opt=='r');
          743  +
          744  +  // �f�B���N�g�����̌��ɕt���������́B
          745  +  if( *opt=='\\' || *opt=='/' )
          746  +   opt++;
          747  +
          748  +  // ���X�g�A�b�v
          749  +  kiVar t2,t3;
          750  +  *r = "";
          751  +  for( unsigned int i=0; i!=x->m_psList->len(); i++ )
          752  +  {
          753  +   // �t�@�C��������
          754  +   t = ( part==full ? *x->m_psDir : (const char*)"");
          755  +   t += lfn ? (*x->m_psList)[i].cFileName : (*x->m_psList)[i].cAlternateFileName;
          756  +
          757  +   if( selfrecurse && ((*x->m_psList)[i].dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) )
          758  +   {
          759  +    // �Z���t�ċA
          760  +    t2 = t;
          761  +    t  = "";
          762  +    t3 = *x->m_psDir;
          763  +    t3+= lfn ? (*x->m_psList)[i].cFileName : (*x->m_psList)[i].cAlternateFileName;
          764  +    selfR( t2, t3, lfn, &t );
          765  +   }
          766  +   else
          767  +   {
          768  +    // �m�[�}������
          769  +    if( *opt && ((*x->m_psList)[i].dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) )
          770  +     t += '\\', t += opt;
          771  +    if( lfn )
          772  +     t.quote();
          773  +   }
          774  +   *r += t;
          775  +   *r += ' ';
          776  +  }
          777  + }
          778  +
          779  + r->removeTrailWS();
          780  +}
          781  +
          782  +void CArcB2e::CB2eCore::resp( bool needq, const char* opt, const CharArray& a, const BoolArray& b,int c, kiVar* r )
          783  +{
          784  + //-----------------------------//
          785  + //-- (resp[@|-o] (list) ...) --//
          786  + //-----------------------------//
          787  +
          788  + // ���X�|���X�t�@�C�����쐬
          789  + kiPath rspfile;
          790  + myapp().get_tempdir(rspfile);
          791  + rspfile += "filelist";
          792  +
          793  + // �I�v�V�����ƌ������ĕԂ�
          794  + *r  = opt;
          795  + *r += rspfile;
          796  +
          797  + // �t�@�C���֏�������
          798  + kiFile fp;
          799  + if( !fp.open( rspfile,false ) )
          800  +  return;
          801  +
          802  + kiVar tmp;
          803  + for( int i=1; i<c; i++ )
          804  + {
          805  +  // fp�֊e������split���Ȃ��珑������
          806  +  getarg( a[i],b[i],&tmp );
          807  +
          808  +  for( const char *s,*p=tmp; *p; p++ )
          809  +  {
          810  +   // �]���ȋ󔒂̓X�L�b�v
          811  +   while( *p==' ' )
          812  +    p++;
          813  +   if( *p=='\0' )
          814  +    break;
          815  +
          816  +   // �����̏I���ցc
          817  +   s=p;
          818  +   for( int q=0; *p!='\0' && (*p!=' ' || (q&1)!=0); p++ )
          819  +    if( *p=='"' )
          820  +     q++;
          821  +
          822  +   // "�̂‚��‚܍��킹�ꍆ
          823  +   if( !needq && *s=='"' )
          824  +   {
          825  +    s++;
          826  +    if( p!=s && *(p-1)=='"' )
          827  +     p--;
          828  +   }
          829  +
          830  +   fp.write( s, p-s );
          831  +   fp.write( "\r\n", 2 );
          832  +
          833  +   // "�̂‚��‚܍��킹��
          834  +   if( *p=='"' )
          835  +    p++;
          836  +   if( *p=='\0' )
          837  +    break;
          838  +  }
          839  + }
          840  +}
          841  +
          842  +void CArcB2e::CB2eCore::input( const char* msg, const char* defval, kiVar* r )
          843  +{
          844  + struct CB2eInputDlg : public kiDialog
          845  + {
          846  +  const char* msg;
          847  +  const char* def;
          848  +  kiVar*      res;
          849  +
          850  +  CB2eInputDlg( const char* m, const char* d, kiVar* r )
          851  +   : kiDialog( IDD_PASSWORD ), msg(m), def(d), res(r) {}
          852  +  BOOL onInit()
          853  +   {
          854  +    sendMsgToItem( IDC_EDIT, WM_SETTEXT, 0, (LPARAM)def );
          855  +    sendMsgToItem( IDC_MESSAGE, WM_SETTEXT, 0, (LPARAM)msg );
          856  +    ::ShowWindow( item(IDC_MASK), SW_HIDE );
          857  +    ::ShowWindow( item(IDCANCEL), SW_HIDE );
          858  +    ::EnableWindow( item(IDC_MASK), FALSE );
          859  +    ::EnableWindow( item(IDCANCEL), FALSE );
          860  +    ::SetFocus( item(IDC_EDIT) );
          861  +    return TRUE;
          862  +   }
          863  +  bool onOK()
          864  +   {
          865  +    char* buf = new char[32768];
          866  +    sendMsgToItem( IDC_EDIT, WM_GETTEXT, 32768, (LPARAM)buf );
          867  +    *res = buf;
          868  +    delete [] buf;
          869  +    return true;
          870  +   }
          871  + };
          872  +
          873  + CB2eInputDlg d( msg, defval, r );
          874  + d.doModal( app()->mainhwnd() );
          875  +}
          876  +

Added ArcB2e.h version [f42371bc1f59bea6]

            1  +#ifndef AFX_ARCB2e_H__697CC1BD_2C28_434C_8C53_239D624227C3__INCLUDED_
            2  +#define AFX_ARCB2e_H__697CC1BD_2C28_434C_8C53_239D624227C3__INCLUDED_
            3  +
            4  +#include "Archiver.h"
            5  +
            6  +class CArcB2e : public CArchiver
            7  +{
            8  +public: //--<action>--
            9  +
           10  + CArcB2e( const char* scriptname );
           11  + virtual ~CArcB2e();
           12  + static const char* init_b2e_path();
           13  +
           14  +private: //--<CArchiver>--
           15  +
           16  + int  v_load();
           17  + bool v_ver( kiStr& str );
           18  + bool v_check( const kiPath& aname );
           19  + int  v_contents( const kiPath& aname, kiPath& dname );
           20  + int  v_melt( const arcname& aname, const kiPath& ddir, const aflArray* files );
           21  + bool v_list( const arcname& aname, aflArray& files );
           22  + int  v_compress( const kiPath& base, const wfdArray& files, const kiPath& ddir, int method, bool sfx );
           23  + kiStr v_name(const char*) const { return exe ? exe->name() : kiStr(""); }
           24  +
           25  + bool arc2sfx( const kiPath& temp, const kiPath& dest );
           26  + int  cmpr( const char* scr, const kiPath& base, const wfdArray& files, const kiPath& ddir, const int method );
           27  +
           28  +private: //--<RythpScript>--
           29  +
           30  + // scripts
           31  + char*       m_ScriptBuf;
           32  + char*       m_LoadScr;
           33  + const char* m_EncScr;
           34  + const char* m_DecScr;
           35  + const char* m_SfxScr;
           36  + const char* m_DcEScr;
           37  + const char* m_LstScr;
           38  + bool        m_SfxDirect;
           39  +
           40  + enum scr_mode { mLod, mEnc, mDec, mDc1, mSfx, mLst };
           41  + int exec_script( const char* scr, scr_mode mode );
           42  +
           43  + // B2e Core
           44  + class CB2eCore : public kiRythpVM
           45  + {
           46  +  friend class CArcB2e;
           47  +
           48  +  bool exec_function( const kiVar& name, const CharArray& a, const BoolArray& b,int c, kiVar* r );
           49  +
           50  +  void arc( const char* opt, const CharArray& a, const BoolArray& b,int c, kiVar* r );
           51  +  void list( const char* opt, const CharArray& a, const BoolArray& b,int c, kiVar* r );
           52  +  void resp( bool needq, const char* opt, const CharArray& a, const BoolArray& b,int c, kiVar* r );
           53  +  void input( const char* msg, const char* defval, kiVar* r );
           54  +
           55  +  void setPtr( CArcB2e* p, scr_mode m ){x=p;m_mode=m;}
           56  +  CArcB2e* x;
           57  +  scr_mode m_mode;
           58  +  kiVar t;
           59  + };
           60  + friend class CB2eCore;
           61  + static char st_base[MAX_PATH];
           62  + static int  st_life;
           63  + static CB2eCore* rvm;
           64  +
           65  + // module
           66  + CArcModule* exe;
           67  + kiArray<kiStr> m_subFile;
           68  +
           69  + // script�A�g
           70  + bool load_module( const char* name );
           71  + int m_Result;
           72  + bool m_usMode;
           73  + const arcname*  m_psArc;
           74  + const kiPath*   m_psDir;
           75  + const int*      m_psMhd;
           76  + const wfdArray* m_psList;
           77  + const aflArray* m_psAInfo;
           78  +};
           79  +
           80  +#endif

Added ArcCpt.cpp version [de96d041f43cbd6f]

            1  +
            2  +#include "stdafx.h"
            3  +#include "ArcCpt.h"
            4  +#include "NoahApp.h"
            5  +
            6  +//--- CArchiver --------------------------------------------------
            7  +
            8  +bool CArcCpt::v_check( const kiPath& aname )
            9  +{
           10  + bool ans = ( cpt.open( aname ) && read_main_hdr() && check_index_crc() );
           11  + cpt.close();
           12  + return ans;
           13  +}
           14  +
           15  +bool CArcCpt::v_list( const arcname& aname, aflArray& files )
           16  +{
           17  + ::SetCurrentDirectory( aname.basedir );
           18  +
           19  + bool ans = ( cpt.open( aname.lname ) && read_main_hdr() && operation_for_each( true, &files ) );
           20  + cpt.close();
           21  + return ans;
           22  +}
           23  +
           24  +int CArcCpt::v_melt( const arcname& aname, const kiPath& ddir, const aflArray* files )
           25  +{
           26  + ::SetCurrentDirectory( aname.basedir );
           27  + if( !cpt.open( aname.lname ) )
           28  +  return 0xffff;
           29  +
           30  + ::SetCurrentDirectory( ddir );
           31  + bool ans = ( read_main_hdr() && operation_for_each( false, const_cast<aflArray*>(files) ) );
           32  + cpt.close();
           33  + return ans ? 0 : 0x8020;
           34  +}
           35  +
           36  +int CArcCpt::v_contents( const kiPath& aname, kiPath& dname )
           37  +{
           38  + int ans=aUnknown;
           39  + if( cpt.open( aname ) && read_main_hdr() )
           40  + {
           41  +  if( cpt.read( tmp, 7 ) )
           42  +  {
           43  +   WORD EntryNum = (tmp[4]<<8)  + tmp[5];
           44  +   if( EntryNum == 1 )
           45  +    ans = aSingleFile;
           46  +   else
           47  +   {
           48  +    cpt.read( tmp, tmp[6] );
           49  +    tmp[0] = cpt.getc();
           50  +    if( tmp[0] & 0x80 ) // Folder
           51  +    {
           52  +     unsigned long size = (tmp[0]&0x3f) + 2;
           53  +     if( size == cpt.read( tmp+1, size ) )
           54  +      if( EntryNum == 1 + (tmp[size-1]<<8) + tmp[size] )
           55  +      {
           56  +       dname = "";
           57  +       tmp[ 1+tmp[0] ] = '\0';
           58  +       for( char* pp=(char*)tmp+1; *pp; pp=kiStr::next(pp) )
           59  +       {
           60  +        if( kiStr::isLeadByte(*pp) )
           61  +         dname += *pp, dname += *(pp+1);
           62  +        else if( *pp<' ' || *pp>'~' )
           63  +         dname += '_';
           64  +        else switch( *pp )
           65  +        {
           66  +         case '\\': case '/': case ':': case '*':
           67  +         case '?': case '\"': case '<': case '>': case '|':
           68  +          dname += '_';
           69  +         default:
           70  +          dname += *pp;
           71  +        }
           72  +       }
           73  +
           74  +       ans = aSingleDir;
           75  +      }
           76  +    }
           77  +   }
           78  +  }
           79  + }
           80  + cpt.close();
           81  + return ans;
           82  +}
           83  +
           84  +//--- CRC ----------------------------------------------------------
           85  +
           86  +static unsigned long crctbl[256] = { 1 };
           87  +
           88  +static void init_crc_table()
           89  +{
           90  + if( crctbl[0]==1 ) // uninitialized
           91  +  for( unsigned long c,n=0; n!=256; n++ )
           92  +  {
           93  +   c = n;
           94  +   for( unsigned long k=8; k; k-- )
           95  +    c = (c&1) ? ((0xedb88320L)^(c>>1)) : (c>>1);
           96  +   crctbl[n] = c;
           97  +  }
           98  +}
           99  +
          100  +static unsigned long crc( unsigned long c, unsigned char* cp,int cnt )
          101  +{
          102  + while( cnt-- )
          103  +  c = (c>>8)^crctbl[(c&0xff)^*cp++];
          104  + return c;
          105  +}
          106  +
          107  +//--- cpt ----------------------------------------------------------
          108  +
          109  +bool CArcCpt::read_main_hdr()
          110  +{
          111  + //-- �擪�̃o�C�g�� MagicNumber : 0x01 �Ȃ͂��B
          112  + m_nMacBinOffset = 0;
          113  + if( 8 != cpt.read( tmp, 8 ) )
          114  +  return false;
          115  + if( tmp[0] != 1 )
          116  + {
          117  +  if(  0  != tmp[0]
          118  +   || 120 != cpt.read( tmp, 120 )
          119  +   ||  8  != cpt.read( tmp,  8  )
          120  +   || tmp[0] != 1 ) // MacBin�X�L�b�v
          121  +   return false;
          122  +  m_nMacBinOffset = 128;
          123  + }
          124  +
          125  + //-- index�܂Œ���
          126  + cpt.seek( (tmp[4]<<24) + (tmp[5]<<16) + (tmp[6]<<8) + (tmp[7]) - 8 );
          127  + return true;
          128  +}
          129  +
          130  +bool CArcCpt::check_index_crc()
          131  +{
          132  + bool folder;
          133  + unsigned int size;
          134  +
          135  + //-- CRC(DWORD), EntryNum(WORD), CommentLen(BYTE)
          136  + if( !cpt.read( tmp, 7 ) )
          137  +  return false;
          138  +
          139  + init_crc_table();
          140  +
          141  + DWORD     CRC = (tmp[0]<<24) + (tmp[1]<<16) + (tmp[2]<<8) + tmp[3];
          142  + WORD EntryNum = (tmp[4]<<8)  + tmp[5];
          143  + if( tmp[6] != cpt.read( tmp+7, tmp[6] ) )
          144  +  return false;
          145  + DWORD chk_crc = crc( 0xffffffff, tmp+4, 3+tmp[6] );
          146  +
          147  + //-- �S�w�b�_�𑖍�����CRC�v�Z
          148  + for( WORD i=0; i!=EntryNum; i++ )
          149  + {
          150  +  tmp[0] = cpt.getc();
          151  +
          152  +  if( tmp[0] & 0x80 ) folder = true,  size = (tmp[0]&0x3f) + 2;
          153  +  else    folder = false, size = (tmp[0]) + 45;
          154  +  if( size != cpt.read( tmp+1, size ) ) return false;
          155  +
          156  +  chk_crc = crc( chk_crc, tmp, 1+size );
          157  +    }
          158  +
          159  + return CRC == chk_crc;
          160  +}
          161  +
          162  +bool CArcCpt::operation_for_each( bool o_list, aflArray* files )
          163  +{
          164  + //-- Entry���𓾂�
          165  + if( !cpt.read( tmp, 7 ) )
          166  +  return false;
          167  + WORD EntryNum = (tmp[4]<<8)  + tmp[5];
          168  + cpt.read( tmp, tmp[6] );
          169  +
          170  + //-- �_�C�A���O����
          171  + pdlg = files ? NULL : new CArcProgressDlg( EntryNum );
          172  +
          173  + //-- ����
          174  + kiPath path;
          175  + m_nIndexPos = cpt.tell();
          176  + bool ans = recurse( o_list, files, path, 0, EntryNum );
          177  + delete pdlg;
          178  + return ans;
          179  +}
          180  +
          181  +bool CArcCpt::recurse( bool o_list, aflArray* files, kiPath& path, int base, int num )
          182  +{
          183  + bool folder;
          184  + unsigned int size;
          185  + kiPath pthtmp;
          186  +
          187  + for( int i=0; i<num; i++ )
          188  + {
          189  +  cpt.seekTo( m_nIndexPos );
          190  +
          191  + //-- tmp��index�ǂݍ���
          192  +
          193  +  tmp[0] = cpt.getc();
          194  +  if( tmp[0] & 0x80 ) folder = true,  size = (tmp[0]&0x3f) + 2;
          195  +  else    folder = false, size = (tmp[0]) + 45;
          196  +  if( size != cpt.read( tmp+1, size ) ) return false;
          197  +  m_nIndexPos = cpt.tell(); // ����Index�̈ʒu���L��
          198  +
          199  + //-- �w�b�_���
          200  +
          201  +  //   0: filename_len (BYTE)
          202  +  // 1-n: filename     (with no '\0')
          203  +  char filename[MAX_PATH];
          204  +  ki_memcpy( filename, tmp+1, tmp[0] );
          205  +  filename[ *tmp ] = '\0';
          206  +  for( char* pp=filename; *pp; pp=kiStr::next(pp) )
          207  +  {
          208  +   if( kiStr::isLeadByte(*pp) )
          209  +    continue;
          210  +   if( *pp<' ' || *pp>'~' )
          211  +    *pp = '_';
          212  +   else switch( *pp )
          213  +   {
          214  +    case '\\': case '/': case ':': case '*':
          215  +    case '?': case '\"': case '<': case '>': case '|':
          216  +     *pp = '_';
          217  +   }
          218  +  }
          219  +  // filename��2�ˆȏ��.�݂̂���Ȃ��Ă�����_�ɏ�������
          220  +  {
          221  +   int dots = 0;
          222  +   char* pp;
          223  +   for( pp=filename; *pp; pp=kiStr::next(pp) )
          224  +    if( *pp == '.' ) { ++dots; }
          225  +    else { dots=-1; break; }
          226  +   if( dots >= 2 )
          227  +    for( pp=filename; *pp; ++pp )
          228  +     *pp = '_';
          229  +  }
          230  +
          231  + //-- �_�C�A���O����
          232  +
          233  +  pthtmp = path, pthtmp += filename;
          234  +
          235  +  if( pdlg )
          236  +  {
          237  +   pdlg->change( pthtmp, base+i+1 );
          238  +   if( !pdlg->msgloop() )
          239  +    return false;
          240  +  }
          241  +
          242  + //-- �t�H���_����
          243  +
          244  +  if( folder )
          245  +  {
          246  +   unsigned long fldlen = (tmp[size-1]<<8) + tmp[size];
          247  +   pthtmp += '\\';
          248  +
          249  +   if( o_list )
          250  +   {
          251  +    files->forcelen( base+i+1 );
          252  +    ki_strcpy( (*files)[base+i].inf.szFileName, pthtmp );
          253  +    (*files)[base+i].isfile = false;
          254  +   }
          255  +
          256  +   if( !recurse( o_list, files, pthtmp, base+i+1, fldlen ) )
          257  +    return false;
          258  +   i += fldlen;
          259  +  }
          260  +
          261  + //-- �t�@�C������
          262  +
          263  +  else
          264  +  {
          265  +   const unsigned char* hdr = tmp + (size+1) - 80;
          266  +
          267  +   unsigned long rsrcSkip; bool lzhFlag;
          268  +   if( (hdr[68]<<24) + (hdr[69]<<16) + (hdr[70]<<8) + hdr[71] != 0 )
          269  +   {
          270  +    // ���� dataFork�����݂���Ȃ��
          271  +    dataULen = (hdr[68]<<24) + (hdr[69]<<16) + (hdr[70]<<8) + hdr[71];
          272  +    dataCLen = (hdr[76]<<24) + (hdr[77]<<16) + (hdr[78]<<8) + hdr[79];
          273  +    rsrcSkip = (hdr[72]<<24) + (hdr[73]<<16) + (hdr[74]<<8) + hdr[75];
          274  +    lzhFlag  = (hdr[63]&4) !=0;
          275  +   }
          276  +   else
          277  +   {
          278  +    // dataFork�����݂��Ȃ��Ȃ��
          279  +    dataULen = (hdr[64]<<24) + (hdr[65]<<16) + (hdr[66]<<8) + hdr[67];
          280  +    dataCLen = (hdr[72]<<24) + (hdr[73]<<16) + (hdr[74]<<8) + hdr[75];
          281  +    rsrcSkip = 0;
          282  +    lzhFlag  = (hdr[63]&2) !=0;
          283  +   }
          284  +
          285  +   if( o_list ) // ���X�g�։�����
          286  +   {
          287  +    files->forcelen( base+i+1 );
          288  +    ki_strcpy( (*files)[base+i].inf.szFileName, pthtmp );
          289  +    ki_strcpy( (*files)[base+i].inf.szMode, lzhFlag ? "rle+lzh" : "rle" );
          290  +    (*files)[base+i].inf.dwCompressedSize = dataCLen;
          291  +    (*files)[base+i].inf.dwOriginalSize = dataULen;
          292  +    (*files)[base+i].isfile = true;
          293  +   }
          294  +   else if( !files || (*files)[base+i].selected )
          295  +   {
          296  +    if( !(hdr[63] & 1) )
          297  +    {
          298  +     pthtmp.mkdir();
          299  +     cpt.seekTo( (hdr[36]<<24) + (hdr[37]<<16) + (hdr[38]<<8) + hdr[39] +
          300  +        rsrcSkip + m_nMacBinOffset ); // filepos + rsrcCLen + (0 | 128)
          301  +     if( out.open( pthtmp, false ) )
          302  +     {
          303  +      cptmelt( lzhFlag );
          304  +      out.close();
          305  +     }
          306  +    }
          307  +   }
          308  +  }
          309  +    }
          310  +
          311  + return true;
          312  +}
          313  +
          314  +//-- �𓀏��� ------------------------------------------------
          315  +
          316  +#define ESC1  0x81
          317  +#define ESC2  0x82
          318  +#define NONESEEN 0
          319  +#define ESC1SEEN 1
          320  +#define ESC2SEEN 2
          321  +
          322  +void CArcCpt::cptmelt( bool isRL )
          323  +{
          324  + cpt_outstat = NONESEEN;
          325  + cpt_LZptr = 0;
          326  + cpt_blocksize = 0x1fff0;
          327  +
          328  + if( isRL )
          329  +  cpt_rle_lzh();
          330  + else
          331  +  while( dataCLen-- )
          332  +   cpt_outch( cpt.getc() );
          333  +}
          334  +
          335  +void CArcCpt::cpt_outch(unsigned char ch)
          336  +{
          337  + cpt_LZbuff[ cpt_LZptr++ & (CIRCSIZE-1) ] = ch;
          338  +
          339  + switch( cpt_outstat )
          340  + {
          341  + case NONESEEN:
          342  +  if( ch==ESC1 )
          343  +   cpt_outstat = ESC1SEEN;
          344  +  else
          345  +   dataULen--,out.putc( cpt_savechar=ch );
          346  +  break;
          347  +
          348  + case ESC1SEEN:
          349  +  if( ch==ESC2 )
          350  +   cpt_outstat = ESC2SEEN;
          351  +  else
          352  +  {
          353  +   dataULen--,out.putc( cpt_savechar=ESC1 );
          354  +   if( ch!=ESC1 )
          355  +   {
          356  +    cpt_outstat = NONESEEN;
          357  +    dataULen--,out.putc( cpt_savechar=ch );
          358  +   }
          359  +  }
          360  +  break;
          361  +
          362  + case ESC2SEEN:
          363  +  cpt_outstat = NONESEEN;
          364  +  if( ch!=0 )
          365  +   while( --ch )
          366  +    dataULen--,out.putc(cpt_savechar);
          367  +  else
          368  +  {
          369  +   dataULen--,out.putc( ESC1 );
          370  +   dataULen--,out.putc( cpt_savechar=ESC2 );
          371  +  }
          372  +    }
          373  +}
          374  +
          375  +void CArcCpt::cpt_rle_lzh()
          376  +{
          377  + int block_count;
          378  + unsigned int bptr;
          379  + int Huffchar, LZlength, LZoffs;
          380  +
          381  + cpt_LZbuff[CIRCSIZE - 3] = 0;
          382  + cpt_LZbuff[CIRCSIZE - 2] = 0;
          383  + cpt_LZbuff[CIRCSIZE - 1] = 0;
          384  + cpt_LZptr = 0;
          385  +
          386  + while( dataULen!=0 )
          387  + {
          388  +  cpt_readHuff(256,cpt_Hufftree);
          389  +  cpt_readHuff( 64,cpt_LZlength);
          390  +  cpt_readHuff(128,cpt_LZoffs  );
          391  +  block_count = 0;
          392  +  cpt_newbits = (cpt.getc()<<8);
          393  +  cpt_newbits = cpt_newbits | cpt.getc();
          394  +  cpt_newbits = cpt_newbits << 16;
          395  +  cpt_bitsavail = 16;
          396  +  while( block_count<cpt_blocksize && dataULen!=0 )
          397  +  {
          398  +   if( cpt_getbit() )
          399  +   {
          400  +    Huffchar = gethuffbyte(cpt_Hufftree);
          401  +    cpt_outch((unsigned char)Huffchar);
          402  +    block_count += 2;
          403  +   }
          404  +   else
          405  +   {
          406  +    LZlength = gethuffbyte(cpt_LZlength);
          407  +    LZoffs = gethuffbyte(cpt_LZoffs);
          408  +    LZoffs = (LZoffs << 6) | cpt_get6bits();
          409  +    bptr = cpt_LZptr - LZoffs;
          410  +    while( LZlength-->0 )
          411  +     cpt_outch(cpt_LZbuff[bptr++&(CIRCSIZE-1)]);
          412  +    block_count += 3;
          413  +   }
          414  +  }
          415  + }
          416  +}
          417  +
          418  +int CArcCpt::gethuffbyte(node* l_nodelist)
          419  +{
          420  + register node *np;
          421  + np = l_nodelist;
          422  + while(np->flag == 0)
          423  +  np = cpt_getbit() ? np->one : np->zero;
          424  + return np->byte;
          425  +}
          426  +
          427  +void CArcCpt::cpt_readHuff(int size,node* Hufftree)
          428  +{
          429  + sf_entry tree_entry[256 + SLACK];
          430  + int tree_entries;
          431  + int tree_MaxLength;
          432  + int treeBytes, i, len;
          433  + sf_entry *ejm1;
          434  + int j;
          435  + sf_entry *entry;
          436  +    sf_entry tmp;
          437  +    int entries;
          438  +    unsigned a, b;
          439  + int codelen, lvlstart, next, parents;
          440  + int tree_count[32];
          441  +
          442  + treeBytes = cpt.getc();
          443  + if( size<treeBytes*2 )
          444  +  return;
          445  + for( i=0; i!=32; i++ )
          446  +  tree_count[i] = 0;
          447  + i = 0;
          448  + tree_MaxLength = 0;
          449  + tree_entries = 0;
          450  + while( treeBytes-->0 )
          451  + {
          452  +  int c=cpt.getc();
          453  +  len = c >> 4;
          454  +
          455  +  if(len != 0)
          456  +  {
          457  +   if(len > tree_MaxLength)
          458  +    tree_MaxLength = len;
          459  +   tree_count[len]++;
          460  +   tree_entry[tree_entries].Value = i;
          461  +   tree_entry[tree_entries++].BitLength = len;
          462  +  }
          463  +  i++;
          464  +  len = c & 0x0f;
          465  +  if(len != 0)
          466  +  {
          467  +   if(len > tree_MaxLength)
          468  +    tree_MaxLength = len;
          469  +   tree_count[len]++;
          470  +   tree_entry[tree_entries].Value = i;
          471  +   tree_entry[tree_entries++].BitLength = len;
          472  +  }
          473  +  i++;
          474  + }
          475  +
          476  + j = 0;
          477  +    for( i=0; i<=tree_MaxLength; i++ )
          478  +  j = (j << 1) + tree_count[i];
          479  + j = (1 <<tree_MaxLength) - j;
          480  + for( i=0; i<j; i++ )
          481  + {
          482  +  tree_entry[tree_entries].Value = size;
          483  +  tree_entry[tree_entries++].BitLength = tree_MaxLength;
          484  + }
          485  +
          486  + entry = &(tree_entry[0]);
          487  + entries = tree_entries;
          488  +    for( i=0; ++i<entries; )
          489  + {
          490  +  tmp = entry[i];
          491  +  b = tmp.BitLength;
          492  +  j = i;
          493  +  while((j > 0) && ((a = (ejm1 = &(entry[j - 1]))->BitLength) >= b))
          494  +  {
          495  +   if((a == b) && (ejm1->Value <= tmp.Value))
          496  +    break;
          497  +   *(ejm1 + 1) = *ejm1;
          498  +   --j;
          499  +  }
          500  +  entry[j] = tmp;
          501  + }
          502  +
          503  +    i = tree_entries - 1;
          504  +    lvlstart = next = size * 2 + SLACK - 1;
          505  +    for(codelen = tree_MaxLength; codelen >= 1; --codelen)
          506  + {
          507  +  while((i >= 0) && (tree_entry[i].BitLength == codelen))
          508  +  {
          509  +   Hufftree[next].byte = tree_entry[i].Value;
          510  +   Hufftree[next].flag = 1;
          511  +   next--;
          512  +   i--;
          513  +  }
          514  +  parents = next;
          515  +  if(codelen > 1)
          516  +  {
          517  +   for(j = lvlstart; j > parents + 1; j-= 2)
          518  +   {
          519  +    Hufftree[next].one = &(Hufftree[j]);
          520  +    Hufftree[next].zero = &(Hufftree[j - 1]);
          521  +    Hufftree[next].flag = 0;
          522  +    next--;
          523  +   }
          524  +  }
          525  +  lvlstart = parents;
          526  + }
          527  + Hufftree[0].one = &(Hufftree[next + 2]);
          528  + Hufftree[0].zero = &(Hufftree[next + 1]);
          529  + Hufftree[0].flag = 0;
          530  +}
          531  +
          532  +int CArcCpt::cpt_get6bits()
          533  +{
          534  + int cn,b=(cpt_newbits >> 26) & 0x3f;
          535  + cpt_bitsavail -= 6;
          536  + cpt_newbits <<= 6;
          537  + if(cpt_bitsavail < 16)
          538  + {
          539  +  cn = (cpt.getc() << 8);
          540  +  cn |= cpt.getc();
          541  +  cpt_newbits |= (cn << (16 - cpt_bitsavail));
          542  +  cpt_bitsavail += 16;
          543  + }
          544  + return b;
          545  +}
          546  +
          547  +int CArcCpt::cpt_getbit()
          548  +{
          549  + int b = (cpt_newbits >> 31) & 1;
          550  + cpt_bitsavail--;
          551  + if( cpt_bitsavail<16 )
          552  + {
          553  +  cpt_newbits |= (cpt.getc() << 8);
          554  +  cpt_newbits |= cpt.getc();
          555  +  cpt_bitsavail += 16;
          556  + }
          557  + cpt_newbits <<= 1;
          558  + return b;
          559  +}

Added ArcCpt.h version [909c16b823b96e7b]

            1  +#ifndef AFX_ARCCPT_H__B5D13025_2DA9_4489_8BCB_ACB84B908A84__INCLUDED_
            2  +#define AFX_ARCCPT_H__B5D13025_2DA9_4489_8BCB_ACB84B908A84__INCLUDED_
            3  +
            4  +#include "Archiver.h"
            5  +#include "SubDlg.h"
            6  +
            7  +class CArcCpt : public CArchiver
            8  +{
            9  +public:
           10  + CArcCpt() : CArchiver("cpt.bin.") {}
           11  +
           12  +private:
           13  + int  v_load(){return aCheck|aMelt|aList|aMeltEach;}
           14  + bool v_check( const kiPath& aname );
           15  + int  v_contents( const kiPath& aname, kiPath& dname );
           16  + int  v_melt( const arcname& aname, const kiPath& ddir, const aflArray* files );
           17  + bool v_list( const arcname& aname, aflArray& files );
           18  + kiStr v_name(const char*) const { return "CPT"; }
           19  +
           20  + CArcProgressDlg* pdlg;
           21  +
           22  +//-- cpt archive operations ----------------
           23  +
           24  + unsigned int m_nMacBinOffset;
           25  + unsigned int m_nIndexPos;
           26  + unsigned int dataULen, dataCLen;
           27  +
           28  + kiFile cpt,out;
           29  + unsigned char tmp[270]; // temp
           30  +
           31  + bool read_main_hdr();
           32  + bool check_index_crc();
           33  + bool operation_for_each( bool o_list=true, aflArray* files=NULL );
           34  + bool recurse( bool o_list, aflArray* files, kiPath& path, int base, int num );
           35  + void cptmelt( bool isRL );
           36  +
           37  +//-- lzh - rle -------------------------------
           38  +
           39  +#define CIRCSIZE 8192
           40  + class sf_entry
           41  + {
           42  + public:
           43  +  int Value;
           44  +  int BitLength;
           45  + };
           46  + class node
           47  + {
           48  + public:
           49  +  int flag, byte;
           50  +  node *one, *zero;
           51  + };
           52  +
           53  + void cpt_outch( unsigned char ch );
           54  + BYTE cpt_outstat,cpt_savechar;
           55  + void cpt_rle_lzh();
           56  + int cpt_get6bits();
           57  + int cpt_getbit();
           58  + void cpt_readHuff(int size,node* Hufftree);
           59  +
           60  + int gethuffbyte(node* l_nodelist);
           61  +#define SLACK 6
           62  + node cpt_Hufftree[512 + SLACK],cpt_LZlength[128 + SLACK],cpt_LZoffs[256 + SLACK];
           63  + unsigned char cpt_LZbuff[CIRCSIZE];
           64  + unsigned int cpt_LZptr;
           65  + unsigned long cpt_newbits;
           66  + int cpt_bitsavail;
           67  + int cpt_blocksize;
           68  +};
           69  +
           70  +#endif

Added ArcDLL.cpp version [83474074d1b2482a]

            1  +
            2  +#include "stdafx.h"
            3  +#include "ArcDLL.h"
            4  +#include "NoahApp.h"
            5  +
            6  +int CArcDLL::v_load()
            7  +{
            8  + // DLL�̑��݊m�F
            9  + if( !dll.exist() )
           10  +  return 0;
           11  +
           12  + // ���k���\�b�h���X�g��ݒ�
           13  + DWORD cp = set_cmpr_mhd();
           14  +
           15  + // Abilty��Ԃ�
           16  + return (m_Ecmd ? aCheck|aMelt : 0) | (m_Xcmd ? aList|aMeltEach : 0) | cp | (m_Scmd ? aSfx : 0);
           17  +}
           18  +
           19  +int CArcDLL::v_melt( const arcname& aname, const kiPath& ddir, const aflArray* files )
           20  +{
           21  + // �o�͐���J�����g��
           22  + ::SetCurrentDirectory( ddir );
           23  +
           24  + // �𓀃R�}���h
           25  + kiStr cmd = ( !files || files->len()==0 ) ? m_Ecmd : m_Xcmd;
           26  +
           27  + // ���ɖ�
           28  + cmd += " \"", cmd += aname.basedir, cmd += aname.lname, cmd += "\" \"";
           29  + // �o�͐�f�B���N�g��
           30  + cmd += ddir, cmd += '"';
           31  +
           32  + // ( ��������� )�t�@�C�����X�g
           33  + if( files )
           34  +  for( unsigned int i=0; i!=files->len(); i++ )
           35  +   if( (*files)[i].selected )
           36  +    cmd += " \"",
           37  +    decorate_add_melt( cmd, (*files)[i].inf.szFileName ),
           38  +    cmd += '"';
           39  +
           40  + // �R�}���h���s�I
           41  + return dll.cmd( cmd );
           42  +}
           43  +
           44  +int  CArcDLL::v_compress( const kiPath&   base,
           45  +        const wfdArray& files,
           46  +        const kiPath&   ddir,
           47  +        const int       method,
           48  +        const bool      sfx )
           49  +{
           50  + // ���̓J�����g
           51  + ::SetCurrentDirectory( base );
           52  +
           53  + // �t�@�C�������X�g�쐬
           54  + kiStr lst;
           55  + for( unsigned int i=0; i!=files.len(); i++ )
           56  + {
           57  +  lst += '"';
           58  +  decorate_add_cmpr( lst, files[i].cFileName );
           59  +  if( files[i].dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
           60  +   if( m_Wild==1 )
           61  +    lst += "\\*";
           62  +   else if( m_Wild==2 )
           63  +    lst += "\\*.*";
           64  +  lst += "\" ";
           65  + }
           66  +
           67  + // ���ɖ��쐬
           68  +
           69  + // Ver 3.14 -- �t�H���_�Ȃ�g���q�������Ȃ�
           70  + //  b2e�̕��͍��X�ǁ[���悤���Ȃ��̂ŁA���������ύX
           71  + // Ver 3.19 -- ���g���q�͈�‚���
           72  + kiStr aname;
           73  + if( files[0].dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
           74  + {
           75  +  aname = kiPath::name( files[0].cFileName );
           76  + }
           77  + else
           78  + {
           79  +  switch(mycnf().extnum())
           80  +  {
           81  +  case 0: aname = files[0].cFileName;break;
           82  +  case 1: kiPath(files[0].cFileName).getBody_all(aname);break;
           83  +  default:kiPath(files[0].cFileName).getBody(aname);break;
           84  +  }
           85  + }
           86  +
           87  +
           88  + // ���k�I
           89  + if( sfx )
           90  + {
           91  +  kiPath tmp;
           92  +  myapp().get_tempdir( tmp );
           93  +
           94  +  kiPath tsfx(tmp);  tsfx+=aname; tsfx+=".exe";
           95  +  kiPath rsfx(ddir); rsfx+=aname; rsfx+=".exe";
           96  +
           97  +  int ans = cmpr( method, aname, tmp, lst );
           98  +  if( ans < 0x8000 )
           99  +  {
          100  +   ans = 0x8020;
          101  +   ::SetCurrentDirectory( tmp );
          102  +   if( arc2sfx( aname ) )
          103  +    if( ::CopyFile( tsfx, rsfx, FALSE ) )
          104  +     ans = 0;
          105  +   // �J�����g��߂��Ă����Ȃ��Ƃ��Ƃō폜�ł��Ȃ��c
          106  +   ::SetCurrentDirectory( base );
          107  +  }
          108  +
          109  +  tmp.remove();
          110  +  return ans;
          111  + }
          112  + else
          113  +  return cmpr( method, aname, ddir, lst );
          114  +}
          115  +
          116  +int CArcDLL::cmpr( int mhd, kiStr& aname,const kiPath& to,const kiStr& lst )
          117  +{
          118  + aname += '.', aname+=get_cmpr_ext(mhd);
          119  +
          120  + kiStr cmd = get_cmpr_cmd(mhd);
          121  + cmd += " \"";
          122  + cmd += to;
          123  + cmd += aname;
          124  + cmd += "\" ";
          125  + cmd += lst;
          126  + return dll.cmd( cmd );
          127  +}
          128  +
          129  +bool CArcDLL::arc2sfx( const kiStr& aname )
          130  +{
          131  + kiStr cmd=m_Scmd; cmd+=" \"", cmd+=aname, cmd+='"';
          132  + return 0x8000>dll.cmd( cmd );
          133  +}
          134  +
          135  +//----------------------------------------------------------------------//
          136  +
          137  +void CArcDLL::decorate_add_cmpr( kiStr& lst, const char* fname )
          138  +{
          139  + lst += fname;
          140  +}
          141  +
          142  +void CArcDLL::decorate_add_melt( kiStr& lst, const char* fname )
          143  +{
          144  + lst += fname;
          145  +}
          146  +
          147  +void CArcDLL_DotSlash::decorate_add_cmpr( kiStr& lst, const char* fname )
          148  +{
          149  + // �擪 - �� @ �΍�ɁA.\\ �ŃG�X�P�[�v����
          150  + if( *fname=='-' || *fname=='@' )
          151  +  lst += ".\\";
          152  + lst += fname;
          153  +}
          154  +
          155  +void CArcLzh::decorate_add_cmpr( kiStr& lst, const char* fname )
          156  +{
          157  + // UNLHA32.DLL �ɂ͂��̖����p�̃I�v�V���� -gb ���B
          158  + if( *fname=='-' )
          159  +  lst += "-gb";
          160  + lst += fname;
          161  +}
          162  +
          163  +void CArcLzh::decorate_add_melt( kiStr& lst, const char* fname )
          164  +{
          165  + // UNLHA32.DLL �ɂ͂��̖����p�̃I�v�V���� -gb ���B
          166  + if( *fname=='-' )
          167  +  lst += "-gb";
          168  + lst += fname;
          169  +}
          170  +
          171  +void CArcZip::decorate_add_cmpr( kiStr& lst, const char* fname )
          172  +{
          173  + // �擪 - �� @ �΍�ɁA[-] [@] �ƒu������
          174  + if( *fname=='-' || *fname=='@' )
          175  +  lst+='[', lst+=*fname++, lst+=']';
          176  +
          177  + // �r���� [ �� [[] �ɒu������
          178  + while( *fname )
          179  +  if( kiStr::isLeadByte(*fname) )
          180  +  {
          181  +   lst += *fname++, lst += *fname++;
          182  +  }
          183  +  else
          184  +  {
          185  +   lst += *fname;
          186  +   if( *fname++=='[' )
          187  +    lst += "[]";
          188  +  }
          189  +}
          190  +
          191  +//----------------------------------------------------------------------//
          192  +
          193  +DWORD CArcLzh::set_cmpr_mhd()
          194  +{
          195  + set_cmp_ext( "lzh" );
          196  + add_cmp_mhd( "lh5" ), add_cmp_mhd( "lh6" ), add_cmp_mhd( "lh7" );
          197  + return aCompress|aArchive;
          198  +}
          199  +
          200  +const char* CArcLzh::get_cmpr_cmd( int method )
          201  +{
          202  + static char cmd[] = "a -d -jso1 -- -jm2";
          203  + cmd[ sizeof(cmd)-2 ] = (char)('2'+method);
          204  + return cmd;
          205  +}
          206  +
          207  +//----------------------------------------------------------------------//
          208  +
          209  +DWORD CArcZip::set_cmpr_mhd()
          210  +{
          211  + set_cmp_ext( "zip" );
          212  + add_cmp_mhd( "store" ),
          213  + add_cmp_mhd( "normal", true ), add_cmp_mhd( "password" );
          214  + return aCompress|aArchive;
          215  +}
          216  +
          217  +const char* CArcZip::get_cmpr_cmd( int method )
          218  +{
          219  + switch( method )
          220  + {
          221  + case 0: return "-rS0";
          222  + case 2: return "-rS9e";
          223  + }
          224  + return "-rS9";
          225  +}
          226  +
          227  +//----------------------------------------------------------------------//
          228  +
          229  +DWORD CArcCab::set_cmpr_mhd()
          230  +{
          231  + set_cmp_ext( "cab" );
          232  + add_cmp_mhd( "MSZIP" ), add_cmp_mhd( "LZX21",true );
          233  + return aCompress|aArchive;
          234  +}
          235  +
          236  +const char* CArcCab::get_cmpr_cmd( int method )
          237  +{
          238  + return method==0 ? "-a -r -mz" : "-a -r -ml:21";
          239  +}
          240  +
          241  +//----------------------------------------------------------------------//
          242  +
          243  +DWORD CArcTar::set_cmpr_mhd()
          244  +{
          245  + set_cmp_ext( "tar" );
          246  + add_cmp_mhd( "normal" ), add_cmp_mhd( "gzip",true ), add_cmp_mhd( "bzip2" );
          247  + add_cmp_mhd( "xz" ), add_cmp_mhd( "lzma" );
          248  + return aCompress|aArchive;
          249  +}
          250  +
          251  +const char* CArcTar::get_cmpr_ext( int method )
          252  +{
          253  + switch( method )
          254  + {
          255  + case 1: return "tgz";
          256  + case 2: return "tbz";
          257  + case 3: return "tar.xz";
          258  + case 4: return "tar.lzma";
          259  + }
          260  + return "tar";
          261  +}
          262  +
          263  +const char* CArcTar::get_cmpr_cmd( int method )
          264  +{
          265  + switch( method )
          266  + {
          267  + case 1: return "-cvz9 --";
          268  + case 2: return "-cvB --";
          269  + case 3: return "-cvJ9 --";
          270  + case 4: return "-cv --lzma=9 --";
          271  + }
          272  + return "-cv --";
          273  +}
          274  +
          275  +//----------------------------------------------------------------------//
          276  +
          277  +DWORD CArcBga::set_cmpr_mhd()
          278  +{
          279  + set_cmp_ext( "bga" );
          280  + add_cmp_mhd( "gzip" ), add_cmp_mhd( "bzip2",true );
          281  + return aCompress|aArchive;
          282  +}
          283  +
          284  +const char* CArcBga::get_cmpr_ext( int method )
          285  +{
          286  + return method==0 ? "gza" : "bza";
          287  +}
          288  +
          289  +const char* CArcBga::get_cmpr_cmd( int method )
          290  +{
          291  + return "a -r -a";
          292  +}
          293  +
          294  +//----------------------------------------------------------------------//
          295  +
          296  +DWORD CArcYz1::set_cmpr_mhd()
          297  +{
          298  + set_cmp_ext( "yz1" );
          299  + add_cmp_mhd( "normal" ), add_cmp_mhd( "password" );
          300  + return aCompress|aArchive;
          301  +}
          302  +
          303  +const char* CArcYz1::get_cmpr_cmd( int method )
          304  +{
          305  + return method==0 ? "c --" : "c -p --";
          306  +}
          307  +
          308  +//----------------------------------------------------------------------//
          309  +
          310  +bool CArcRar::v_check( const kiPath& aname )
          311  +{
          312  + // Unrar.dll �̃o�O�H�̂��߁A�t�@�C���n���h�����������Ȃ����Ƃ�
          313  + // ����̂ŁA���O�̃`�F�b�N���[�`����p����
          314  + // # Subset of XacRett #39
          315  +
          316  + bool ans=false;
          317  + kiFile rar;
          318  + if( !rar.open(aname) )
          319  +  return false;
          320  +
          321  + unsigned char mark[10];
          322  + if( 10!=rar.read(mark,10) )
          323  +  return false;
          324  +
          325  + if( mark[0]==0x52 && mark[1]==0x45 && mark[2]==0x7e && mark[3]==0x5e )
          326  +  return true;
          327  + else if( mark[0]==0x52 && mark[1]==0x61 &&
          328  +    mark[2]==0x72 && mark[3]==0x21 &&
          329  +    mark[4]==0x1a && mark[5]==0x07 &&
          330  +    mark[6]==0x00 && mark[9]==0x73 )
          331  +  return true;
          332  + else
          333  + {
          334  +  unsigned char* mem=new unsigned char[0x20000];
          335  +  int siz = rar.read( mem, 0x1FFF0 );
          336  +
          337  +  for( unsigned char* p=mem; p<mem+siz-9; p++ )
          338  +  {
          339  +   if( *p!=0x52 )continue;
          340  +   if( p[1]==0x45 && p[2]==0x7e && p[3]==0x5e &&
          341  +    mem[18]==0x52 && mem[19]==0x53 &&
          342  +    mem[20]==0x46 && mem[21]==0x58)
          343  +    { ans=true; break; }
          344  +
          345  +   if( p[1]==0x61 && p[2]==0x72 && p[3]==0x21 &&
          346  +    p[4]==0x1a && p[5]==0x07 && p[6]==0x00 &&
          347  +    p[9]==0x73 )
          348  +    { ans=true; break; }
          349  +  }
          350  +  delete [] mem;
          351  +    }
          352  +
          353  + return ans;
          354  +}
          355  +
          356  +int CArcRar::v_melt( const arcname& aname, const kiPath& ddir, const aflArray* files )
          357  +{
          358  + // Unrar�̓R�}���h�w��Ń_�C�A���O�������Ȃ��̂ŁA
          359  + // OwnerWindow���w�肷��
          360  +
          361  + if( files && files->len() )
          362  +  dll.own( app()->mainhwnd() );
          363  +
          364  + int ans = CArcDLL::v_melt( aname, ddir, files );
          365  +
          366  + if( files && files->len() )
          367  +  dll.fre();
          368  +
          369  + return ans;
          370  +}
          371  +
          372  +int CArcUnZip::v_melt( const arcname& aname, const kiPath& ddir, const aflArray* files )
          373  +{
          374  + // UnZip32.dll�����ȃt�H���_�����o���o�O�΍�
          375  +
          376  + int ans = CArcDLL::v_melt( aname, ddir, files );
          377  + dll.unload();
          378  + return ans;
          379  +}
          380  +
          381  +//----------------------------------------------------------------------//
          382  +
          383  +DWORD CArc7z::set_cmpr_mhd()
          384  +{
          385  + set_cmp_ext( "7z" );
          386  + add_cmp_mhd( "LZMA", true );
          387  + add_cmp_mhd( "LZMA(std)" );
          388  + add_cmp_mhd( "LZMA(fast)" );
          389  + add_cmp_mhd( "PPMd" );
          390  + return aCompress|aArchive;
          391  +}
          392  +
          393  +const char* CArc7z::get_cmpr_cmd( int method )
          394  +{
          395  + if( m_SfxMode )
          396  +  switch( method )
          397  +  {
          398  +   case 0:  return "a -t7z -sfx -m0=LZMA -r0 -mx=9 --";
          399  +   case 1:  return "a -t7z -sfx -m0=LZMA -r0 -mx=5 --";
          400  +   case 2:  return "a -t7z -sfx -m0=LZMA -r0 -mx=1 --";
          401  +   default: return "a -t7z -sfx -m0=PPMd -r0 -mx=9 --";
          402  +  }
          403  + else
          404  +  switch( method )
          405  +  {
          406  +   case 0:  return "a -t7z -m0=LZMA -r0 -mx=9 --";
          407  +   case 1:  return "a -t7z -m0=LZMA -r0 -mx=5 --";
          408  +   case 2:  return "a -t7z -m0=LZMA -r0 -mx=1 --";
          409  +   default: return "a -t7z -m0=PPMd -r0 -mx=9 --";
          410  +  }
          411  +}
          412  +
          413  +int CArc7z::v_compress( const kiPath& base, const wfdArray& files, const kiPath& ddir, int method, bool sfx )
          414  +{
          415  + m_SfxMode = sfx; // ����������肵��SFX���[�h���L��
          416  + return CArcDLL::v_compress(base,files,ddir,method,false);
          417  +}
          418  +
          419  +const char* CArc7z::get_cmpr_ext( int method )
          420  +{
          421  + return m_SfxMode ? "exe" : "7z";
          422  +}
          423  +
          424  +//----------------------------------------------------------------------//
          425  +
          426  +DWORD CArc7zZip::set_cmpr_mhd()
          427  +{
          428  + set_cmp_ext( "zip" );
          429  + add_cmp_mhd( "7-zip", true );
          430  + return aCompress|aArchive;
          431  +}
          432  +
          433  +const char* CArc7zZip::get_cmpr_cmd( int method )
          434  +{
          435  + return "a -tzip -r0 -mx=9 --";
          436  +}
          437  +
          438  +int CArc7zZip::v_compress( const kiPath& base, const wfdArray& files, const kiPath& ddir, int method, bool sfx )
          439  +{
          440  + // ����������肵�Ēʏ툳�k
          441  + return CArcDLL::v_compress(base,files,ddir,method,false);
          442  +}
          443  +

Added ArcDLL.h version [a694505ce13887ba]

            1  +#ifndef AFX_ARCDLL_H__911C109D_A40E_4722_A6F7_E3ACB8C2D2E3__INCLUDED_
            2  +#define AFX_ARCDLL_H__911C109D_A40E_4722_A6F7_E3ACB8C2D2E3__INCLUDED_
            3  +
            4  +#include "Archiver.h"
            5  +
            6  +class CArcDLL : public CArchiver
            7  +{
            8  +public:
            9  + CArcDLL(
           10  +  const char*  Dllname, // DLL��
           11  +  const char*  Exts,  // �Ή��g���q
           12  +  const char*  Ecmd,  // �𓀗p�R�}���h
           13  +  const char*  Xcmd,  // �����𓀗p�R�}���h
           14  +  unsigned int Wild=1, // ���C���h�J�[�h�̌`��( 0=no(*) 1=* 2=*.* )
           15  +  const char*  Scmd=NULL )// SFX�ϊ��p�R�}���h
           16  +  : dll( Dllname ), CArchiver( Exts ), m_Ecmd( Ecmd ),
           17  +   m_Xcmd( Xcmd ), m_Wild( Wild ), m_Scmd( Scmd ) {}
           18  +
           19  +protected: //-- �h�����Ă��悵
           20  + virtual DWORD set_cmpr_mhd()
           21  +  { return 0; }
           22  + virtual const char* get_cmpr_ext( int method )
           23  +  { return cmp_ext(); }
           24  + virtual const char* get_cmpr_cmd( int method )
           25  +  { return ""; }
           26  + virtual void decorate_add_cmpr( kiStr& lst, const char* fname );
           27  + virtual void decorate_add_melt( kiStr& lst, const char* fname );
           28  +
           29  +protected: //-- ��������
           30  + CArcModule dll;
           31  + bool v_ver( kiStr& str ){ dll.ver(str); return true; }
           32  + bool v_check( const kiPath& aname ){ return dll.chk(aname); }
           33  + int  v_contents( const kiPath& aname, kiPath& dname ){ return dll.cnt(aname,dname,m_Wild==2?"*.*":"*"); }
           34  + bool v_list( const arcname& aname, aflArray& files ){ return dll.lst_dll(aname,files,m_Wild==2?"*.*":"*"); }
           35  +
           36  + int  v_load();
           37  + int  v_melt( const arcname& aname, const kiPath& ddir, const aflArray* files );
           38  + int  v_compress( const kiPath& base, const wfdArray& files, const kiPath& ddir, int method, bool sfx );
           39  + kiStr v_name(const char*) const { return dll.name(); }
           40  +
           41  +private:
           42  + const char *m_Ecmd, *m_Xcmd, *m_Scmd;
           43  + unsigned int m_Wild;
           44  + int  cmpr( int mhd, kiStr& aname,const kiPath& to,const kiStr& lst );
           45  + bool arc2sfx( const kiStr& aname );
           46  +};
           47  +
           48  +//------------------------------------------------------------//
           49  +
           50  +class CArcDLL_DotSlash : public CArcDLL
           51  +{
           52  + // "./-" �� "./@" �Ƃ��邱�ƂłƂ肠������������k����`��
           53  + virtual void decorate_add_cmpr( kiStr& lst, const char* fname );
           54  +
           55  +protected:
           56  + CArcDLL_DotSlash(
           57  +  const char*  Dllname,
           58  +  const char*  Exts,
           59  +  const char*  Ecmd,
           60  +  const char*  Xcmd,
           61  +  unsigned int Wild=1,
           62  +  const char*  Scmd=NULL )
           63  +  : CArcDLL( Dllname, Exts, Ecmd, Xcmd, Wild, Scmd ) {}
           64  +};
           65  +
           66  +//------------------------------------------------------------//
           67  +
           68  +class CArcRar : public CArcDLL
           69  +{
           70  +public:
           71  + CArcRar() : CArcDLL(
           72  +  "Unrar32.dll",
           73  +  "rar.",
           74  +  "-x",
           75  +  "-x -s -y --" ) {}
           76  +
           77  +private:
           78  + kiStr v_name(const char*) const { return "RAR"; }
           79  + // ���ʂɔh��
           80  + bool v_check( const kiPath& aname );
           81  + int  v_melt( const arcname& aname, const kiPath& ddir, const aflArray* files );
           82  +};
           83  +
           84  +//------------------------------------------------------------//
           85  +
           86  +class CArcUnZip : public CArcDLL
           87  +{
           88  +public:
           89  + CArcUnZip() : CArcDLL(
           90  +  "UnZip32.dll",
           91  +  "zip.jar.",
           92  +  "-x",
           93  +  "-x --i -o" ) {}
           94  +private:
           95  + kiStr v_name(const char*) const { return "ZIP"; }
           96  + // ���ʂɔh��
           97  + int  v_melt( const arcname& aname, const kiPath& ddir, const aflArray* files );
           98  +};
           99  +
          100  +//------------------------------------------------------------//
          101  +
          102  +class CArcLzh : public CArcDLL
          103  +{
          104  +public:
          105  + CArcLzh() : CArcDLL(
          106  +  "Unlha32.dll",
          107  +  "lzh.lha.lzs.",
          108  +  "x -a1 -jf0",
          109  +  "x -a1 -jf0 -jyo -p1 -n -gm --",
          110  +  0,
          111  +  "s -gw3 -x1" ) {}
          112  +private:
          113  + kiStr v_name(const char*) const { return "LZH"; }
          114  + DWORD set_cmpr_mhd();
          115  + const char* get_cmpr_cmd( int method );
          116  + void decorate_add_cmpr( kiStr& lst, const char* fname );
          117  + void decorate_add_melt( kiStr& lst, const char* fname );
          118  +};
          119  +
          120  +//------------------------------------------------------------//
          121  +
          122  +class CArcZip : public CArcDLL
          123  +{
          124  +public:
          125  + CArcZip() : CArcDLL(
          126  +  "Zip32j.dll",
          127  +  "",
          128  +  NULL,
          129  +  NULL,
          130  +  1,
          131  +  "--sfx" ) {}
          132  +private:
          133  + DWORD set_cmpr_mhd();
          134  + const char* get_cmpr_cmd( int method );
          135  + void decorate_add_cmpr( kiStr& lst, const char* fname );
          136  +};
          137  +
          138  +//------------------------------------------------------------//
          139  +
          140  +class CArcCab : public CArcDLL_DotSlash
          141  +{
          142  +public:
          143  + CArcCab() : CArcDLL_DotSlash(
          144  +  "Cab32.dll",
          145  +  "cab.",
          146  +  "-x",
          147  +  "-x -i -o",
          148  +  1,
          149  +  "-f" ) {}
          150  +private:
          151  + kiStr v_name(const char*) const { return "CAB"; }
          152  + DWORD set_cmpr_mhd();
          153  + const char* get_cmpr_cmd( int method );
          154  +};
          155  +
          156  +//------------------------------------------------------------//
          157  +
          158  +class CArcTar : public CArcDLL_DotSlash
          159  +{
          160  +public:
          161  + CArcTar() : CArcDLL_DotSlash(
          162  +  "Tar32.dll",
          163  +  "tar.tgz.tbz.gz.bz2.z.taz.rpm.deb.ar.xz.lzma.",
          164  +  "-xvf",
          165  +  "--check-all-path=1 --display-dialog=0 -xvf",
          166  +  2 ) {}
          167  +private:
          168  + #define ARCHIVETYPE_NORMAL 0
          169  + #define ARCHIVETYPE_TAR 1
          170  + #define ARCHIVETYPE_TARGZ 2
          171  + #define ARCHIVETYPE_TARZ 3
          172  + #define ARCHIVETYPE_GZ 4
          173  + #define ARCHIVETYPE_Z 5
          174  + #define ARCHIVETYPE_TARBZ2 6
          175  + #define ARCHIVETYPE_BZ2 7
          176  +
          177  + #define ARCHIVETYPE_CPIO 32
          178  + #define ARCHIVETYPE_CPIOGZ 32+4
          179  + #define ARCHIVETYPE_CPIOZ 32+5
          180  + #define ARCHIVETYPE_CPIOBZ2 32+7
          181  +
          182  + #define ARCHIVETYPE_AR  48
          183  + #define ARCHIVETYPE_ARGZ 48+4
          184  + #define ARCHIVETYPE_ARZ  48+5
          185  + #define ARCHIVETYPE_ARBZ2 48+7
          186  + kiStr v_name(const char* an) const { switch(dll.arctype(an)) {
          187  +  case ARCHIVETYPE_GZ:     return "GZ";
          188  +  case ARCHIVETYPE_Z:      return "Z";
          189  +  case ARCHIVETYPE_BZ2:    return "BZ2";
          190  +  case ARCHIVETYPE_TARGZ:  return "TAR+GZ";
          191  +  case ARCHIVETYPE_TARZ:   return "TAR+Z";
          192  +  case ARCHIVETYPE_TARBZ2: return "TAR+BZ2";
          193  +  case ARCHIVETYPE_CPIOGZ: return kiStr("rpm").isSame(kiPath::ext(an)) ? "RPM" : "CPIO+GZ";
          194  +  case ARCHIVETYPE_CPIOZ:  return "CPIO+Z";
          195  +  case ARCHIVETYPE_CPIOBZ2:return "CPIO+BZ2";
          196  +  case ARCHIVETYPE_ARGZ:   return "AR+GZ";
          197  +  case ARCHIVETYPE_ARZ:    return "AR+Z";
          198  +  case ARCHIVETYPE_ARBZ2:  return "AR+BZ2";
          199  +  case ARCHIVETYPE_AR:     return "AR";
          200  +  case ARCHIVETYPE_CPIO:   return "CPIO";
          201  +  default:                 return "TAR";
          202  + }}
          203  + const char* get_cmpr_ext( int method );
          204  + DWORD set_cmpr_mhd();
          205  + const char* get_cmpr_cmd( int method );
          206  +};
          207  +
          208  +//------------------------------------------------------------//
          209  +
          210  +class CArcBga : public CArcDLL_DotSlash
          211  +{
          212  +public:
          213  + CArcBga() : CArcDLL_DotSlash(
          214  +  "Bga32.dll",
          215  +  "gza.bza.",
          216  +  "x -a",
          217  +  "x -a -i -o",
          218  +  0,
          219  +  "s" ) {}
          220  +private:
          221  + kiStr v_name(const char* an) const { return dll.arctype(an)==2 ? "BZA" : "GZA"; }
          222  + const char* get_cmpr_ext( int method );
          223  + DWORD set_cmpr_mhd();
          224  + const char* get_cmpr_cmd( int method );
          225  +};
          226  +
          227  +//------------------------------------------------------------//
          228  +
          229  +class CArcYz1 : public CArcDLL
          230  +{
          231  +public:
          232  + CArcYz1() : CArcDLL(
          233  +  "Yz1.dll",
          234  +  "yz1.",
          235  +  "x",
          236  +  "x -y -z -i2 --",
          237  +  0,
          238  +  "s" ) {}
          239  +private:
          240  + kiStr v_name(const char*) const { return "YZ1"; }
          241  + DWORD set_cmpr_mhd();
          242  + const char* get_cmpr_cmd( int method );
          243  +};
          244  +
          245  +//------------------------------------------------------------//
          246  +
          247  +class CArcArj : public CArcDLL
          248  +{
          249  +public:
          250  + CArcArj() : CArcDLL
          251  +  ( "Unarj32j.dll", "arj.", "x -jyc", "x -y -p -hm -i -!" ) {}
          252  +
          253  +private:
          254  + kiStr v_name(const char*) const { return "ARJ"; }
          255  +};
          256  +
          257  +//------------------------------------------------------------//
          258  +
          259  +class CArcGca : public CArcDLL
          260  +{
          261  +public:
          262  + CArcGca() : CArcDLL
          263  +  ( "UnGCA32.dll", "gca.", "e -sx1", "ex -xx1 -sx0 -yx0" ) {}
          264  +
          265  +private:
          266  + kiStr v_name(const char*) const { return "GCA"; }
          267  +};
          268  +
          269  +//------------------------------------------------------------//
          270  +
          271  +class CArc7z : public CArcDLL_DotSlash
          272  +{
          273  +public:
          274  + CArc7z() : CArcDLL_DotSlash(
          275  +  "7-zip32.dll",
          276  +  "7z.zip.jar.",
          277  +  "x --",
          278  +  "x -y -hide --",
          279  +  1,
          280  +  "" ) {}
          281  +private:
          282  + kiStr v_name(const char* an) const { return dll.arctype(an)==1 ? "ZIP" : "7Z"; }
          283  + DWORD set_cmpr_mhd();
          284  + const char* get_cmpr_cmd( int method );
          285  + const char* get_cmpr_ext( int method );
          286  + virtual int v_compress( const kiPath& base, const wfdArray& files, const kiPath& ddir, int method, bool sfx );
          287  + bool m_SfxMode;
          288  +};
          289  +
          290  +//------------------------------------------------------------//
          291  +
          292  +class CArc7zZip : public CArcDLL_DotSlash
          293  +{
          294  +public:
          295  + CArc7zZip() : CArcDLL_DotSlash(
          296  +  "7-zip32.dll",
          297  +  "",NULL,NULL,1,"" ) {}
          298  +private:
          299  + DWORD set_cmpr_mhd();
          300  + const char* get_cmpr_cmd( int method );
          301  + virtual bool v_ver( kiStr& ){return false;}//CArc7z�ɔC����
          302  + virtual int v_compress( const kiPath& base, const wfdArray& files, const kiPath& ddir, int method, bool sfx );
          303  +};
          304  +
          305  +//------------------------------------------------------------//
          306  +
          307  +#endif

Added ArcMsc.cpp version [b142f0fccb14651d]

            1  +
            2  +#include "stdafx.h"
            3  +#include "ArcMsc.h"
            4  +#include "NoahApp.h"
            5  +
            6  +bool CArcMsc::header( kiFile& fp, unsigned long* siz, char* ext )
            7  +{
            8  + // �ǂݏo��
            9  + unsigned char p[14];
           10  + if( 14!=fp.read(p,14) )
           11  +  return false;
           12  +
           13  + // �w�b�_�\���FSZDD��'3A [ext3rd] [orisiz(dword)]
           14  + static const unsigned char head[9]={ 0x53,0x5A,0x44,0x44,0x88,0xF0,0x27,0x33,0x41 };//="SZDD��'3A";
           15  +
           16  + for( int i=0; i!=9; i++ )
           17  +  if( p[i]!=head[i] )
           18  +   return false;
           19  +
           20  + if( ext )
           21  +  *ext = (char)p[9];
           22  +
           23  + DWORD x = p[10]+(p[11]<<8)+(p[12]<<16)+(p[13]<<24);
           24  + if( siz )
           25  +  *siz=x;
           26  +
           27  + // �����I�ɁA16�{�Ƃ������k���͏o�Ȃ�
           28  + return (x <= fp.getSize()*16);
           29  +}
           30  +
           31  +void CArcMsc::filename( char* oname, const char* ol, char ext )
           32  +{
           33  + // �R�s�[
           34  + ki_strcpy( oname, ol );
           35  +
           36  + // �Ōオ '_' �Ȃ�����Ă����B
           37  + bool bIs_=false;
           38  + for( char* p=oname; *p; p=kiStr::next(p) )
           39  +  bIs_ = (*p=='_');
           40  + if( bIs_ )
           41  +  *(--p)='\0';
           42  +
           43  +
           44  + if( ext )
           45  + {
           46  +  // �g���q����
           47  +  *p++ = ext;
           48  +  *p   = '\0';
           49  + }
           50  + else
           51  + {
           52  +  // �g���q�����⊮
           53  +  const char* x = kiPath::ext(oname);
           54  +  if( ki_strlen(x)==2 )
           55  +  {
           56  +   ::CharLower(oname);
           57  +
           58  +     if( 0==ki_strcmp(x,"ex") )(*p++)='e';
           59  +   else if( 0==ki_strcmp(x,"co") )(*p++)='m';
           60  +   else if( 0==ki_strcmp(x,"sc") )(*p++)='r';
           61  +
           62  +   else if( 0==ki_strcmp(x,"dl") )(*p++)='l';
           63  +   else if( 0==ki_strcmp(x,"oc") )(*p++)='x';
           64  +   else if( 0==ki_strcmp(x,"dr") )(*p++)='v';
           65  +   else if( 0==ki_strcmp(x,"vx") )(*p++)='d';
           66  +   else if( 0==ki_strcmp(x,"38") )(*p++)='6';
           67  +   else if( 0==ki_strcmp(x,"sy") )(*p++)='s';
           68  +   else if( 0==ki_strcmp(x,"cp") )(*p++)='l';
           69  +   else if( 0==ki_strcmp(x,"li") )(*p++)='b';
           70  +   else if( 0==ki_strcmp(x,"tt") )(*p++)='f';
           71  +
           72  +   else if( 0==ki_strcmp(x,"ch") )(*p++)='m';
           73  +   else if( 0==ki_strcmp(x,"hl") )(*p++)='p';
           74  +   else if( 0==ki_strcmp(x,"cn") )(*p++)='t';
           75  +   else if( 0==ki_strcmp(x,"da") )(*p++)='t';
           76  +
           77  +   else if( 0==ki_strcmp(x,"tx") )(*p++)='t';
           78  +   else if( 0==ki_strcmp(x,"wr") )(*p++)='i';
           79  +   else if( 0==ki_strcmp(x,"wa") )(*p++)='v';
           80  +   else if( 0==ki_strcmp(x,"mi") )(*p++)='d';
           81  +   else if( 0==ki_strcmp(x,"rm") )(*p++)='i';
           82  +   else if( 0==ki_strcmp(x,"bm") )(*p++)='p';
           83  +   else if( 0==ki_strcmp(x,"rl") )(*p++)='e';
           84  +   else if( 0==ki_strcmp(x,"cu") )(*p++)='r';
           85  +   else if( 0==ki_strcmp(x,"do") )(*p++)='c';
           86  +   else if( 0==ki_strcmp(x,"ic") )(*p++)='o';
           87  +   else if( 0==ki_strcmp(x,"re") )(*p++)='g';
           88  +   else if( 0==ki_strcmp(x,"rt") )(*p++)='f';
           89  +   else if( 0==ki_strcmp(x,"ht") )(*p++)='m';
           90  +   else         (*p++)='#';
           91  +
           92  +   *p = '\0';
           93  +  }
           94  + }
           95  +}
           96  +
           97  +bool CArcMsc::v_check( const kiPath& aname )
           98  +{
           99  + kiFile fp;
          100  + if( fp.open( aname ) )
          101  +  return header( fp,NULL,NULL );
          102  + return false;
          103  +}
          104  +
          105  +bool CArcMsc::v_list( const arcname& aname, aflArray& files )
          106  +{
          107  + kiPath fname(aname.basedir); fname+=aname.lname;
          108  +
          109  + arcfile x;
          110  + kiFile fp;
          111  + char ext;
          112  + if( !fp.open( fname ) || !header( fp, &x.inf.dwOriginalSize, &ext ) )
          113  +  return false;
          114  + ki_strcpy( x.inf.szMode, "-msc-" );
          115  + filename( x.inf.szFileName, aname.lname, ext );
          116  + x.inf.dwCompressedSize = fp.getSize();
          117  + x.isfile = true;
          118  +
          119  + // TODO: �������ǂ�����H
          120  +
          121  + files.add( x );
          122  + return true;
          123  +}
          124  +
          125  +int CArcMsc::v_melt( const arcname& aname, const kiPath& ddir, const aflArray* files )
          126  +{
          127  + kiFile fp;
          128  + kiPath fname(aname.basedir); fname+=aname.lname;
          129  + kiPath oname(ddir);
          130  + char tmp[MAX_PATH];
          131  +
          132  + // �w�b�_�ǂݍ���
          133  + char ext;
          134  + unsigned long alllen;
          135  + if( !fp.open( fname ) || !header(fp,&alllen,&ext) )
          136  +  return 0xffff;
          137  + fp.close();
          138  + filename( tmp, aname.lname, ext );
          139  + oname += tmp;
          140  +
          141  + // ���ɁE�o�͐���J��
          142  + OFSTRUCT of;
          143  + of.cBytes = sizeof(of);
          144  + int FROM = ::LZOpenFile( const_cast<char*>((const char*)fname),&of,OF_READ );
          145  + int TO   = ::LZOpenFile( const_cast<char*>((const char*)oname),&of,OF_WRITE|OF_CREATE );
          146  + if( FROM<0 || TO<0 )
          147  +  return 0xffff;
          148  + // ��
          149  + bool ans = (0<=::LZCopy( FROM,TO ));
          150  + // �I��
          151  + ::LZClose( TO );
          152  + ::LZClose( FROM );
          153  + return ans?0:0xffff;
          154  +}
          155  +
          156  +int CArcMsc::v_compress( const kiPath& base, const wfdArray& files, const kiPath& ddir, int method, bool sfx )
          157  +{
          158  + ::SetCurrentDirectory( base );
          159  +
          160  + // ���t�@�C�����J��
          161  + kiFile in;
          162  + if( !in.open( files[0].cFileName ) )
          163  +  return 0xffff;
          164  +
          165  + // �w�b�_���E���k��t�@�C����
          166  + char h_Ext3 = '\0';
          167  + unsigned long h_Len = in.getSize();
          168  +
          169  + char aname[MAX_PATH];
          170  + ki_strcpy( aname, files[0].cFileName );
          171  + for( char *x=aname, *last=aname; *x; x=kiStr::next(x) )
          172  +  last = x;
          173  + if( !IsDBCSLeadByte(*last) )
          174  +  h_Ext3=*last;
          175  + *last = '_', *(last+1) = '\0';
          176  +
          177  + // ���k��J��
          178  + ::SetCurrentDirectory( ddir );
          179  +
          180  + // ���k����J��
          181  + kiFile out;
          182  + if( !out.open( aname, false ) )
          183  +  return 0xffff;
          184  +
          185  + // �^�C���X�^���v�R�s�[
          186  + FILETIME ct, at, mt;
          187  + ::GetFileTime(in.getHandle(), &ct, &at, &mt);
          188  + ::SetFileTime(out.getHandle(), &ct, &at, &mt);
          189  +
          190  + // �w�b�_��������
          191  + unsigned char head[14]={ 0x53,0x5A,0x44,0x44,0x88,0xF0,0x27,0x33,0x41,(unsigned char)h_Ext3,
          192  +        (unsigned char)(h_Len&0xff),(unsigned char)((h_Len>>8)&0xff),
          193  +        (unsigned char)((h_Len>>16)&0xff),(unsigned char)((h_Len>>24)&0xff) };
          194  + out.write( head, 14 );
          195  +
          196  + // ���k���
          197  + CArcProgressDlg dlg( h_Len, true );
          198  + dlg.change( files[0].cFileName );
          199  + if( !do_lzss( in, out, dlg ) )
          200  + {
          201  +  out.close();
          202  +  ::DeleteFile(aname);
          203  +  return 0x8020;
          204  + }
          205  + return 0;
          206  +}
          207  +
          208  +
          209  +//-- 12bit LZSS -----------------------------------------------//
          210  +
          211  +
          212  +#define N 4096 // slide���̃T�C�Y 2^12 bytes
          213  +#define F 18   // �Œ���v�� 2^(16-12)+2 bytes
          214  +
          215  +static unsigned char window[N+F-1];
          216  +static int dad[N+1], lson[N+1], rson[N+257];
          217  +static int matchpos, matchlen;
          218  +
          219  +static void init_tree()
          220  +{
          221  + //-- �؂�������
          222  +
          223  + int i;
          224  + for( i=N+1; i<=N+256; i++ ) // root: 0x00 -- 0xff
          225  +  rson[i] = N;
          226  + for( i=0; i<N ; i++ )
          227  +   dad[i] = N;
          228  +}
          229  +
          230  +static void insert_node( int r )
          231  +{
          232  + //-- [�ʒur]����n�܂�[��str]��؂ɓo�^
          233  + unsigned char* str = window + r;
          234  + rson[r] = lson[r] = N;
          235  +
          236  + //-- �‚��łɈ�v���E�ʒu���L�^����
          237  + matchlen = 2;
          238  +
          239  + // �ꕶ���ڂ�root��I��
          240  + int i, p = N+1+str[0], cmp=1;
          241  + for(; ;)
          242  + {
          243  +  if( cmp >= 0 )
          244  +  {
          245  +   // �E�ɐi��
          246  +   if( rson[p] != N )
          247  +    p = rson[p];
          248  +   // �E�ɂ͂���node���Ȃ��̂ł����ɓo�^���ďI��
          249  +   else
          250  +   {
          251  +    rson[p] = r;
          252  +     dad[r] = p;
          253  +    return;
          254  +   }
          255  +  }
          256  +  else
          257  +  {
          258  +   // ���ɐi��
          259  +   if( lson[p] != N )
          260  +    p = lson[p];
          261  +   // ���ɂ͂���node���Ȃ��̂ł����ɓo�^���ďI��
          262  +   else
          263  +   {
          264  +    lson[p] = r;
          265  +     dad[r] = p;
          266  +    return;
          267  +   }
          268  +  }
          269  +
          270  +  // ���݂�node��str���r( i==��v�� )
          271  +  for( i=1; i<F; i++ )
          272  +   if( cmp = str[i] - window[p+i] )
          273  +    break;
          274  +
          275  +  // ���܂Ō��‚������̂̒��ōŒ���������L��
          276  +  if( i > matchlen )
          277  +  {
          278  +   matchpos = p;
          279  +   if( (matchlen=i) == F )
          280  +    break;
          281  +  }
          282  + }
          283  +
          284  + // [�ʒup]�̗�ƒ���F�ň�v�����ꍇ�A�����ɗ���
          285  + // p �݂̍����Ƃ���� r �Œu��������
          286  +
          287  +  dad[r] =  dad[p];
          288  + lson[r] = lson[p];
          289  + rson[r] = rson[p];
          290  +  dad[lson[p]] = r;
          291  +  dad[rson[p]] = r;
          292  +
          293  + if( rson[dad[p]]==p )
          294  +  rson[dad[p]] = r;
          295  + else
          296  +  lson[dad[p]] = r;
          297  +
          298  + dad[p] = N;
          299  +}
          300  +
          301  +static void delete_node( int p )
          302  +{
          303  + //-- [�ʒup]�̗v�f��؂���폜
          304  +
          305  + if( dad[p] == N ) // ���ɖ؂ɓ����ĂȂ��̂ł����܂�
          306  +  return;
          307  +
          308  + int q;
          309  +
          310  + if( rson[p] == N )
          311  +  q = lson[p]; // �B��̎q����Ɏ����グ��
          312  + else if( lson[p] == N )
          313  +  q = rson[p]; // �B��̎q����Ɏ����グ��
          314  + else
          315  + {
          316  +  q = lson[p];
          317  +
          318  +  if( rson[q] != N )
          319  +  {
          320  +   // ���̎}�̍ʼnE�A�‚܂莩�����������node�������グ��
          321  +   do
          322  +    q = rson[q];
          323  +   while( rson[q] != N );
          324  +
          325  +   rson[dad[q]] = lson[q];
          326  +   dad[lson[q]] = dad[q];
          327  +   lson[q] = lson[p];
          328  +   dad[lson[p]] = q;
          329  +  }
          330  +  rson[q] = rson[p];
          331  +  dad[rson[p]] = q;
          332  + }
          333  +
          334  + dad[q] = dad[p];
          335  + if( rson[dad[p]] == p )
          336  +  rson[dad[p]] = q;
          337  + else
          338  +  lson[dad[p]] = q;
          339  + dad[p] = N;
          340  +}
          341  +
          342  +bool CArcMsc::do_lzss( kiFile& in, kiFile& out, CArcProgressDlg& dlg )
          343  +{
          344  + int i, c, len, r, s;
          345  + unsigned char code[17]={0}, mask=1, codeptr=1;
          346  +
          347  + s = 2;  // s = �f�[�^�Ǎ��ʒu
          348  + r = N - 16; // r = �؂ւ̑}���ʒu
          349  +
          350  + // �N���A
          351  + init_tree();
          352  + ki_memset( window+2, ' ', N-F );
          353  +
          354  + // �擪18bytes����
          355  + for( len=0 ; len<F ; len++ )
          356  + {
          357  +  if( -1 == (c = in.getc()) )
          358  +   break;
          359  +  window[r+len] = c;
          360  + }
          361  + window[0] = window[r+16];
          362  + window[1] = window[r+17];
          363  + if( len==0 )
          364  +  return true;
          365  +
          366  + // �؂֑}��
          367  + for( i=F ; i>=0 ; i-- )
          368  +  insert_node( r-i );
          369  +
          370  + // ���[�v
          371  + unsigned int total_read=18,prgr_read=0;
          372  +
          373  + do
          374  + {
          375  +  if( prgr_read > 5000 )
          376  +  {
          377  +   dlg.change( NULL, total_read+=prgr_read );
          378  +   prgr_read-=5000;
          379  +   if( !dlg.msgloop() )
          380  +   {
          381  +    prgr_read=0xffffffff;
          382  +    break;
          383  +   }
          384  +  }
          385  +
          386  +  if( matchlen > len )
          387  +   matchlen=len;
          388  +
          389  +  if( matchlen < 3 ) // ��v�Ȃ�
          390  +  {
          391  +   matchlen = 1;
          392  +   code[0] |= mask;
          393  +   code[codeptr++] = window[r];
          394  +  }
          395  +  else    // ��v����
          396  +  {
          397  +   // [pos&0xff] [pos&0xf00 | len-3]
          398  +   code[codeptr++] = (unsigned char)matchpos;
          399  +   code[codeptr++] = (unsigned char)(((matchpos>>4)&0xf0) | (matchlen-3));
          400  +  }
          401  +
          402  +  if( (mask<<=1)==0 ) // code �� 8Block �ɂȂ��Ă�����o��
          403  +  {
          404  +   out.write( code, codeptr );
          405  +   // �R�[�h�o�b�t�@������
          406  +   code[0] = 0;
          407  +   codeptr = mask = 1;
          408  +  }
          409  +
          410  +  // �o�͂������ǂݍ���
          411  +  int lastmatchlen = matchlen;
          412  +  for( i=0 ; i<lastmatchlen; i++ )
          413  +  {
          414  +   if( -1 == (c=in.getc()) )
          415  +    break;
          416  +   prgr_read++;
          417  +
          418  +   // [�ʒus]�Ɉꕶ����������
          419  +   delete_node( s );
          420  +   window[s] = c;
          421  +   if( s < F-1 ) window[ N+s ] = c;
          422  +
          423  +   s = (s+1) & (N-1); // s++
          424  +   r = (r+1) & (N-1); // r++
          425  +
          426  +   // �؂�[�ʒur]�̃f�[�^��}��
          427  +   insert_node( r );
          428  +  }
          429  +
          430  +  // EOF�㏈��
          431  +  while( i++ < lastmatchlen )
          432  +  {
          433  +   delete_node( s );
          434  +   s = (s+1) & (N-1); // s++
          435  +   r = (r+1) & (N-1); // r++
          436  +   if( --len )
          437  +    insert_node( r );
          438  +  }
          439  +
          440  + } while( len > 0 );
          441  +
          442  + if( prgr_read==0xffffffff )
          443  +  return false;
          444  +
          445  + // 8block���E�ɑ�����
          446  + if( mask != 1 )
          447  + {
          448  +  while( mask<<=1 )
          449  +   code[codeptr++] = 0;
          450  +  out.write( code, codeptr );
          451  + }
          452  +
          453  + return true;
          454  +}
          455  +

Added ArcMsc.h version [3dbc15b093e50358]

            1  +#ifndef AFX_ARCMSC_H__1891072B_44D7_4577_AF05_6D221A2FD0DD__INCLUDED_
            2  +#define AFX_ARCMSC_H__1891072B_44D7_4577_AF05_6D221A2FD0DD__INCLUDED_
            3  +
            4  +#include "Archiver.h"
            5  +#include "SubDlg.h"
            6  +
            7  +class CArcMsc : public CArchiver
            8  +{
            9  +public:
           10  + CArcMsc() : CArchiver("") {}
           11  +
           12  +private:
           13  + int v_load()
           14  +  {
           15  +   set_cmp_ext( "??_" ), add_cmp_mhd( "MSCompress" );
           16  +   return aCheck|aMelt|aList|aMeltEach|aCompress;
           17  +  }
           18  + int  v_contents( const kiPath& aname, kiPath& dnam ){return aSingleFile;}
           19  +
           20  + bool v_check( const kiPath& aname );
           21  + int  v_melt( const arcname& aname, const kiPath& ddir, const aflArray* files );
           22  + bool v_list( const arcname& aname, aflArray& files );
           23  + int  v_compress( const kiPath& base, const wfdArray& files, const kiPath& ddir, int method, bool sfx );
           24  + kiStr v_name(const char*) const { return "MSCompress"; }
           25  +
           26  +private:
           27  + bool header( kiFile& fp, unsigned long* siz, char* ext );
           28  + void filename( char* oname, const char* ol, char ext );
           29  + bool do_lzss( kiFile& in, kiFile& out, CArcProgressDlg& dlg );
           30  +};
           31  +
           32  +#endif

Added Archiver.cpp version [10de0296b1be04cd]

            1  +// Archiver.cpp
            2  +//-- CArchiver -- common interface in 'Noah' for archiving routine --
            3  +
            4  +#include "stdafx.h"
            5  +#include "Archiver.h"
            6  +#include "NoahApp.h"
            7  +
            8  +
            9  +
           10  +CArcModule::CArcModule( const char* name, bool us )
           11  + : m_dll(NULL)
           12  +{
           13  + // SearchPath�̑O�ɃJ�����g�f�B���N�g����noah.exe�Ɠ����ꏊ��
           14  + char prev_cur[MAX_PATH];
           15  + ::GetCurrentDirectory(MAX_PATH, prev_cur);
           16  + kiSUtil::switchCurDirToExeDir();
           17  +
           18  + if( 0!=::SearchPath( NULL,name,NULL,MAX_PATH,m_name,NULL ) )
           19  + {
           20  +  const char* xt=kiPath::ext(name);
           21  +  if( 0!=ki_strcmpi("dll",xt) )
           22  +  {
           23  +   // EXE�̏ꍇ
           24  +   m_type = us ? EXEUS : EXE;
           25  +  }
           26  +  else
           27  +  {
           28  +   // DLL�̏ꍇ
           29  +   m_dll = new kiArcDLLRaw(name);
           30  +   m_type = DLL;
           31  +   if(name<=xt-8&&xt[-6]=='G'&&xt[-5]=='C'&&xt[-4]=='A' )
           32  +    m_type = DLLGCA;
           33  +   else if(name==xt-6&&xt[-6]=='B'&&xt[-5]=='g'&&xt[-4]=='a' )
           34  +    m_type = DLLBGA;
           35  +  }
           36  + }
           37  + else
           38  + {
           39  +  // �t�@�C�����������A�V�F���̃R�}���h�̏ꍇ
           40  +  // �o�b�t�@�I�[�o�[�t���[�̊댯�c(^^;
           41  +  ki_strcpy( m_name, name );
           42  +  m_type = SHLCMD;
           43  + }
           44  +
           45  + // �J�����g��߂�
           46  + ::SetCurrentDirectory(prev_cur);
           47  +}
           48  +
           49  +CArcModule::~CArcModule()
           50  +{
           51  + delete m_dll;
           52  +}
           53  +
           54  +int CArcModule::cmd( const char* cmd, bool mini )
           55  +{
           56  + if( m_dll )
           57  + {
           58  +  // �A�[�J�C�oDLL���[�h�Ȃ�ȒP�ɏI��
           59  +  char buf[1024];
           60  +  return m_dll->command( NULL, cmd, buf, sizeof(buf) );
           61  + }
           62  +
           63  + // NT���ǂ����̃`�F�b�N��
           64  + kiPath tmpdir;
           65  + static const bool isNT =
           66  +  (app()->osver().dwPlatformId==VER_PLATFORM_WIN32_NT);
           67  + static const char* const closeShell =
           68  +  (isNT ? "cmd.exe /c " : "command.com /c ");
           69  +
           70  + // �R�}���h������쐬
           71  + kiVar theCmd( m_name );
           72  + theCmd.quote();
           73  + theCmd += ' ';
           74  + theCmd += cmd;
           75  +
           76  + if( m_type==SHLCMD )
           77  + {
           78  +  // �V�F���R�}���h�̏ꍇ
           79  +  theCmd = closeShell + theCmd;
           80  + }
           81  + else if( m_type==EXEUS )
           82  + {
           83  +  // US���[�h�̏ꍇ
           84  +  if( isNT )
           85  +  {
           86  +   ::SetEnvironmentVariable( "NOAHCMD", theCmd );
           87  +   theCmd = "%NOAHCMD%";
           88  +  }
           89  +
           90  +  // �ؑփo�b�`�t�@�C������
           91  +  myapp().get_tempdir(tmpdir);
           92  +  kiPath batname(tmpdir);
           93  +  batname += "ncmd.bat";
           94  +  kiFile bat;
           95  +  bat.open( batname,false );
           96  +  bat.write( "@CHCP 437\r\n@", 12 );
           97  +  bat.write( theCmd, theCmd.len() );
           98  +  bat.write( "\r\n@CHCP 932\r\n", 13 );
           99  +
          100  +  theCmd  = closeShell;
          101  +  theCmd += batname;
          102  + }
          103  +
          104  + // �v���Z�X�J�n
          105  + PROCESS_INFORMATION pi;
          106  + STARTUPINFO si={sizeof(STARTUPINFO)};
          107  + si.dwFlags    =STARTF_USESHOWWINDOW;
          108  + si.wShowWindow=mini?SW_MINIMIZE:SW_SHOW;
          109  + if( !::CreateProcess( NULL,const_cast<char*>((const char*)theCmd),
          110  +  NULL,NULL,FALSE,CREATE_NEW_PROCESS_GROUP|NORMAL_PRIORITY_CLASS,
          111  +  NULL,NULL, &si,&pi ) )
          112  +  return 0xffff;
          113  +
          114  + // �I���ҋ@
          115  + ::CloseHandle( pi.hThread );
          116  + while( WAIT_OBJECT_0 != ::WaitForSingleObject( pi.hProcess, 500 ) )
          117  +  kiWindow::msg();
          118  + int ex;
          119  + ::GetExitCodeProcess( pi.hProcess, (DWORD*)&ex );
          120  + ::CloseHandle( pi.hProcess );
          121  +
          122  + // ��n��
          123  + if( m_type==EXEUS )
          124  +  tmpdir.remove();
          125  + return ex;
          126  +}
          127  +
          128  +void CArcModule::ver( kiStr& str )
          129  +{
          130  + // �o�[�W�������𐮌`���ĕ\��
          131  + char *verstr="----", buf[200];
          132  + if( m_dll )
          133  + {
          134  +  if( WORD ver=m_dll->getVer() )
          135  +  {
          136  +   WORD sub=m_dll->getVerSub();
          137  +   ::wsprintf( verstr=buf, "%d.%02d%c", ver/100, ver%100, (sub<100)?0:sub/100+'a'-1 );
          138  +  }
          139  + }
          140  + else if( m_type != NOTEXIST )
          141  + {
          142  +  // �”\�Ȃ烊�\�[�X����̎擾�����݂�
          143  +  if( CArchiver::GetVersionInfoStr( m_name, buf, sizeof(buf) ) )
          144  +   verstr = buf;
          145  +  else
          146  +   verstr = "OK!";
          147  + }
          148  +
          149  + char ans[300];
          150  + ::wsprintf( ans, "%-12s %s", kiPath::name(m_name), verstr );
          151  + str = ans;
          152  +}
          153  +
          154  +bool CArcModule::lst_dll( const arcname& aname, aflArray& files, const char* wild )
          155  +{
          156  + if( !m_dll )
          157  +  return false;
          158  + kiPath nm(aname.basedir); nm+=aname.lname;
          159  + HANDLE h = m_dll->openArc( app()->mainhwnd(), nm, M_CHECK_FILENAME_ONLY|M_ERROR_MESSAGE_OFF );
          160  + if( !h ) return false;
          161  +
          162  + int ct=0;
          163  + files.forcelen( 1 );
          164  + if( 0==m_dll->findfirst( h, wild, &files[0].inf ) )
          165  + {
          166  +  do
          167  +  {
          168  +   INDIVIDUALINFO& iii = files[ct].inf;
          169  +   files[ct].isfile =
          170  +     ( *files[ct].inf.szAttribute!='d'
          171  +    && !kiPath::endwithyen(files[ct].inf.szFileName)
          172  +    && !(m_dll->getAttr( h )&FILE_ATTRIBUTE_DIRECTORY) );
          173  +   files.forcelen( 1+(++ct) );
          174  +  } while( 0==m_dll->findnext( h, &files[ct].inf ) );
          175  + }
          176  + files.forcelen( ct );
          177  +
          178  + m_dll->closeArc( h );
          179  + return true;
          180  +}
          181  +
          182  +int CArcModule::cnt( const kiPath& aname, kiPath& dname, const char* wild )
          183  +{
          184  + int ans = aUnknown;
          185  +
          186  + if( m_dll )
          187  +  if( HANDLE h = m_dll->openArc( app()->mainhwnd(), aname, M_CHECK_FILENAME_ONLY|M_ERROR_MESSAGE_OFF ) )
          188  +  {
          189  +   INDIVIDUALINFO inf1st, inf;
          190  +   if( 0==m_dll->findfirst( h, wild, &inf1st ) )
          191  +   {
          192  +    for( const char* y=inf1st.szFileName; *y && *y!='\\' && *y!='/'; y=kiPath::next(y) );
          193  +    if( y!=inf1st.szFileName )
          194  +    {
          195  +     if( 0!=m_dll->findnext( h, &inf ) )
          196  +      ans = *y ? aSingleDir : aSingleFile;
          197  +     else if( *y && (y-inf1st.szFileName!=1 || inf1st.szFileName[0]!='.') )
          198  +     {
          199  +      ans = aSingleDir;
          200  +      do
          201  +       if( !ki_memcmp( inf1st.szFileName, inf.szFileName, (y-inf1st.szFileName)+1 ) )
          202  +       {
          203  +        ans = aUnknown;
          204  +        break;
          205  +       }
          206  +      while( 0==m_dll->findnext( h, &inf ) );
          207  +     }
          208  +     if( ans==aSingleDir )
          209  +      inf1st.szFileName[y-inf1st.szFileName]='\0', dname+=inf1st.szFileName;
          210  +    }
          211  +   }
          212  +   m_dll->closeArc( h );
          213  +  }
          214  +
          215  + return ans;
          216  +}
          217  +
          218  +bool CArcModule::lst_exe( const char* lstcmd, aflArray& files,
          219  + const char* BL, int BSL, const char* EL, int SL, int dx )
          220  + // BeginLine, BeginSkipLine, EndLine, SkipLine, delta-x
          221  +{
          222  + files.forcelen(0);
          223  +
          224  + // ��ƕϐ�
          225  + const int BLLEN = ki_strlen(BL);
          226  + const int ELLEN = ki_strlen(EL);
          227  + int /*ct=0,*/ step=BSL;
          228  +
          229  + // EXE�ȊO�̂��̂ł̓_��
          230  + if( m_type!=EXE && m_type!=EXEUS )
          231  +  return false;
          232  +
          233  + // �R�}���h������쐬
          234  + kiVar theCmd( m_name );
          235  + theCmd.quote();
          236  + theCmd += ' ';
          237  + theCmd += lstcmd;
          238  +
          239  + // �p�C�v�쐬�i�����Ƃ��p��ON�BDupHan����̖ʓ|���̂Łc(^^;�j
          240  + HANDLE rp, wp;
          241  + SECURITY_ATTRIBUTES sa = {sizeof(SECURITY_ATTRIBUTES),NULL,TRUE};
          242  + ::CreatePipe( &rp, &wp, &sa, 4096 );
          243  +
          244  + // �v���Z�X�J�n
          245  + PROCESS_INFORMATION pi;
          246  + STARTUPINFO si = {sizeof(STARTUPINFO)};
          247  + si.dwFlags     = STARTF_USESHOWWINDOW|STARTF_USESTDHANDLES;
          248  + si.wShowWindow = SW_MINIMIZE;
          249  + si.hStdOutput  = si.hStdError = wp;
          250  + BOOL ok =
          251  +  ::CreateProcess( NULL,const_cast<char*>((const char*)theCmd),NULL,
          252  +   NULL, TRUE, CREATE_NEW_PROCESS_GROUP|NORMAL_PRIORITY_CLASS,
          253  +   NULL, NULL, &si,&pi );
          254  + ::CloseHandle( wp );
          255  +
          256  + // ���s������p�C�v��‚��đ��I��
          257  + if( !ok )
          258  + {
          259  +  ::CloseHandle( rp );
          260  +  return false;
          261  + }
          262  + ::CloseHandle( pi.hThread );
          263  +
          264  + // ��͍��etc(�o�b�t�@�̃T�C�Y�̓p�C�v�̃T�C�Y�̔{�ȏ�łȂ��Ă͂Ȃ�Ȃ�)
          265  + char buf[8192], *end=buf;
          266  + for( bool endpr=false; !endpr; )
          267  + {
          268  +  // �I���ҋ@
          269  +  endpr = (WAIT_OBJECT_0==::WaitForSingleObject(pi.hProcess,500));
          270  +  kiWindow::msg();
          271  +
          272  +  // �p�C�v����ǂ݂Ƃ�
          273  +  DWORD red;
          274  +  ::PeekNamedPipe( rp, NULL, 0, NULL, &red, NULL );
          275  +  if( red==0 )
          276  +   continue;
          277  +  ::ReadFile( rp, end, buf+sizeof(buf)-end, &red, NULL );
          278  +  end += red;
          279  +
          280  +  // �s�ɕ���
          281  +  char *lss=buf;
          282  +  for( char *ls, *le=buf; le<end; ++le )
          283  +  {
          284  +   // �s����T��
          285  +   for( lss=ls=le; le<end; ++le )
          286  +    if( *le=='\n' )
          287  +     break;
          288  +   if( le==end )
          289  +    break;
          290  +
          291  +   // �擪�s�X�L�b�v����
          292  +   if( *BL )
          293  +   {
          294  +    if( BLLEN<=le-ls && ki_memcmp(BL,ls,BLLEN) )
          295  +     BL = "";
          296  +   }
          297  +   // �s�X�e�b�v����
          298  +   else if( --step<=0 )
          299  +   {
          300  +    step = SL;
          301  +
          302  +    // �I�[�s����
          303  +    if( ELLEN==0 )
          304  +     { if( le-ls<=1 ) break; }
          305  +    else if( ELLEN<=le-ls && ki_memcmp(EL,ls,ELLEN) )
          306  +     break;
          307  +
          308  +    // �����X�L�b�v����
          309  +    if( dx>=0 )
          310  +     ls += dx;
          311  +    // �����u���b�N�X�L�b�v����
          312  +    else
          313  +    {
          314  +     for( ;ls<le;++ls )
          315  +      if( *ls!=' ' && *ls!='\t' && *ls!='\r' )
          316  +       break;
          317  +     for( int t=dx; ++t; )
          318  +     {
          319  +      for( ;ls<le;++ls )
          320  +       if( *ls==' ' || *ls=='\t' && *ls=='\r' )
          321  +        break;
          322  +      for( ;ls<le;++ls )
          323  +       if( *ls!=' ' && *ls!='\t' && *ls!='\r' )
          324  +        break;
          325  +     }
          326  +    }
          327  +    // �t�@�C�����R�s�[
          328  +    if( ls<le )
          329  +    {
          330  +     arcfile af; ki_memzero(&af, sizeof(af));
          331  +     af.inf.dwOriginalSize = 0xffffffff;
          332  +//     ki_memzero( &files[ct].inf, sizeof(files[ct].inf) );
          333  +//     files[ct].inf.dwOriginalSize = 0xffffffff;
          334  +
          335  +     int i=0;
          336  +     bool prev_is_space=false;
          337  +     while( i<FNAME_MAX32 && ls<le )
          338  +     {
          339  +      if( *ls==' ' )
          340  +      {
          341  +       if( prev_is_space )
          342  +        break;
          343  +       prev_is_space = true;
          344  +      }
          345  +      else if( *ls=='\t' || *ls=='\r' )
          346  +       break;
          347  +      else
          348  +       prev_is_space = false;
          349  +
          350  +      af.inf.szFileName[i++] = *ls++;
          351  +//      files[ct].inf.szFileName[i++] = *ls++;
          352  +     }
          353  +     if( prev_is_space )
          354  +      --i;
          355  +     if( i )
          356  +     {
          357  +/*
          358  +      files[ct].inf.szFileName[i] = '\0';
          359  +      files[ct].isfile = true;
          360  +      files.forcelen( 1+(++ct) );
          361  +*/
          362  +      af.inf.szFileName[i] = '\0';
          363  +      af.isfile = true;
          364  +      files.add(af);
          365  +     }
          366  +    }
          367  +   }
          368  +  }
          369  +  // �o�b�t�@�V�t�g
          370  +  if( lss != buf )
          371  +   ki_memmov( buf, lss, end-lss ), end=buf+(end-lss);
          372  +  else if( end==buf+sizeof(buf) )
          373  +   end = buf;
          374  + }
          375  +
          376  + // ���I��
          377  + ::CloseHandle( pi.hProcess );
          378  + ::CloseHandle( rp );
          379  + return true;
          380  +}
          381  +
          382  +/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
          383  +// �o�[�W������񃊃\�[�X�擾
          384  +
          385  +bool CArchiver::GetVersionInfoStr( char* name, char* buf, size_t cbBuf )
          386  +{
          387  + static bool old = mycnf().oldver();
          388  + if( old )
          389  +  return false;
          390  +
          391  + DWORD dummy = 0;
          392  + DWORD siz = ::GetFileVersionInfoSize( name, &dummy );
          393  + if( siz == 0 )
          394  +  return false;
          395  +
          396  + bool got = false;
          397  + BYTE* vbuf = new BYTE[siz];
          398  + if( 0 != ::GetFileVersionInfo( name, 0, siz, vbuf ) )
          399  + {
          400  +  WORD* tr = NULL;
          401  +  UINT cbTr = 0;
          402  +
          403  +  // �ŏ��Ɍ��‚�������ƃR�[�h�y�[�W�ŏ��擾
          404  +  if( ::VerQueryValue( vbuf,
          405  +   "\\VarFileInfo\\Translation", (void**)&tr, &cbTr )
          406  +   && cbTr >= 4 )
          407  +  {
          408  +   char blockname[500]="";
          409  +   ::wsprintf( blockname,
          410  +    "\\StringFileInfo\\%04x%04x\\ProductVersion",
          411  +    tr[0], tr[1] );
          412  +
          413  +   char* inf = NULL;
          414  +   UINT cbInf = 0;
          415  +   if( ::VerQueryValue( vbuf, blockname, (void**)&inf, &cbInf )
          416  +    && cbInf < cbBuf-1 )
          417  +   {
          418  +    for( char* v=buf; *inf && cbInf; ++inf,--cbInf )
          419  +     if( *inf != ' ' )
          420  +      *v++ = (*inf==',' ? '.' : *inf);
          421  +    *v = '\0';
          422  +    got = true;
          423  +   }
          424  +  }
          425  +  else
          426  +  {
          427  +   void* fi = NULL;
          428  +   UINT cbFi = 0;
          429  +   VS_FIXEDFILEINFO vffi;
          430  +   if( ::VerQueryValue( vbuf, "\\", &fi, &cbFi )
          431  +    && sizeof(vffi)<=cbFi )
          432  +   {
          433  +    ki_memcpy( &vffi, fi, sizeof(vffi) );
          434  +    if( vffi.dwFileVersionLS >= 0x10000 )
          435  +     ::wsprintf( buf, "%d.%d.%d", vffi.dwFileVersionMS>>16,
          436  +      vffi.dwFileVersionMS&0xffff, vffi.dwFileVersionLS>>16 );
          437  +    else
          438  +     ::wsprintf( buf, "%d.%d", vffi.dwFileVersionMS>>16,
          439  +      vffi.dwFileVersionMS&0xffff );
          440  +    got = true;
          441  +   }
          442  +  }
          443  + }
          444  +
          445  + delete [] vbuf;
          446  + return got;
          447  +}

Added Archiver.h version [6f288846948232f7]

            1  +// Archiver.h
            2  +//-- CArchiver -- common interface in 'Noah' for arhiving routine --
            3  +
            4  +#ifndef AFX_ARCHIVER_H__359A2ED3_2F97_480E_BC94_24834EBA6498__INCLUDED_
            5  +#define AFX_ARCHIVER_H__359A2ED3_2F97_480E_BC94_24834EBA6498__INCLUDED_
            6  +
            7  +enum {
            8  + aCheck = 1, aMelt = 2, aList = 4, aMeltEach = 8, aCompress = 16, aArchive = 32, aSfx = 64,
            9  +};
           10  +enum {
           11  + aUnknown=0, aSingleFile, aSingleDir, aMulti
           12  +};
           13  +
           14  +struct arcname {
           15  + arcname( const kiPath& b,const char *s,const char *l )
           16  +  : basedir(b),sname(s),lname(l) {}
           17  + const kiPath& basedir;
           18  + const char*   lname;
           19  + const char*   sname;
           20  +};
           21  +
           22  +struct arcfile {
           23  + INDIVIDUALINFO inf;
           24  + union {
           25  +  bool selected;
           26  +  bool isfile;
           27  + };
           28  +};
           29  +
           30  +#define aflArray kiArray<arcfile>
           31  +#define wfdArray kiArray<WIN32_FIND_DATA>
           32  +
           33  +class CArchiver
           34  +{
           35  +public: //--< attribute >--
           36  +
           37  + int ability();
           38  + int cancompressby( const char* ext, const char* mhd, bool sfx );
           39  +
           40  + const char*     mlt_ext();
           41  + const kiStr&    cmp_ext();
           42  + const StrArray& cmp_mhd_list();
           43  + const int       cmp_mhd_default();
           44  + bool            ver( kiStr& str );
           45  + static bool GetVersionInfoStr( char* name, char* buf, size_t cbBuf );
           46  +
           47  +public: //--< action >--
           48  +
           49  + bool check( const kiPath& aname );
           50  + int  contents( const kiPath& aname, kiPath& dname );
           51  + int  melt( const arcname& aname, const kiPath& ddir, const aflArray* files=NULL );
           52  + bool list( const arcname& aname, aflArray& files );
           53  + int  compress( const kiPath& base, const wfdArray& files, const kiPath& ddir, int method, bool sfx );
           54  + kiStr arctype_name(const char* an) const { return v_name(an); }
           55  +
           56  +protected: //--< for child >--
           57  +
           58  + CArchiver( const char* mext );
           59  + void set_cmp_ext( const char* ext );
           60  + void add_cmp_mhd( const char* mhd, bool def=false );
           61  +
           62  + virtual int  v_load(){return 0;}
           63  + virtual bool v_ver( kiStr& str ){return false;}
           64  + virtual bool v_check( const kiPath& aname ){return false;}
           65  + virtual int  v_contents( const kiPath& aname, kiPath& dname ){return aUnknown;}
           66  + virtual int  v_melt( const arcname& aname, const kiPath& ddir, const aflArray* files ){return false;}
           67  + virtual bool v_list( const arcname& aname, aflArray& files ){return false;}
           68  + virtual int  v_compress( const kiPath& base, const wfdArray& files, const kiPath& ddir, int method, bool sfx ){return false;}
           69  + virtual kiStr v_name(const char*) const { return ""; }
           70  +
           71  +private: //--< private >--
           72  +
           73  + friend class CNoahArchiverManager;
           74  + bool extCheck( const char* ext );
           75  + kiStr m_MyExtList, m_MyCmpExt;
           76  + StrArray m_Mhd;
           77  + int m_MhdDef,m_Able;
           78  + bool not_loaded;
           79  +
           80  +public: //--< dummy >--
           81  +
           82  + virtual ~CArchiver(){}
           83  +};
           84  +
           85  +inline int CArchiver::ability()
           86  +{
           87  + if( not_loaded )
           88  +  m_Able=v_load(), not_loaded=false;
           89  + return m_Able;
           90  +}
           91  +
           92  +inline int CArchiver::cancompressby( const char* ext, const char* mhd, bool sfx )
           93  +{
           94  + if( not_loaded )
           95  +  m_Able=v_load(), not_loaded=false;
           96  + if( (sfx && !(m_Able&aSfx)) || !(m_Able&aCompress) || !m_MyCmpExt.isSame(ext) )
           97  +  return -1; // no
           98  + for( unsigned int i=0; i!=m_Mhd.len(); i++ )
           99  +  if( m_Mhd[i] == mhd )
          100  +   return (int)i;
          101  + return -2; // only - 'type name' matched
          102  +}
          103  +
          104  +inline bool CArchiver::check( const kiPath& aname )
          105  +{
          106  + if( not_loaded )
          107  +  m_Able=v_load(), not_loaded=false;
          108  + return (m_Able&aCheck)?v_check(aname):false;
          109  +}
          110  +
          111  +inline int CArchiver::contents( const kiPath& aname, kiPath& dname )
          112  +{
          113  + if( not_loaded )
          114  +  m_Able=v_load(), not_loaded=false;
          115  + return (m_Able&aList)?v_contents(aname,dname):false;
          116  +}
          117  +
          118  +inline int CArchiver::melt( const arcname& aname, const kiPath& ddir, const aflArray* files )
          119  +{
          120  + if( not_loaded )
          121  +  m_Able=v_load(), not_loaded=false;
          122  + return (m_Able&aMelt)?v_melt(aname,ddir,files):0xffff;
          123  +}
          124  +
          125  +inline bool CArchiver::list( const arcname& aname, aflArray& files )
          126  +{
          127  + if( not_loaded )
          128  +  m_Able=v_load(), not_loaded=false;
          129  + return (m_Able&aList)?v_list(aname,files):false;
          130  +}
          131  +
          132  +inline int CArchiver::compress( const kiPath& base, const wfdArray& files, const kiPath& ddir, int method, bool sfx )
          133  +{
          134  + if( not_loaded )
          135  +  m_Able=v_load(), not_loaded=false;
          136  + return (m_Able&aCompress)?v_compress(base,files,ddir,method,sfx):0xffff;
          137  +}
          138  +
          139  +inline bool CArchiver::ver( kiStr& str )
          140  +{
          141  + if( not_loaded )
          142  +  m_Able=v_load(), not_loaded=false;
          143  + return v_ver(str);
          144  +}
          145  +
          146  +inline const char* CArchiver::mlt_ext()
          147  +{
          148  + return m_MyExtList;
          149  +}
          150  +
          151  +inline const kiStr& CArchiver::cmp_ext()
          152  +{
          153  + if( not_loaded )
          154  +  m_Able=v_load(), not_loaded=false;
          155  + return m_MyCmpExt;
          156  +}
          157  +
          158  +inline const StrArray& CArchiver::cmp_mhd_list()
          159  +{
          160  + if( not_loaded )
          161  +  m_Able=v_load(), not_loaded=false;
          162  + return m_Mhd;
          163  +}
          164  +
          165  +inline const int CArchiver::cmp_mhd_default()
          166  +{
          167  + if( not_loaded )
          168  +  m_Able=v_load(), not_loaded=false;
          169  + return m_MhdDef;
          170  +}
          171  +
          172  +inline CArchiver::CArchiver( const char* extlist )
          173  +  : m_MyExtList( extlist ), m_Mhd(3), m_MhdDef(0), not_loaded(true)
          174  +{
          175  + m_MyExtList.lower();
          176  +}
          177  +
          178  +inline void CArchiver::set_cmp_ext( const char* ext )
          179  +{
          180  + m_MyCmpExt = ext;
          181  +}
          182  +
          183  +inline void CArchiver::add_cmp_mhd( const char* method, bool Default )
          184  +{
          185  + m_Mhd.add(method);
          186  + if( Default )
          187  +  m_MhdDef = m_Mhd.len() - 1;
          188  +}
          189  +
          190  +inline bool CArchiver::extCheck( const char* ext )
          191  +{
          192  + const char *x=m_MyExtList,*y;
          193  + int ln = ki_strlen(ext);
          194  + while( *x )
          195  + {
          196  +  for( y=x+1; *y && *y!='.'; y++ );
          197  +  if( *y=='\0' ) break;
          198  +
          199  +  if( y-x == ln )
          200  +  {
          201  +   while( x!=y )
          202  +   {
          203  +    if( *x!=ext[ln+(x-y)] )
          204  +     break;
          205  +    x++;
          206  +   }
          207  +   if( x==y )
          208  +    return true;
          209  +  }
          210  +  x=y+1;
          211  + }
          212  + return false;
          213  +}
          214  +
          215  +// �n���ꂽ�p�X�����񂪁A��΃p�X��".."���܂�ł����true
          216  +static bool containsDangerPath( const char* path )
          217  +{
          218  + // ��΃p�X
          219  + if( path[0]=='\\' || path[0]=='/' || path[0]!='\0' && path[1]==':' )
          220  +  return true;
          221  +
          222  + // ".."
          223  + for( const char* p=path; *p; )
          224  + {
          225  +  const char* q = p;
          226  +  while( *q!='\0' && *q!='\\' && *q!='/' )
          227  +   q = ::CharNext(q);
          228  +
          229  +  if( p+2 <= q )
          230  +  {
          231  +   const char* r;
          232  +   for( r=p; r!=q; ++r )
          233  +    if( *r != '.' )
          234  +     break;
          235  +   if( r == q ) // all dot
          236  +    return true;
          237  +  }
          238  +  p = (*q ? ::CharNext(q) : q);
          239  + }
          240  + return false;
          241  +}
          242  +
          243  +/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
          244  +// �����A�[�J�C�oDLL���C�����w ver2�B�‚��ł�exe���K���ɓ���
          245  +
          246  +class CArcModule
          247  +{
          248  +public:
          249  +
          250  + // ���s�R�}���h�����w�肵�č쐬
          251  + //  �E�t�@�C�����Ƃ��ĒT���Č��‚���Ȃ������ꍇ
          252  + //    �V�F���̓����R�}���h�Ɖ��肵�Ĉꉞ�ێ����Ă���
          253  + //  �E�g���q�� exe �� com �Ȃ���s�t�@�C���Ƃ��Ĉ����B
          254  + //  �E����ȊO�Ȃ�A�[�J�C�oDLL�Ƃ��Ĉ����B
          255  + CArcModule( const char* name, bool us=false );
          256  + virtual ~CArcModule();
          257  + bool exist();
          258  + bool isdll();
          259  +
          260  + kiStr name() const { return kiPath::name(m_name); }
          261  +
          262  + // ���s
          263  + int cmd( const char* cmd, bool mini=false );
          264  +
          265  + // ���Ƀ`�F�b�N
          266  + bool chk( const char* aname );
          267  + int  arctype( const char* aname ) const;
          268  +
          269  + // �o�[�W������񕶎����Ԃ�
          270  + void ver( kiStr& str );
          271  +
          272  + // ���ɂ̒��g�����X�g�A�b�v
          273  + bool lst_dll( const arcname& aname, aflArray& files, const char* wild="*" );
          274  + int  cnt( const kiPath& aname, kiPath& dname, const char* wild="*" );
          275  + bool lst_exe( const char* lstcmd, aflArray& files,
          276  +  const char* BL, int BSL, const char* EL, int SL, int dx );
          277  +
          278  + // DLL�����A�����[�h( BugTrap for UnZip32.dll )
          279  + void unload() { m_dll->unload(); }
          280  + // DLL�I�[�i�[���ݒ�( BugTrap for Unrar.dll )
          281  + void own( HWND wnd ) { m_dll->setOwner( wnd ); }
          282  + void fre() { m_dll->clearOwner(); }
          283  +
          284  +private:
          285  + enum { NOTEXIST, DLL, DLLGCA, DLLBGA, EXE, EXEUS, SHLCMD=0 } m_type;
          286  + kiArcDLLRaw* m_dll;
          287  + char         m_name[MAX_PATH];
          288  + const char*  m_wild;
          289  +};
          290  +
          291  +inline bool CArcModule::chk( const char* aname )
          292  + { return m_dll ? FALSE!=m_dll->check( aname, m_type==DLLGCA?24:0 ) : false; }
          293  +
          294  +inline int CArcModule::arctype( const char* aname ) const
          295  + { return m_dll ?
          296  +  m_type==DLLBGA ? m_dll->check(aname,0) : m_dll->getArcType(aname)
          297  +   : 0; }
          298  +
          299  +inline bool CArcModule::exist()
          300  + { return m_type!=NOTEXIST; }
          301  +
          302  +inline bool CArcModule::isdll()
          303  + { return m_type==DLL || m_type==DLLGCA; }
          304  +
          305  +
          306  +
          307  +#endif

Added Noah.cpp version [a3b52f0446b0f2d0]

            1  +// Noah.cpp
            2  +// -- entrypoint etc for 'Noah'
            3  +
            4  +#include "stdafx.h"
            5  +#include "NoahApp.h"
            6  +#include "resource.h"
            7  +
            8  +#if _MSC_VER >= 1300
            9  +extern "C" { int _afxForceEXCLUDE; }
           10  +extern "C" BOOL WINAPI _imp__IsDebuggerPresent() { return FALSE; }
           11  +#endif
           12  +
           13  +// �v���Z�X�������]�[��
           14  +class ProcessNumLimitZone
           15  +{
           16  + HANDLE m_han;
           17  +public:
           18  + ProcessNumLimitZone(int Max, const char* name)
           19  +  : m_han( ::CreateSemaphore( NULL, Max, Max, name ) )
           20  + {
           21  +  if( m_han )
           22  +   ::WaitForSingleObject( m_han, INFINITE );
           23  +  else
           24  +   kiSUtil::msgLastError("CreateSemaphore Failed");
           25  + }
           26  + ~ProcessNumLimitZone()
           27  + {
           28  +  if( m_han )
           29  +  {
           30  +   ::ReleaseSemaphore( m_han, 1, NULL );
           31  +   ::CloseHandle( m_han );
           32  +  }
           33  + }
           34  +};
           35  +
           36  +//----------------------------------------------//
           37  +//--------- Noah �̃G���g���|�C���g ------------//
           38  +//----------------------------------------------//
           39  +
           40  +void kilib_create_new_app()
           41  +{
           42  + //-- kilib �ɃA�v���P�[�V������ݒ�
           43  + new CNoahApp;
           44  +}
           45  +
           46  +void CNoahApp::run( kiCmdParser& cmd )
           47  +{
           48  + //-- ������
           49  + m_cnfMan.init();
           50  + m_arcMan.init();
           51  +
           52  + //-- �R�}���h���C���p�����[�^�ێ�
           53  + m_pCmd = &cmd;
           54  +
           55  + //-- �u�t�@�C�������n����ĂȂ� or Shift�����N���v�Ȃ�ݒ��ʕ\��
           56  + if( cmd.param().len()==0 || keyPushed(VK_SHIFT) )
           57  + {
           58  +  //-- Load-INI ( �S�� )
           59  +  m_cnfMan.load( All );
           60  +  //-- �ݒ��ʕ\��
           61  +  m_cnfMan.dialog();
           62  + }
           63  + else
           64  + {
           65  +  //-- ���k�𓀂Ȃǂ̍��
           66  +  do_cmdline( true );
           67  + }
           68  +
           69  + //-- �I������
           70  + m_tmpDir.remove();
           71  +}
           72  +
           73  +//----------------------------------------------//
           74  +//------------- ���k/�� �� ��� --------------//
           75  +//----------------------------------------------//
           76  +
           77  +bool CNoahApp::is_writable_dir( const kiPath& path )
           78  +{
           79  + // �v����ɁACDROM/DVDROM ��؂肽���B
           80  + // FDD, PacketWrite��Disk ��؂�̂͂�����߂�B
           81  +
           82  + // RAMDISK, REMOTE, FIXED, UNKNOWN �ȃf�B�X�N�͏������݉”\�ƌ��Ȃ�
           83  + UINT drv = path.getDriveType();
           84  + if( drv==DRIVE_REMOVABLE || drv==DRIVE_CDROM )
           85  + {
           86  +  // �fWin95�ł͎g���Ȃ��֐��Ȃ̂�DynamicLoad
           87  +  typedef BOOL (WINAPI*pGDFSE)( LPCTSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER );
           88  +  pGDFSE pGetDiskFreeSpaceEx
           89  +   = (pGDFSE) ::GetProcAddress( ::GetModuleHandle("kernel32.dll"), "GetDiskFreeSpaceExA" );
           90  +  if( pGetDiskFreeSpaceEx )
           91  +  {
           92  +   // �󂫗e�ʂ�0�Ȃ�A�������ݕs�‚Ƃ݂Ȃ�
           93  +   ULARGE_INTEGER fs, dummy;
           94  +   pGetDiskFreeSpaceEx( path, &dummy, &dummy, &fs );
           95  +   if( fs.QuadPart == 0 )
           96  +    return false;
           97  +  }
           98  + }
           99  + return true;
          100  +}
          101  +
          102  +void CNoahApp::do_cmdline( bool directcall )
          103  +{
          104  + do_files( m_pCmd->param(), &m_pCmd->option(), !directcall );
          105  +}
          106  +
          107  +void CNoahApp::do_files( const cCharArray& files,
          108  +       const cCharArray* opts,
          109  +       bool  basicaly_ignore )
          110  +{
          111  + struct local {
          112  +  ~local() {kiSUtil::switchCurDirToExeDir(); } // �f�B���N�g�����b�N���Ȃ��悤��
          113  + } _;
          114  +
          115  + //-- Archiver Manager �Ƀt�@�C�������X�g���L������
          116  + if( 0 == m_arcMan.set_files( files ) )
          117  +  return;
          118  +
          119  + //-- ��Ɨp�ϐ�
          120  + enum { unknown, melt, compress }
          121  +   whattodo = unknown;
          122  + bool ctrl_mlt = keyPushed( VK_CONTROL );
          123  + bool ctrl_cmp = ctrl_mlt;
          124  + bool alt      = keyPushed( VK_MENU ) || keyPushed( VK_RWIN ) || keyPushed( VK_LWIN );
          125  + const char *cmptype=NULL, *method=NULL;
          126  + kiPath  destdir;
          127  + kiStr tmp(300);
          128  +
          129  + //-- ( ��������� )�R�}���h���C���I�v�V����������
          130  + if( opts )
          131  +  for( unsigned int i=0; i!=opts->len(); i++ )
          132  +   switch( (*opts)[i][1] )
          133  +   {
          134  +   case 'a': if( !basicaly_ignore )
          135  +   case 'A':  whattodo = compress; break;
          136  +
          137  +   case 'x': if( !basicaly_ignore )
          138  +   case 'X':  whattodo = melt;  break;
          139  +
          140  +   case 'd': if( !basicaly_ignore )
          141  +   case 'D':  destdir = (*opts)[i]+2; break;
          142  +
          143  +   case 'w': if( !basicaly_ignore )
          144  +   case 'W':  alt = true;    break;
          145  +
          146  +   case 't': if( !basicaly_ignore )
          147  +   case 'T':  cmptype = (*opts)[i]+2; break;
          148  +
          149  +   case 'm': if( !basicaly_ignore )
          150  +   case 'M':  method = (*opts)[i]+2; break;
          151  +
          152  +   case 'c': if( !basicaly_ignore ) {
          153  +   case 'C':  if((*opts)[i][2]!='x') ctrl_cmp = true;
          154  +       if((*opts)[i][2]!='a') ctrl_mlt = true;
          155  +      break;}
          156  +   }
          157  +
          158  + //-- Load-INI ( ���샂�[�h�ݒ� )
          159  + m_cnfMan.load( Mode );
          160  +
          161  + //-- ���k�𓀂̂ǂ�����s�������肷��B����͈ȉ��̒ʂ�B
          162  + //
          163  + // �E�R�}���h���C���ŁA���k�Ǝw�肳��Ă�Ζ������ň��k��
          164  + //
          165  + // �E�����łȂ���΁A�܂�Noah�̓��샂�[�h�擾
          166  + // �@m0:���k��p  m1:���k�D��  m2:�𓀗D��  m3:�𓀐�p
          167  + // �@�@�R�}���h���C���ʼn𓀂Ǝw�肳��Ă���� m3�B
          168  + // �@�@�w�肪������΁Am_cnfMan ����ǂݍ��݁B
          169  + //
          170  + // �Em0 ���A'm1�ł������t�@�C��������' �̎��͖������ň��k��
          171  + //
          172  + // �E�����łȂ���΁A�𓀃��[�`�������蓖�ĂĂ݂�B
          173  + // �@���̍ہAm3 �ȊO�̂Ƃ��͈�‚ł����蓖�Ď��s������G���[�����k��
          174  + // �@m3 �ł��A��‚����蓖�Ă��Ȃ���΃G���[�B�������I��
          175  +
          176  + if( whattodo != compress )
          177  + {
          178  +  int mode = 3;
          179  +  if( whattodo != melt )
          180  +   mode = m_cnfMan.mode();
          181  +
          182  +  if( mode==0 || ( mode==1 && m_arcMan.file_num()>=2 ) )
          183  +   whattodo = compress;
          184  +  else
          185  +  {
          186  +   //-- �𓀃��[�`�����蓖�ĂĂ݂�
          187  +   bool suc = m_arcMan.map_melters( mode );
          188  +   if( suc )
          189  +    whattodo = melt;
          190  +   else
          191  +   {
          192  +    if( mode != 3 )
          193  +     whattodo = compress;
          194  +    else
          195  +    {
          196  +     //-- �𓀐�p���[�h�����lj𓀕s�I�I
          197  +     msgBox( tmp.loadRsrc(IDS_M_ERROR) );
          198  +     return;
          199  +    }
          200  +   }
          201  +  }
          202  + }
          203  +
          204  + if( whattodo == melt )
          205  + {
          206  +  //-- �𓀐ݒ�͊���m_cnfMan.init()�Ń��[�h����Ă���c
          207  +
          208  +  if( destdir.len()==0 )
          209  +  {
          210  +   //-- �𓀐�f�B���N�g���擾
          211  +   if( m_cnfMan.mdirsm() )
          212  +    if( is_writable_dir(m_arcMan.get_basepath()) )
          213  +     destdir = m_arcMan.get_basepath();
          214  +   if( destdir.len()==0 )
          215  +    destdir = m_cnfMan.mdir();
          216  +  }
          217  +
          218  +  //-- ��
          219  +  if( ctrl_mlt ) m_arcMan.do_listing( destdir );
          220  +  else {
          221  +   ProcessNumLimitZone zone( mycnf().multiboot_limit(), "LimitterForNoahAtKmonosNet" );
          222  +   m_arcMan.do_melting( destdir );
          223  +  }
          224  + }
          225  + else
          226  + {
          227  +  //-- Load-INI( ���k�ݒ� )
          228  +  m_cnfMan.load( Compress );
          229  +
          230  +  if( destdir.len()==0 )
          231  +  {
          232  +   //-- ���k��f�B���N�g���擾
          233  +   if( m_cnfMan.cdirsm() )
          234  +    if( is_writable_dir(m_arcMan.get_basepath()) )
          235  +     destdir = m_arcMan.get_basepath();
          236  +   if( destdir.len()==0 )
          237  +    destdir = m_cnfMan.cdir();
          238  +  }
          239  +  if( !cmptype ) cmptype = m_cnfMan.cext();
          240  +  else if( !method ) method = "";
          241  +  if( !method  ) method  = m_cnfMan.cmhd();
          242  +
          243  +  //-- ���k�p���[�`�������蓖��
          244  +  if( !m_arcMan.map_compressor( cmptype, method, ctrl_cmp ) )
          245  +  {
          246  +   //-- ���k�s�\�Ȍ`���I�I
          247  +   msgBox( tmp.loadRsrc(IDS_C_ERROR) );
          248  +   return;
          249  +  }
          250  +
          251  +  //-- ���k
          252  +  ProcessNumLimitZone zone( mycnf().multiboot_limit(), "LimitterForNoahAtKmonosNet" );
          253  +  m_arcMan.do_compressing( destdir, alt );
          254  + }
          255  +}
          256  +
          257  +//----------------------------------------------//
          258  +//----------------- ���̑��G�p -----------------//
          259  +//----------------------------------------------//
          260  +
          261  +// from= 0:normal 1:melt 2:compress
          262  +void CNoahApp::open_folder( const kiPath& path, int from )
          263  +{
          264  + if( from==1 || from==2 ) //-- Shell�ɍX�V�ʒm
          265  +  ::SHChangeNotify( SHCNE_UPDATEDIR, SHCNF_PATH, (const void*)(const char*)path, NULL );
          266  +
          267  + //-- �f�X�N�g�b�v��������J���Ȃ�
          268  + kiPath dir(path), tmp(kiPath::Dsk,false);
          269  + dir.beBackSlash(false), dir.beShortPath(), tmp.beShortPath();
          270  +
          271  + if( !tmp.isSame( dir ) )
          272  + {
          273  +  //-- Load-INI( �t�H���_�J���ݒ� )
          274  +  m_cnfMan.load( OpenDir );
          275  +  if( (from==1 && !m_cnfMan.modir())
          276  +   || (from==2 && !m_cnfMan.codir()) )
          277  +   return;
          278  +
          279  +  char cmdline[1000];
          280  +  wsprintf( cmdline, m_cnfMan.openby(), (const char*)dir );
          281  +  ::WinExec( cmdline, SW_SHOWDEFAULT );
          282  + }
          283  +}
          284  +
          285  +// �S�V�X�e�����ň�ӂȃe���|�����t�H���_������ĕԂ�
          286  +void CNoahApp::get_tempdir( kiPath& tmp )
          287  +{
          288  + char buf[MAX_PATH];
          289  +
          290  + if( m_tmpDir.len()==0 )
          291  + {
          292  +  ::GetTempFileName( kiPath( kiPath::Tmp ), "noa", 0, buf );
          293  +  ::DeleteFile( buf );
          294  +  m_tmpDir = buf;
          295  +  m_tmpDir.beBackSlash( true );
          296  +  m_tmpDir.mkdir();
          297  +  m_tmpID = ::GetCurrentProcessId();
          298  + }
          299  +
          300  + ::GetTempFileName( m_tmpDir, "noa", m_tmpID++, buf );
          301  + ::DeleteFile( buf );
          302  + tmp = buf;
          303  + tmp.beBackSlash( true );
          304  + tmp.mkdir();
          305  +}