Repository: zhongjianhua163/BlackMoonKernelStaticLib
Branch: master
Commit: 538ab86d2d8e
Files: 290
Total size: 706.5 KB

Directory structure:
gitextract_xxll1hxj/

├── .github/
│   └── workflows/
│       ├── blackmoon_krnln.yml
│       ├── blackmoon_krnlnobj.yml
│       └── blackmoon_mfc.yml
├── .gitignore
├── LICENSE
├── MFCObj/
│   ├── BlackMoonMFCdll.cpp
│   ├── EyMFCComInit.cpp
│   ├── EyMFCComInit.h
│   ├── MFCBlackMoon.aps
│   ├── MFCBlackMoon.cpp
│   ├── MFCBlackMoon.def
│   ├── MFCBlackMoon.h
│   ├── MFCBlackMoon.rc
│   ├── MFCBlackMoonCon.cpp
│   ├── Resource.h
│   ├── StdAfx.cpp
│   ├── StdAfx.h
│   └── res/
│       └── MFCBlackMoon.rc2
├── Project/
│   ├── MFCBlackMoon_VC6.clw
│   ├── MFCBlackMoon_VC6.dsp
│   ├── MFCBlackMoon_VS2019.vcxproj
│   ├── MFCBlackMoon_VS2019.vcxproj.filters
│   ├── MFCBlackMoon_VS2019.vcxproj.user
│   ├── krnln_VC6.dsp
│   ├── krnln_VC6_Obj.dsp
│   ├── krnln_VS2019.vcxproj
│   ├── krnln_VS2019.vcxproj.filters
│   ├── krnln_VS2019.vcxproj.user
│   ├── krnln_VS2019_Obj.vcxproj
│   ├── krnln_VS2019_Obj.vcxproj.filters
│   └── krnln_VS2019_Obj.vcxproj.user
├── README.md
├── Readme.txt
├── krnln/
│   ├── BlackMoonCallPropertyVaule.cpp
│   ├── BlackMoonCallUserDll.cpp
│   ├── BlackMoonDll.cpp
│   ├── BlackMoonDll2.cpp
│   ├── BlackMoonExe.cpp
│   ├── BlackMoonLibNotifySys.cpp
│   ├── BlackMoonResDll.cpp
│   ├── CloneBinData.cpp
│   ├── CloneTextData.cpp
│   ├── DateTimeFormat.cpp
│   ├── Diskid32.obj
│   ├── DllEntryFunc.cpp
│   ├── EyComInit.cpp
│   ├── EyInit.cpp
│   ├── FileManager.cpp
│   ├── FreeAryElement.cpp
│   ├── GetAryElementInf.cpp
│   ├── GetDataTypeType.cpp
│   ├── GetDatePart.cpp
│   ├── GetDaysOfSpecMonth.cpp
│   ├── GetRegRootVal.cpp
│   ├── GetSpecTime.cpp
│   ├── GetSysDataTypeDataSize.cpp
│   ├── GetTimePart.cpp
│   ├── GetWeekDay.cpp
│   ├── HelpFunc12.cpp
│   ├── IsInFileMangerList.cpp
│   ├── LTrimZeroChr.cpp
│   ├── LTrimZeroChr.h
│   ├── MyMemFile.cpp
│   ├── MyMemFile.h
│   ├── Myfunctions.cpp
│   ├── Myfunctions.h
│   ├── NumToChinese.cpp
│   ├── PY.OBJ
│   ├── SDataToStr.cpp
│   ├── StdAfx.cpp
│   ├── StdAfx.h
│   ├── eHelpFunc.cpp
│   ├── krnln_BJCase.cpp
│   ├── krnln_BinLeft.cpp
│   ├── krnln_BinLen.cpp
│   ├── krnln_BinMid.cpp
│   ├── krnln_BinRight.cpp
│   ├── krnln_ChDir.cpp
│   ├── krnln_ChDrive.cpp
│   ├── krnln_ClearClipBoard.cpp
│   ├── krnln_CryptOpen.cpp
│   ├── krnln_CurDir.cpp
│   ├── krnln_DeleteRegItem.cpp
│   ├── krnln_Dispatch.cpp
│   ├── krnln_DoEvents.cpp
│   ├── krnln_FSeek.cpp
│   ├── krnln_FileCopy.cpp
│   ├── krnln_FileDateTime.cpp
│   ├── krnln_FileLen.cpp
│   ├── krnln_FileMove.cpp
│   ├── krnln_GetAllPY.cpp
│   ├── krnln_GetAttr.cpp
│   ├── krnln_GetBackColor.cpp
│   ├── krnln_GetBinElement.cpp
│   ├── krnln_GetBinRegItem.cpp
│   ├── krnln_GetClipBoardText.cpp
│   ├── krnln_GetCmdLine.cpp
│   ├── krnln_GetColorCount.cpp
│   ├── krnln_GetCursorHorzPos.cpp
│   ├── krnln_GetCursorVertPos.cpp
│   ├── krnln_GetDataTypeSize.cpp
│   ├── krnln_GetDatePart.cpp
│   ├── krnln_GetDaysOfSpecMonth.cpp
│   ├── krnln_GetDiskFreeSpace.cpp
│   ├── krnln_GetDiskLabel.cpp
│   ├── krnln_GetDiskTotalSpace.cpp
│   ├── krnln_GetEnv.cpp
│   ├── krnln_GetHDiskCode.cpp
│   ├── krnln_GetHostName.cpp
│   ├── krnln_GetIntInsideBin.cpp
│   ├── krnln_GetKeyText.cpp
│   ├── krnln_GetLastError.cpp
│   ├── krnln_GetNumRegItem.cpp
│   ├── krnln_GetRunFileName.cpp
│   ├── krnln_GetRunPath.cpp
│   ├── krnln_GetRuntimeDataType.cpp
│   ├── krnln_GetScreenHeight.cpp
│   ├── krnln_GetScreenWidth.cpp
│   ├── krnln_GetSectionNames.cpp
│   ├── krnln_GetSpecTime.cpp
│   ├── krnln_GetSysVer.cpp
│   ├── krnln_GetTempFileName.cpp
│   ├── krnln_GetTextRegItem.cpp
│   ├── krnln_GetTickCount.cpp
│   ├── krnln_GetTimePart.cpp
│   ├── krnln_GetWinPic.cpp
│   ├── krnln_HostNameToIP.cpp
│   ├── krnln_IDiv.cpp
│   ├── krnln_IPToHostName.cpp
│   ├── krnln_InBin.cpp
│   ├── krnln_InBinRev.cpp
│   ├── krnln_InStr.cpp
│   ├── krnln_InStrRev.cpp
│   ├── krnln_InputBox.cpp
│   ├── krnln_InsBin.cpp
│   ├── krnln_InsLine.cpp
│   ├── krnln_InsText.cpp
│   ├── krnln_IsCalcOK.cpp
│   ├── krnln_IsDebugVer.cpp
│   ├── krnln_IsFileExist.cpp
│   ├── krnln_IsHaveTextInClip.cpp
│   ├── krnln_IsRegItemExist.cpp
│   ├── krnln_LCase.cpp
│   ├── krnln_LTrim.cpp
│   ├── krnln_MakeLong.cpp
│   ├── krnln_MakeWord.cpp
│   ├── krnln_MkDir.cpp
│   ├── krnln_MsgBox.cpp
│   ├── krnln_NumToRMB.cpp
│   ├── krnln_NumToText.cpp
│   ├── krnln_OpenManyFileDialog.cpp
│   ├── krnln_OpenMemFile.cpp
│   ├── krnln_PlayMID.cpp
│   ├── krnln_PlayMusic.cpp
│   ├── krnln_PlayStop.cpp
│   ├── krnln_PutEnv.cpp
│   ├── krnln_QJCase.cpp
│   ├── krnln_RTrim.cpp
│   ├── krnln_ReadBin.cpp
│   ├── krnln_ReadFile.cpp
│   ├── krnln_ReadLine.cpp
│   ├── krnln_ReadText.cpp
│   ├── krnln_RemoveData.cpp
│   ├── krnln_ReplaceText.cpp
│   ├── krnln_RestroeCursor.cpp
│   ├── krnln_ReverseIntBytes.cpp
│   ├── krnln_RmDir.cpp
│   ├── krnln_RpBin.cpp
│   ├── krnln_RpSubBin.cpp
│   ├── krnln_RpSubText.cpp
│   ├── krnln_RunConsoleApp.cpp
│   ├── krnln_SaveRegItem.cpp
│   ├── krnln_SeekToBegin.cpp
│   ├── krnln_SeekToEnd.cpp
│   ├── krnln_SetAttr.cpp
│   ├── krnln_SetClipBoardText.cpp
│   ├── krnln_SetDiskLabel.cpp
│   ├── krnln_SetIntInsideBin.cpp
│   ├── krnln_SetKeyText.cpp
│   ├── krnln_SetSysTime.cpp
│   ├── krnln_SetWaitCursor.cpp
│   ├── krnln_SortAry.cpp
│   ├── krnln_SpaceBin.cpp
│   ├── krnln_SplitBin.cpp
│   ├── krnln_StrComp.cpp
│   ├── krnln_StrToUTF8.cpp
│   ├── krnln_TimeChg.cpp
│   ├── krnln_TimeDiff.cpp
│   ├── krnln_TimePart.cpp
│   ├── krnln_TimeToText.cpp
│   ├── krnln_ToBin.cpp
│   ├── krnln_ToByte.cpp
│   ├── krnln_ToFloat.cpp
│   ├── krnln_ToInt.cpp
│   ├── krnln_ToLong.cpp
│   ├── krnln_ToShort.cpp
│   ├── krnln_ToTime.cpp
│   ├── krnln_TrimAll.cpp
│   ├── krnln_UCase.cpp
│   ├── krnln_UNum.cpp
│   ├── krnln_UTF8ToStr.cpp
│   ├── krnln_Unlock.cpp
│   ├── krnln_Variant.cpp
│   ├── krnln_WeekDay.cpp
│   ├── krnln_WriteBin.cpp
│   ├── krnln_WriteFile.cpp
│   ├── krnln_WriteLine.cpp
│   ├── krnln_WriteMem.cpp
│   ├── krnln_WriteText.cpp
│   ├── krnln_ZeroAry.cpp
│   ├── krnln_abs.cpp
│   ├── krnln_asc.cpp
│   ├── krnln_atn.cpp
│   ├── krnln_band.cpp
│   ├── krnln_beep.cpp
│   ├── krnln_bin.cpp
│   ├── krnln_bnot.cpp
│   ├── krnln_bor.cpp
│   ├── krnln_bxor.cpp
│   ├── krnln_chr.cpp
│   ├── krnln_close.cpp
│   ├── krnln_cos.cpp
│   ├── krnln_create.cpp
│   ├── krnln_day.cpp
│   ├── krnln_exp.cpp
│   ├── krnln_feof.cpp
│   ├── krnln_fgets.cpp
│   ├── krnln_fix.cpp
│   ├── krnln_fputs.cpp
│   ├── krnln_hex.cpp
│   ├── krnln_hour.cpp
│   ├── krnln_int.cpp
│   ├── krnln_kill.cpp
│   ├── krnln_left.cpp
│   ├── krnln_len.cpp
│   ├── krnln_like.cpp
│   ├── krnln_loc.cpp
│   ├── krnln_lock.cpp
│   ├── krnln_lof.cpp
│   ├── krnln_log.cpp
│   ├── krnln_mid.cpp
│   ├── krnln_minute.cpp
│   ├── krnln_mod.cpp
│   ├── krnln_month.cpp
│   ├── krnln_name.cpp
│   ├── krnln_now.cpp
│   ├── krnln_oct.cpp
│   ├── krnln_open.cpp
│   ├── krnln_p2double.cpp
│   ├── krnln_p2float.cpp
│   ├── krnln_p2int.cpp
│   ├── krnln_pbin.cpp
│   ├── krnln_ping.cpp
│   ├── krnln_pow.cpp
│   ├── krnln_pstr.cpp
│   ├── krnln_randomize.cpp
│   ├── krnln_read.cpp
│   ├── krnln_reset.cpp
│   ├── krnln_rgb.cpp
│   ├── krnln_right.cpp
│   ├── krnln_rnd.cpp
│   ├── krnln_round.cpp
│   ├── krnln_run.cpp
│   ├── krnln_second.cpp
│   ├── krnln_sgn.cpp
│   ├── krnln_shl.cpp
│   ├── krnln_shr.cpp
│   ├── krnln_sin.cpp
│   ├── krnln_sleep.cpp
│   ├── krnln_space.cpp
│   ├── krnln_split.cpp
│   ├── krnln_sqr.cpp
│   ├── krnln_str.cpp
│   ├── krnln_string.cpp
│   ├── krnln_tan.cpp
│   ├── krnln_trim.cpp
│   ├── krnln_val.cpp
│   ├── krnln_write.cpp
│   ├── krnln_year.cpp
│   ├── lib.h
│   ├── lib2.h
│   ├── md5t.cpp
│   ├── md5t.h
│   ├── mem.cpp
│   ├── mem.h
│   ├── midi.cpp
│   ├── midi.h
│   └── replaceText.cpp
├── krnln_VC6.dsw
└── krnln_VS2019.sln

================================================
FILE CONTENTS
================================================

================================================
FILE: .github/workflows/blackmoon_krnln.yml
================================================
name: BlackMoon Krnln

on:
  push:
    branches: [master]
  pull_request:
    branches: [master]

jobs:
  bmkrnln-debug-win32:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v2

      # Add msuild to local environment
      - name: Add msbuild to PATH
        uses: microsoft/setup-msbuild@v1.0.2

      # Test build
      - name: Build BlackMoon Krnln
        run: msbuild Project/krnln_VS2019.vcxproj /p:configuration=debug /p:platform=win32 -maxcpucount:4

  bmkrnln-release-win32:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v2

      # Add msuild to local environment
      - name: Add msbuild to PATH
        uses: microsoft/setup-msbuild@v1.0.2

      # Test build
      - name: Build BlackMoon Krnln
        run: msbuild Project/krnln_VS2019.vcxproj /p:configuration=release /p:platform=win32 -maxcpucount:4


================================================
FILE: .github/workflows/blackmoon_krnlnobj.yml
================================================
name: BlackMoon Krnln OBJ

on:
  push:
    branches: [master]
  pull_request:
    branches: [master]

jobs:
  bmkrobj-debug-win32:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v2

      # Add msuild to local environment
      - name: Add msbuild to PATH
        uses: microsoft/setup-msbuild@v1.0.2

      # Test build
      - name: Build BlackMoon Krnln OBJ
        run: msbuild Project/krnln_VS2019_Obj.vcxproj /p:configuration=debug /p:platform=win32 -maxcpucount:4

  bmkrobj-release-win32:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v2

      # Add msuild to local environment
      - name: Add msbuild to PATH
        uses: microsoft/setup-msbuild@v1.0.2

      # Test build
      - name: Build BlackMoon Krnln OBJ
        run: msbuild Project/krnln_VS2019_Obj.vcxproj /p:configuration=release /p:platform=win32 -maxcpucount:4


================================================
FILE: .github/workflows/blackmoon_mfc.yml
================================================
name: BlackMoon MFC

on:
  push:
    branches: [master]
  pull_request:
    branches: [master]

jobs:
  bmmfc-debug-win32:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v2

      # Add msuild to local environment
      - name: Add msbuild to PATH
        uses: microsoft/setup-msbuild@v1.0.2

      # Test build
      - name: Build BlackMoon MFC
        run: msbuild Project/MFCBlackMoon_VS2019.vcxproj /p:configuration=debug /p:platform=win32 -maxcpucount:4

  bmmfc-release-win32:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v2

      # Add msuild to local environment
      - name: Add msbuild to PATH
        uses: microsoft/setup-msbuild@v1.0.2

      # Test build
      - name: Build BlackMoon MFC
        run: msbuild Project/MFCBlackMoon_VS2019.vcxproj /p:configuration=release /p:platform=win32 -maxcpucount:4


================================================
FILE: .gitignore
================================================
*.ncb
*.opt
*.plg
*.suo
.vs/*
Release/*
Debug/*
Project/krnln_VS2005.vcproj.*
Project/krnln_VS2005_Obj.vcproj.*
Project/*.plg
Project/Release/*
Project/ReleaseDll/*
Project/Debug/*


================================================
FILE: LICENSE
================================================
BSD 3-Clause License

Copyright (c) 2019, 钟建华
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.

* Neither the name of the copyright holder nor the names of its
  contributors may be used to endorse or promote products derived from
  this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


================================================
FILE: MFCObj/BlackMoonMFCdll.cpp
================================================

#include "stdafx.h"
#include "EyMFCComInit.h"
//#define _EDLLMAIN
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CMFCBlackMoonDLLApp

BEGIN_MESSAGE_MAP(CMFCBlackMoonDLLApp, CWinApp)
	//{{AFX_MSG_MAP(CMFCBlackMoonDLLApp)
		// NOTE - the ClassWizard will add and remove mapping macros here.
		//    DO NOT EDIT what you see in these blocks of generated code!
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CMFCBlackMoonDLLApp construction

CMFCBlackMoonDLLApp::CMFCBlackMoonDLLApp()
{
	// TODO: add construction code here,
	// Place all significant initialization in InitInstance
}

/////////////////////////////////////////////////////////////////////////////
// The one and only CMFCBlackMoonDLLApp object
#pragma comment(lib, "nafxcw.lib")
CMFCBlackMoonDLLApp theApp;

typedef void (*PDESTROY)(void);
PDESTROY DllEntryFunc();
extern HANDLE hBlackMoonInstanceHandle;
extern "C" PDESTROY DestroyAddress;
extern "C" {
	//PDESTROY ECodeStart();
	void  _cdecl E_Init();
	void  _cdecl E_DestroyRes();
#ifdef _EDLLMAIN
	int __stdcall EDllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 );
#endif
}
INT nBMProtectESP = 0;
INT nBMProtectEBP = 0;
BOOL CMFCBlackMoonDLLApp::InitInstance() 
{
	// TODO: Add your specialized code here and/or call the base class
	//MessageBox(NULL,"I am MfcBlackMoon","DLL",MB_OK);
	hBlackMoonInstanceHandle = m_hInstance;
	E_Init();
	DestroyAddress = DllEntryFunc();
	
#ifdef _EDLLMAIN
	int nRet = EDllMain(m_hInstance,DLL_PROCESS_ATTACH,0);
	if(nRet==0)
		return nRet;
#endif
	


	return CWinApp::InitInstance();
}

int CMFCBlackMoonDLLApp::ExitInstance() 
{
	// TODO: Add your specialized code here and/or call the base class
#ifdef _EDLLMAIN
	int nRet = EDllMain(m_hInstance,DLL_PROCESS_DETACH,0);
#endif
	E_DestroyRes();
	
	return CWinApp::ExitInstance();
}




================================================
FILE: MFCObj/EyMFCComInit.cpp
================================================
#include "stdafx.h"
typedef void (*PDESTROY)(void);
extern "C" PDESTROY DestroyAddress;

extern "C" PDESTROY HFileDestroyAddress;

extern "C" PDESTROY DestroyMidiPlayer;

extern "C" HANDLE hBlackMoonHeap;

void BlackMoonInitAllElib();
void BlackMoonFreeAllElib();

extern "C" {


	void  _cdecl E_Init(){
		hBlackMoonHeap =::GetProcessHeap();
		AfxOleInit();
		CoInitialize(0);
		BlackMoonInitAllElib();
	}

	void  _cdecl E_DestroyRes(){
		
		if(DestroyAddress)
			DestroyAddress();

		if(HFileDestroyAddress)
			HFileDestroyAddress();

		if(DestroyMidiPlayer)
			DestroyMidiPlayer();
		BlackMoonFreeAllElib();
		//CoUninitialize();
	}


}

================================================
FILE: MFCObj/EyMFCComInit.h
================================================
#if !defined(AFX_MFCBLACKMOON_H__66A6D0ED_F1AB_4149_9834_F05CAE45D193__INCLUDED_)
#define AFX_MFCBLACKMOON_H__66A6D0ED_F1AB_4149_9834_F05CAE45D193__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#ifndef __AFXWIN_H__
	#error include 'stdafx.h' before including this file for PCH
#endif

#include "resource.h"		// main symbols

/////////////////////////////////////////////////////////////////////////////
// CMFCBlackMoonApp
// See MFCBlackMoon.cpp for the implementation of this class
//

class CMFCBlackMoonDLLApp : public CWinApp
{
public:
	CMFCBlackMoonDLLApp();

// Overrides
	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CMFCBlackMoonDLLApp)
	public:
	virtual BOOL InitInstance();
	virtual int ExitInstance();
	//}}AFX_VIRTUAL

	//{{AFX_MSG(CMFCBlackMoonDLLApp)
		// NOTE - the ClassWizard will add and remove member functions here.
		//    DO NOT EDIT what you see in these blocks of generated code !
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};


/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_MFCBLACKMOON_H__66A6D0ED_F1AB_4149_9834_F05CAE45D193__INCLUDED_)


================================================
FILE: MFCObj/MFCBlackMoon.cpp
================================================
// MFCBlackMoon.cpp : Defines the initialization routines for the DLL.
//

#include "stdafx.h"
#include "MFCBlackMoon.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

//
//	Note!
//
//		If this DLL is dynamically linked against the MFC
//		DLLs, any functions exported from this DLL which
//		call into MFC must have the AFX_MANAGE_STATE macro
//		added at the very beginning of the function.
//
//		For example:
//
//		extern "C" BOOL PASCAL EXPORT ExportedFunction()
//		{
//			AFX_MANAGE_STATE(AfxGetStaticModuleState());
//			// normal function body here
//		}
//
//		It is very important that this macro appear in each
//		function, prior to any calls into MFC.  This means that
//		it must appear as the first statement within the 
//		function, even before any object variable declarations
//		as their constructors may generate calls into the MFC
//		DLL.
//
//		Please see MFC Technical Notes 33 and 58 for additional
//		details.
//

/////////////////////////////////////////////////////////////////////////////
// CMFCBlackMoonApp

BEGIN_MESSAGE_MAP(CMFCBlackMoonApp, CWinApp)
	//{{AFX_MSG_MAP(CMFCBlackMoonApp)
		// NOTE - the ClassWizard will add and remove mapping macros here.
		//    DO NOT EDIT what you see in these blocks of generated code!
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CMFCBlackMoonApp construction

CMFCBlackMoonApp::CMFCBlackMoonApp()
{
	// TODO: add construction code here,
	// Place all significant initialization in InitInstance
}

/////////////////////////////////////////////////////////////////////////////
// The one and only CMFCBlackMoonApp object
//#pragma comment(lib, "nafxcw.lib")
CMFCBlackMoonApp theApp;
extern "C" {
	int ECodeStart();
	void  _cdecl E_Init();
}
INT nBMProtectESP = 0;
INT nBMProtectEBP = 0;
BOOL CMFCBlackMoonApp::InitInstance() 
{
	// TODO: Add your specialized code here and/or call the base class
//	MessageBox(NULL,"I am MfcBlackMoon","NULL",MB_OK);
		E_Init();
		int nRet;
//		int nRet = ECodeStart();
		_asm{
			mov nBMProtectESP,esp;
			mov nBMProtectEBP,ebp;
			call ECodeStart;
			mov nRet,eax;

		}
	return CWinApp::InitInstance();
}





================================================
FILE: MFCObj/MFCBlackMoon.def
================================================
; MFCBlackMoon.def : Declares the module parameters for the DLL.

LIBRARY      "MFCBlackMoon"
DESCRIPTION  'MFCBlackMoon Windows Dynamic Link Library'

EXPORTS
    ; Explicit exports can go here


================================================
FILE: MFCObj/MFCBlackMoon.h
================================================
// MFCBlackMoon.h : main header file for the MFCBLACKMOON DLL
//

#if !defined(AFX_MFCBLACKMOON_H__66A6D0ED_F1AB_4149_9834_F05CAE45D193__INCLUDED_)
#define AFX_MFCBLACKMOON_H__66A6D0ED_F1AB_4149_9834_F05CAE45D193__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#ifndef __AFXWIN_H__
	#error include 'stdafx.h' before including this file for PCH
#endif

#include "resource.h"		// main symbols

/////////////////////////////////////////////////////////////////////////////
// CMFCBlackMoonApp
// See MFCBlackMoon.cpp for the implementation of this class
//

class CMFCBlackMoonApp : public CWinApp
{
public:
	CMFCBlackMoonApp();

// Overrides
	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CMFCBlackMoonApp)
	public:
	virtual BOOL InitInstance();

	//}}AFX_VIRTUAL

	//{{AFX_MSG(CMFCBlackMoonApp)
		// NOTE - the ClassWizard will add and remove member functions here.
		//    DO NOT EDIT what you see in these blocks of generated code !
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};


/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_MFCBLACKMOON_H__66A6D0ED_F1AB_4149_9834_F05CAE45D193__INCLUDED_)


================================================
FILE: MFCObj/MFCBlackMoon.rc
================================================
// Microsoft Visual C++ generated resource script.
//
#include "resource.h"

#define APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 2 resource.
//
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
#undef APSTUDIO_READONLY_SYMBOLS

#ifdef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// TEXTINCLUDE
//

1 TEXTINCLUDE DISCARDABLE 
BEGIN
    "resource.h\0"
END

2 TEXTINCLUDE DISCARDABLE 
BEGIN
    "#include ""afxres.h""\r\n"
    "\0"
END

3 TEXTINCLUDE DISCARDABLE 
BEGIN
    "#define _AFX_NO_SPLITTER_RESOURCES\r\n"
    "#define _AFX_NO_OLE_RESOURCES\r\n"
    "#define _AFX_NO_TRACKER_RESOURCES\r\n"
    "#define _AFX_NO_PROPERTY_RESOURCES\r\n"
	"\r\n"
	"#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_CHS)\r\n"
	"#ifdef _WIN32\r\n"
	"LANGUAGE 4, 2\r\n"
	"#pragma code_page(936)\r\n"
	"#endif //_WIN32\r\n"
	"#include ""res\\MFCBlackMoon.rc2""  // non-Microsoft Visual C++ edited resources\r\n"
	"#include ""l.chs\\afxres.rc""  	// Standard components\r\n"
	"#endif\r\n"
    "\0"
END

/////////////////////////////////////////////////////////////////////////////
#endif    // APSTUDIO_INVOKED




#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_CHS)
#ifdef _WIN32
LANGUAGE 4, 2
#pragma code_page(936)
#endif //_WIN32

/////////////////////////////////////////////////////////////////////////////
//
// Version
//

VS_VERSION_INFO     VERSIONINFO
  FILEVERSION       1,0,0,1
  PRODUCTVERSION    1,0,0,1
 FILEFLAGSMASK 0x3fL
#ifdef _DEBUG
 FILEFLAGS 0x1L
#else
 FILEFLAGS 0x0L
#endif
 FILEOS 0x4L
 FILETYPE 0x2L
 FILESUBTYPE 0x0L
BEGIN
	BLOCK "StringFileInfo"
	BEGIN
        BLOCK "080404B0"
		BEGIN 
			VALUE "CompanyName",     "\0"
			VALUE "FileDescription", "MFCBlackMoon DLL\0"
			VALUE "FileVersion",     "1, 0, 0, 1\0"
			VALUE "InternalName",    "MFCBlackMoon\0"
			VALUE "LegalCopyright",  "Ȩ (C) 2013\0"
			VALUE "LegalTrademarks", "\0"
			VALUE "OriginalFilename","MFCBlackMoon.DLL\0"
			VALUE "ProductName",     "MFCBlackMoon Dynamic Link Library\0"
			VALUE "ProductVersion",  "1, 0, 0, 1\0"
		END
	END
	BLOCK "VarFileInfo" 
	BEGIN 
		VALUE "Translation", 0x0804, 1200
    END
END

#endif

#ifndef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 3 resource.
//
#define _AFX_NO_SPLITTER_RESOURCES
#define _AFX_NO_OLE_RESOURCES
#define _AFX_NO_TRACKER_RESOURCES
#define _AFX_NO_PROPERTY_RESOURCES

#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_CHS)
#ifdef _WIN32
LANGUAGE 4, 2
#pragma code_page(936)
#endif //_WIN32
#include "res\\MFCBlackMoon.rc2"  // non-Microsoft Visual C++ edited resources
#include "l.chs\\afxres.rc"  	// Standard components
#endif

/////////////////////////////////////////////////////////////////////////////
#endif    // not APSTUDIO_INVOKED



================================================
FILE: MFCObj/MFCBlackMoonCon.cpp
================================================
// test.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <iostream>

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#pragma comment(lib, "nafxcw.lib")

extern "C" {
	int ECodeStart();
	void  _cdecl E_Init();
}
/////////////////////////////////////////////////////////////////////////////
// The one and only application object
extern "C" int ECodeStart();
//BOOL bIsEnterFromBMEntrypoint = FALSE;
INT nBMProtectESP = 0;
INT nBMProtectEBP = 0;

CWinApp;

using namespace std;

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
	int nRetCode = 0;
	// initialize MFC and print and error on failure
	if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))
	{
		// TODO: change error code to suit your needs
		cerr << _T("Fatal Error: MFC initialization failed") << endl;
		nRetCode = 1;
	}
	else
	{
		// TODO: code your application's behavior here.
	//	CString strHello;
	//	strHello=_T("I am MfcBlackMoon");
	//	cout << (LPCTSTR)strHello << endl;

		E_Init();
		//		int nRet = ECodeStart();
		_asm{
			mov nBMProtectESP,esp;
			mov nBMProtectEBP,ebp;
			call ECodeStart;
			mov nRetCode,eax;
			
		}
	}

	return nRetCode;
}




================================================
FILE: MFCObj/Resource.h
================================================
//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by MFCBLACKMOON.RC
//

// Next default values for new objects
// 
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS

#define _APS_NEXT_RESOURCE_VALUE	1000
#define _APS_NEXT_CONTROL_VALUE		1000
#define _APS_NEXT_SYMED_VALUE		1000
#define _APS_NEXT_COMMAND_VALUE		32771
#endif
#endif


================================================
FILE: MFCObj/StdAfx.cpp
================================================
// stdafx.cpp : source file that includes just the standard includes
//	MFCBlackMoon.pch will be the pre-compiled header
//	stdafx.obj will contain the pre-compiled type information

#include "stdafx.h"





================================================
FILE: MFCObj/StdAfx.h
================================================
// stdafx.h : include file for standard system include files,
//  or project specific include files that are used frequently, but
//      are changed infrequently
//

#if !defined(AFX_STDAFX_H__2E3BE724_6CE0_4B24_8A39_6BCD4E07A00B__INCLUDED_)
#define AFX_STDAFX_H__2E3BE724_6CE0_4B24_8A39_6BCD4E07A00B__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#ifndef _WIN32_WINNT

#ifdef _WIN32_WINNT_MAXVER
#define _WIN32_WINNT _WIN32_WINNT_MAXVER
#else
#define _WIN32_WINNT 0x0502
#endif

#endif

#define VC_EXTRALEAN		// Exclude rarely-used stuff from Windows headers

#include <afxwin.h>         // MFC core and standard components
#include <afxext.h>         // MFC extensions

#ifndef _AFX_NO_OLE_SUPPORT
#include <afxole.h>         // MFC OLE classes
#include <afxodlgs.h>       // MFC OLE dialog classes
#include <afxdisp.h>        // MFC Automation classes
#endif // _AFX_NO_OLE_SUPPORT


#ifndef _AFX_NO_DB_SUPPORT
#include <afxdb.h>			// MFC ODBC database classes
#endif // _AFX_NO_DB_SUPPORT

#ifndef _AFX_NO_DAO_SUPPORT
#include <afxdao.h>			// MFC DAO database classes
#endif // _AFX_NO_DAO_SUPPORT

#include <afxdtctl.h>		// MFC support for Internet Explorer 4 Common Controls
#ifndef _AFX_NO_AFXCMN_SUPPORT
#include <afxcmn.h>			// MFC support for Windows Common Controls
#endif // _AFX_NO_AFXCMN_SUPPORT


//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_STDAFX_H__2E3BE724_6CE0_4B24_8A39_6BCD4E07A00B__INCLUDED_)


================================================
FILE: MFCObj/res/MFCBlackMoon.rc2
================================================
//
// MFCBLACKMOON.RC2 - resources Microsoft Visual C++ does not edit directly
//

#ifdef APSTUDIO_INVOKED
	#error this file is not editable by Microsoft Visual C++
#endif //APSTUDIO_INVOKED


/////////////////////////////////////////////////////////////////////////////
// Add manually edited resources here...

/////////////////////////////////////////////////////////////////////////////


================================================
FILE: Project/MFCBlackMoon_VC6.clw
================================================
; CLW file contains information for the MFC ClassWizard

[General Info]
Version=1
ClassCount=1
Class1=CMFCBlackMoonApp
LastClass=CMFCBlackMoonApp
NewFileInclude2=#include "..\MFCObj\MFCBlackMoon.h"
ResourceCount=0
NewFileInclude1=#include "..\MFCObj\StdAfx.h"

[CLS:CMFCBlackMoonApp]
Type=0
HeaderFile=..\MFCObj\MFCBlackMoon.h
ImplementationFile=..\MFCObj\MFCBlackMoon.cpp
Filter=N
BaseClass=CWinApp
VirtualFilter=AC



================================================
FILE: Project/MFCBlackMoon_VC6.dsp
================================================
# Microsoft Developer Studio Project File - Name="MFCBlackMoon" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **

# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102

CFG=MFCBlackMoon - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE 
!MESSAGE NMAKE /f "MFCBlackMoon_VC6.mak".
!MESSAGE 
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE 
!MESSAGE NMAKE /f "MFCBlackMoon_VC6.mak" CFG="MFCBlackMoon - Win32 Debug"
!MESSAGE 
!MESSAGE Possible choices for configuration are:
!MESSAGE 
!MESSAGE "MFCBlackMoon - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "MFCBlackMoon - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "MFCBlackMoon - Win32 ReleaseDLL" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE 

# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe

!IF  "$(CFG)" == "MFCBlackMoon - Win32 Release"

# PROP BASE Use_MFC 5
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "..\Release"
# PROP BASE Intermediate_Dir ".\Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 5
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "..\Release"
# PROP Intermediate_Dir ".\Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_WINDLL" /Yu"stdafx.h" /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_WINDLL" /D "_MBCS" /D "_USRDLL" /FD /D /D /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x804 /d "NDEBUG"
# ADD RSC /l 0x804 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 /nologo /subsystem:windows /dll /machine:I386
# ADD LINK32 /nologo /subsystem:windows /dll /machine:I386

!ELSEIF  "$(CFG)" == "MFCBlackMoon - Win32 Debug"

# PROP BASE Use_MFC 5
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "..\Debug"
# PROP BASE Intermediate_Dir ".\Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 5
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "..\Debug"
# PROP Intermediate_Dir ".\Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_WINDLL" /Yu"stdafx.h" /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_WINDLL" /D "_MBCS" /D "_USRDLL" /Yu"stdafx.h" /FD /GZ /c
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x804 /d "_DEBUG"
# ADD RSC /l 0x804 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 /nologo /subsystem:windows /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 /nologo /subsystem:windows /dll /debug /machine:I386 /pdbtype:sept

!ELSEIF  "$(CFG)" == "MFCBlackMoon - Win32 ReleaseDLL"

# PROP BASE Use_MFC 5
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "..\Release"
# PROP BASE Intermediate_Dir ".\ReleaseDll"
# PROP BASE Target_Dir ""
# PROP Use_MFC 5
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "..\Release"
# PROP Intermediate_Dir ".\ReleaseDll"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /FD /D /D /c
# ADD CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_WINDLL" /D "_MBCS" /D "_USRDLL" /D "_EDLLMAIN" /FD /D /D /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x804 /d "NDEBUG"
# ADD RSC /l 0x804 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 /nologo /subsystem:windows /dll /machine:I386
# ADD LINK32 /nologo /subsystem:windows /dll /machine:I386

!ENDIF 

# Begin Target

# Name "MFCBlackMoon - Win32 Release"
# Name "MFCBlackMoon - Win32 Debug"
# Name "MFCBlackMoon - Win32 ReleaseDLL"
# Begin Group "Source Files"

# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File

SOURCE=..\MFCObj\BlackMoonMFCdll.cpp
# End Source File
# Begin Source File

SOURCE=..\MFCObj\EyMFCComInit.cpp
# End Source File
# Begin Source File

SOURCE=..\MFCObj\MFCBlackMoon.cpp
# End Source File
# Begin Source File

SOURCE=..\MFCObj\MFCBlackMoon.def
# End Source File
# Begin Source File

SOURCE=..\MFCObj\MFCBlackMoon.rc
# End Source File
# Begin Source File

SOURCE=..\MFCObj\MFCBlackMoonCon.cpp
# End Source File
# Begin Source File

SOURCE=..\MFCObj\StdAfx.cpp
# ADD CPP /Yc"stdafx.h"
# End Source File
# End Group
# Begin Group "Header Files"

# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File

SOURCE=..\MFCObj\EyMFCComInit.h
# End Source File
# Begin Source File

SOURCE=..\MFCObj\MFCBlackMoon.h
# End Source File
# Begin Source File

SOURCE=..\MFCObj\Resource.h
# End Source File
# Begin Source File

SOURCE=..\MFCObj\StdAfx.h
# End Source File
# End Group
# Begin Group "Resource Files"

# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# Begin Source File

SOURCE=..\MFCObj\res\MFCBlackMoon.rc2
# End Source File
# End Group
# Begin Source File

SOURCE=..\ReadMe.txt
# End Source File
# End Target
# End Project


================================================
FILE: Project/MFCBlackMoon_VS2019.vcxproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup Label="ProjectConfigurations">
    <ProjectConfiguration Include="Debug|Win32">
      <Configuration>Debug</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="ReleaseDll|Win32">
      <Configuration>ReleaseDll</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="ReleaseDll|x64">
      <Configuration>ReleaseDll</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Debug|x64">
      <Configuration>Debug</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|x64">
      <Configuration>Release</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="..\MFCObj\BlackMoonMFCdll.cpp" />
    <ClCompile Include="..\MFCObj\EyMFCComInit.cpp" />
    <ClCompile Include="..\MFCObj\MFCBlackMoon.cpp" />
    <ClCompile Include="..\MFCObj\MFCBlackMoonCon.cpp" />
    <ClCompile Include="..\MFCObj\StdAfx.cpp" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="..\MFCObj\EyMFCComInit.h" />
    <ClInclude Include="..\MFCObj\MFCBlackMoon.h" />
    <ClInclude Include="..\MFCObj\Resource.h" />
    <ClInclude Include="..\MFCObj\StdAfx.h" />
  </ItemGroup>
  <ItemGroup>
    <None Include="..\MFCObj\MFCBlackMoon.def" />
    <None Include="..\MFCObj\res\MFCBlackMoon.rc2" />
  </ItemGroup>
  <ItemGroup>
    <ResourceCompile Include="..\MFCObj\MFCBlackMoon.rc" />
  </ItemGroup>
  <PropertyGroup Label="Globals">
    <VCProjectVersion>16.0</VCProjectVersion>
    <ProjectGuid>{302FE4C1-503E-476A-AD7B-D6768D2E0158}</ProjectGuid>
    <Keyword>MFCDLLProj</Keyword>
    <RootNamespace>MFCBlackMoon</RootNamespace>
    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
    <ProjectName>MFCBlackMoon</ProjectName>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v142</PlatformToolset>
    <CharacterSet>MultiByte</CharacterSet>
    <UseOfMfc>Static</UseOfMfc>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v142</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>MultiByte</CharacterSet>
    <UseOfMfc>Static</UseOfMfc>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDll|Win32'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v142</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>MultiByte</CharacterSet>
    <UseOfMfc>Static</UseOfMfc>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v142</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
    <UseOfMfc>Static</UseOfMfc>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v142</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
    <UseOfMfc>Static</UseOfMfc>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDll|x64'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v142</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
    <UseOfMfc>Static</UseOfMfc>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
  </ImportGroup>
  <ImportGroup Label="Shared">
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDll|Win32'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDll|x64'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <LinkIncremental>false</LinkIncremental>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDll|Win32'">
    <LinkIncremental>false</LinkIncremental>
    <OutDir>$(SolutionDir)Release</OutDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <LinkIncremental>true</LinkIncremental>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <LinkIncremental>true</LinkIncremental>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <LinkIncremental>false</LinkIncremental>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDll|x64'">
    <LinkIncremental>false</LinkIncremental>
  </PropertyGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <ClCompile>
      <PrecompiledHeader>NotUsing</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>WIN32;_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <PrecompiledHeaderFile>StdAfx.h</PrecompiledHeaderFile>
      <PrecompiledHeaderOutputFile />
      <WholeProgramOptimization>false</WholeProgramOptimization>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <ModuleDefinitionFile>..\MFCObj\MFCBlackMoon.def</ModuleDefinitionFile>
    </Link>
    <Midl>
      <MkTypLibCompatible>false</MkTypLibCompatible>
      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
    </Midl>
    <ResourceCompile>
      <Culture>0x0804</Culture>
      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ResourceCompile>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDll|Win32'">
    <ClCompile>
      <PrecompiledHeader>NotUsing</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>WIN32;_WINDOWS;NDEBUG;_USRDLL;_EDLLMAIN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <PrecompiledHeaderFile>StdAfx.h</PrecompiledHeaderFile>
      <PrecompiledHeaderOutputFile>
      </PrecompiledHeaderOutputFile>
      <WholeProgramOptimization>false</WholeProgramOptimization>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <ModuleDefinitionFile>..\MFCObj\MFCBlackMoon.def</ModuleDefinitionFile>
    </Link>
    <Midl>
      <MkTypLibCompatible>false</MkTypLibCompatible>
      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
    </Midl>
    <ResourceCompile>
      <Culture>0x0804</Culture>
      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ResourceCompile>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <ClCompile>
      <PrecompiledHeader>NotUsing</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>WIN32;_WINDOWS;_DEBUG;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <PrecompiledHeaderFile>StdAfx.h</PrecompiledHeaderFile>
      <PrecompiledHeaderOutputFile />
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <ModuleDefinitionFile>..\MFCObj\MFCBlackMoon.def</ModuleDefinitionFile>
    </Link>
    <Midl>
      <MkTypLibCompatible>false</MkTypLibCompatible>
      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
    </Midl>
    <ResourceCompile>
      <Culture>0x0804</Culture>
      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ResourceCompile>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <ClCompile>
      <PrecompiledHeader>Use</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>_WINDOWS;_DEBUG;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <ModuleDefinitionFile>..\MFCObj\MFCBlackMoon.def</ModuleDefinitionFile>
    </Link>
    <Midl>
      <MkTypLibCompatible>false</MkTypLibCompatible>
      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
    </Midl>
    <ResourceCompile>
      <Culture>0x0804</Culture>
      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ResourceCompile>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <ClCompile>
      <PrecompiledHeader>Use</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <ModuleDefinitionFile>..\MFCObj\MFCBlackMoon.def</ModuleDefinitionFile>
    </Link>
    <Midl>
      <MkTypLibCompatible>false</MkTypLibCompatible>
      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
    </Midl>
    <ResourceCompile>
      <Culture>0x0804</Culture>
      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ResourceCompile>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDll|x64'">
    <ClCompile>
      <PrecompiledHeader>Use</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>_WINDOWS;NDEBUG;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <ModuleDefinitionFile>..\MFCObj\MFCBlackMoon.def</ModuleDefinitionFile>
    </Link>
    <Midl>
      <MkTypLibCompatible>false</MkTypLibCompatible>
      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
    </Midl>
    <ResourceCompile>
      <Culture>0x0804</Culture>
      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <AdditionalIncludeDirectories>$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ResourceCompile>
  </ItemDefinitionGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
</Project>

================================================
FILE: Project/MFCBlackMoon_VS2019.vcxproj.filters
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <Filter Include="源文件">
      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
    </Filter>
    <Filter Include="头文件">
      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
      <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
    </Filter>
    <Filter Include="资源文件">
      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
    </Filter>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="..\MFCObj\BlackMoonMFCdll.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\MFCObj\EyMFCComInit.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\MFCObj\MFCBlackMoon.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\MFCObj\MFCBlackMoonCon.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\MFCObj\StdAfx.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="..\MFCObj\EyMFCComInit.h">
      <Filter>头文件</Filter>
    </ClInclude>
    <ClInclude Include="..\MFCObj\MFCBlackMoon.h">
      <Filter>头文件</Filter>
    </ClInclude>
    <ClInclude Include="..\MFCObj\Resource.h">
      <Filter>头文件</Filter>
    </ClInclude>
    <ClInclude Include="..\MFCObj\StdAfx.h">
      <Filter>头文件</Filter>
    </ClInclude>
  </ItemGroup>
  <ItemGroup>
    <None Include="..\MFCObj\MFCBlackMoon.def">
      <Filter>源文件</Filter>
    </None>
    <None Include="..\MFCObj\res\MFCBlackMoon.rc2">
      <Filter>资源文件</Filter>
    </None>
  </ItemGroup>
  <ItemGroup>
    <ResourceCompile Include="..\MFCObj\MFCBlackMoon.rc">
      <Filter>资源文件</Filter>
    </ResourceCompile>
  </ItemGroup>
</Project>

================================================
FILE: Project/MFCBlackMoon_VS2019.vcxproj.user
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup />
</Project>

================================================
FILE: Project/krnln_VC6.dsp
================================================
# Microsoft Developer Studio Project File - Name="krnln" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **

# TARGTYPE "Win32 (x86) Static Library" 0x0104

CFG=krnln - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE 
!MESSAGE NMAKE /f "krnln_VC6.mak".
!MESSAGE 
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE 
!MESSAGE NMAKE /f "krnln_VC6.mak" CFG="krnln - Win32 Debug"
!MESSAGE 
!MESSAGE Possible choices for configuration are:
!MESSAGE 
!MESSAGE "krnln - Win32 Release" (based on "Win32 (x86) Static Library")
!MESSAGE "krnln - Win32 Debug" (based on "Win32 (x86) Static Library")
!MESSAGE 

# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe

!IF  "$(CFG)" == "krnln - Win32 Release"

# PROP BASE Use_MFC 2
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "..\Release"
# PROP BASE Intermediate_Dir ".\Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "..\Release"
# PROP Intermediate_Dir ".\Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_AFXDLL" /Yu"stdafx.h" /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /FR /Yu"stdafx.h" /FD /c
# ADD BASE RSC /l 0x804 /d "NDEBUG" /d "_AFXDLL"
# ADD RSC /l 0x804 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo /out:"..\Release\krnln.lib"

!ELSEIF  "$(CFG)" == "krnln - Win32 Debug"

# PROP BASE Use_MFC 2
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "..\Debug"
# PROP BASE Intermediate_Dir ".\Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "..\Debug"
# PROP Intermediate_Dir ".\Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_AFXDLL" /Yu"stdafx.h" /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /Yu"stdafx.h" /FD /GZ /c
# ADD BASE RSC /l 0x804 /d "_DEBUG" /d "_AFXDLL"
# ADD RSC /l 0x804 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo

!ENDIF 

# Begin Target

# Name "krnln - Win32 Release"
# Name "krnln - Win32 Debug"
# Begin Group "Source Files"

# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File

SOURCE="..\krnln\BlackMoonCallPropertyVaule.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\BlackMoonCallUserDll.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\BlackMoonLibNotifySys.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\CloneBinData.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\CloneTextData.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\DateTimeFormat.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\DllEntryFunc.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\eHelpFunc.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\FileManager.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\FreeAryElement.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\GetAryElementInf.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\GetDataTypeType.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\GetDatePart.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\GetDaysOfSpecMonth.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\GetRegRootVal.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\GetSpecTime.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\GetSysDataTypeDataSize.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\GetTimePart.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\GetWeekDay.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\HelpFunc12.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\IsInFileMangerList.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_abs.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_asc.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_atn.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_band.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_beep.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_bin.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_BinLeft.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_BinLen.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_BinMid.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_BinRight.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_BJCase.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_bnot.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_bor.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_bxor.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ChDir.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ChDrive.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_chr.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ClearClipBoard.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_close.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_cos.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_create.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_CryptOpen.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_CurDir.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_day.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_DeleteRegItem.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_Dispatch.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_DoEvents.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_exp.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_feof.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_fgets.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_FileCopy.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_FileDateTime.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_FileLen.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_FileMove.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_fix.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_fputs.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_FSeek.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetAllPY.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetAttr.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetBackColor.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetBinElement.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetBinRegItem.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetClipBoardText.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetCmdLine.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetColorCount.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetCursorHorzPos.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetCursorVertPos.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetDataTypeSize.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetDatePart.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetDaysOfSpecMonth.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetDiskFreeSpace.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetDiskLabel.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetDiskTotalSpace.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetEnv.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetHDiskCode.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetHostName.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetIntInsideBin.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetKeyText.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetLastError.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetNumRegItem.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetRunFileName.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetRunPath.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetRuntimeDataType.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetScreenHeight.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetScreenWidth.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetSectionNames.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetSpecTime.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetSysVer.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetTempFileName.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetTextRegItem.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetTickCount.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetTimePart.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_GetWinPic.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_hex.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_HostNameToIP.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_hour.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_IDiv.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_InBin.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_InBinRev.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_InputBox.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_InsBin.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_InsLine.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_InsText.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_InStr.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_InStrRev.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_int.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_IPToHostName.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_IsCalcOK.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_IsFileExist.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_IsHaveTextInClip.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_IsRegItemExist.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_kill.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_LCase.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_left.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_len.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_like.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_loc.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_lock.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_lof.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_log.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_LTrim.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_MakeLong.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_MakeWord.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_mid.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_minute.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_MkDir.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_mod.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_month.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_MsgBox.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_name.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_now.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_NumToRMB.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_NumToText.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_oct.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_open.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_OpenManyFileDialog.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_OpenMemFile.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_p2double.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_p2float.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_p2int.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_pbin.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ping.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_PlayMID.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_PlayMusic.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_PlayStop.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_pow.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_pstr.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_PutEnv.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_QJCase.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_randomize.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_read.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ReadBin.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ReadFile.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ReadLine.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ReadText.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_RemoveData.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ReplaceText.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_reset.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_RestroeCursor.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ReverseIntBytes.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_rgb.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_right.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_RmDir.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_rnd.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_round.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_RpBin.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_RpSubBin.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_RpSubText.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_RTrim.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_run.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_RunConsoleApp.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_SaveRegItem.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_second.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_SeekToBegin.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_SeekToEnd.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_SetAttr.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_SetClipBoardText.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_SetDiskLabel.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_SetIntInsideBin.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_SetKeyText.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_SetSysTime.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_SetWaitCursor.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_sgn.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_shl.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_shr.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_sin.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_sleep.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_SortAry.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_space.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_SpaceBin.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_split.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_SplitBin.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_sqr.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_str.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_StrComp.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_string.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_StrToUTF8.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_tan.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_TimeChg.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_TimeDiff.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_TimePart.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_TimeToText.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ToBin.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ToByte.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ToFloat.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ToInt.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ToLong.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ToShort.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ToTime.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_trim.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_TrimAll.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_UCase.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_Unlock.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_UNum.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_UTF8ToStr.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_val.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_Variant.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_WeekDay.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_write.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_WriteBin.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_WriteFile.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_WriteLine.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_WriteMem.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_WriteText.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_year.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\krnln_ZeroAry.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\LTrimZeroChr.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\md5t.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\mem.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\midi.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\Myfunctions.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\MyMemFile.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\NumToChinese.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\replaceText.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\SDataToStr.cpp"
# End Source File
# Begin Source File

SOURCE="..\krnln\StdAfx.cpp"
# ADD CPP /Yc"stdafx.h"
# End Source File
# End Group
# Begin Group "Header Files"

# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File

SOURCE="..\krnln\lib2.h"
# End Source File
# Begin Source File

SOURCE="..\krnln\LTrimZeroChr.h"
# End Source File
# Begin Source File

SOURCE="..\krnln\md5t.h"
# End Source File
# Begin Source File

SOURCE="..\krnln\mem.h"
# End Source File
# Begin Source File

SOURCE="..\krnln\midi.h"
# End Source File
# Begin Source File

SOURCE="..\krnln\Myfunctions.h"
# End Source File
# Begin Source File

SOURCE="..\krnln\MyMemFile.h"
# End Source File
# Begin Source File

SOURCE="..\krnln\StdAfx.h"
# End Source File
# End Group
# Begin Source File

SOURCE="..\Readme.txt"
# End Source File
# Begin Source File

SOURCE="..\krnln\Diskid32.obj"
# End Source File
# Begin Source File

SOURCE="..\krnln\PY.OBJ"
# End Source File
# End Target
# End Project


================================================
FILE: Project/krnln_VC6_Obj.dsp
================================================
# Microsoft Developer Studio Project File - Name="krnln_Obj" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **

# TARGTYPE "Win32 (x86) Static Library" 0x0104

CFG=krnln_Obj - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE 
!MESSAGE NMAKE /f "krnln_VC6_Obj.mak".
!MESSAGE 
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE 
!MESSAGE NMAKE /f "krnln_VC6_Obj.mak" CFG="krnln_Obj - Win32 Debug"
!MESSAGE 
!MESSAGE Possible choices for configuration are:
!MESSAGE 
!MESSAGE "krnln_Obj - Win32 Release" (based on "Win32 (x86) Static Library")
!MESSAGE "krnln_Obj - Win32 Debug" (based on "Win32 (x86) Static Library")
!MESSAGE 

# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe

!IF  "$(CFG)" == "krnln_Obj - Win32 Release"

# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "..\Release"
# PROP BASE Intermediate_Dir ".\Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "..\Release"
# PROP Intermediate_Dir ".\Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_LIB" /YX /FD /c
# ADD BASE RSC /l 0x804 /d "NDEBUG"
# ADD RSC /l 0x804 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo

!ELSEIF  "$(CFG)" == "krnln_Obj - Win32 Debug"

# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "..\Debug"
# PROP BASE Intermediate_Dir ".\Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
# ADD BASE RSC /l 0x804 /d "_DEBUG"
# ADD RSC /l 0x804 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo

!ENDIF 

# Begin Target

# Name "krnln_Obj - Win32 Release"
# Name "krnln_Obj - Win32 Debug"
# Begin Group "Source Files"

# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File

SOURCE=..\krnln\BlackMoonDll.cpp
# End Source File
# Begin Source File

SOURCE=..\krnln\BlackMoonDll2.cpp
# End Source File
# Begin Source File

SOURCE=..\krnln\BlackMoonExe.cpp
# End Source File
# Begin Source File

SOURCE=..\krnln\BlackMoonResDll.cpp
# End Source File
# Begin Source File

SOURCE=..\krnln\DllEntryFunc.cpp
# End Source File
# Begin Source File

SOURCE=..\krnln\EyComInit.cpp
# End Source File
# Begin Source File

SOURCE=..\krnln\EyInit.cpp
# End Source File
# End Group
# Begin Group "Header Files"

# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File

SOURCE=..\krnln\StdAfx.h
# End Source File
# End Group
# End Target
# End Project


================================================
FILE: Project/krnln_VS2019.vcxproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup Label="ProjectConfigurations">
    <ProjectConfiguration Include="Debug|Win32">
      <Configuration>Debug</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Debug|x64">
      <Configuration>Debug</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|x64">
      <Configuration>Release</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="..\krnln\BlackMoonCallPropertyVaule.cpp" />
    <ClCompile Include="..\krnln\BlackMoonCallUserDll.cpp" />
    <ClCompile Include="..\krnln\BlackMoonLibNotifySys.cpp" />
    <ClCompile Include="..\krnln\CloneBinData.cpp" />
    <ClCompile Include="..\krnln\CloneTextData.cpp" />
    <ClCompile Include="..\krnln\DateTimeFormat.cpp" />
    <ClCompile Include="..\krnln\DllEntryFunc.cpp" />
    <ClCompile Include="..\krnln\eHelpFunc.cpp" />
    <ClCompile Include="..\krnln\FileManager.cpp" />
    <ClCompile Include="..\krnln\FreeAryElement.cpp" />
    <ClCompile Include="..\krnln\GetAryElementInf.cpp" />
    <ClCompile Include="..\krnln\GetDataTypeType.cpp" />
    <ClCompile Include="..\krnln\GetDatePart.cpp" />
    <ClCompile Include="..\krnln\GetDaysOfSpecMonth.cpp" />
    <ClCompile Include="..\krnln\GetRegRootVal.cpp" />
    <ClCompile Include="..\krnln\GetSpecTime.cpp" />
    <ClCompile Include="..\krnln\GetSysDataTypeDataSize.cpp" />
    <ClCompile Include="..\krnln\GetTimePart.cpp" />
    <ClCompile Include="..\krnln\GetWeekDay.cpp" />
    <ClCompile Include="..\krnln\HelpFunc12.cpp" />
    <ClCompile Include="..\krnln\IsInFileMangerList.cpp" />
    <ClCompile Include="..\krnln\krnln_abs.cpp" />
    <ClCompile Include="..\krnln\krnln_asc.cpp" />
    <ClCompile Include="..\krnln\krnln_atn.cpp" />
    <ClCompile Include="..\krnln\krnln_band.cpp" />
    <ClCompile Include="..\krnln\krnln_beep.cpp" />
    <ClCompile Include="..\krnln\krnln_bin.cpp" />
    <ClCompile Include="..\krnln\krnln_BinLeft.cpp" />
    <ClCompile Include="..\krnln\krnln_BinLen.cpp" />
    <ClCompile Include="..\krnln\krnln_BinMid.cpp" />
    <ClCompile Include="..\krnln\krnln_BinRight.cpp" />
    <ClCompile Include="..\krnln\krnln_BJCase.cpp" />
    <ClCompile Include="..\krnln\krnln_bnot.cpp" />
    <ClCompile Include="..\krnln\krnln_bor.cpp" />
    <ClCompile Include="..\krnln\krnln_bxor.cpp" />
    <ClCompile Include="..\krnln\krnln_ChDir.cpp" />
    <ClCompile Include="..\krnln\krnln_ChDrive.cpp" />
    <ClCompile Include="..\krnln\krnln_chr.cpp" />
    <ClCompile Include="..\krnln\krnln_ClearClipBoard.cpp" />
    <ClCompile Include="..\krnln\krnln_close.cpp" />
    <ClCompile Include="..\krnln\krnln_cos.cpp" />
    <ClCompile Include="..\krnln\krnln_create.cpp" />
    <ClCompile Include="..\krnln\krnln_CryptOpen.cpp" />
    <ClCompile Include="..\krnln\krnln_CurDir.cpp" />
    <ClCompile Include="..\krnln\krnln_day.cpp" />
    <ClCompile Include="..\krnln\krnln_DeleteRegItem.cpp" />
    <ClCompile Include="..\krnln\krnln_Dispatch.cpp" />
    <ClCompile Include="..\krnln\krnln_DoEvents.cpp" />
    <ClCompile Include="..\krnln\krnln_exp.cpp" />
    <ClCompile Include="..\krnln\krnln_feof.cpp" />
    <ClCompile Include="..\krnln\krnln_fgets.cpp" />
    <ClCompile Include="..\krnln\krnln_FileCopy.cpp" />
    <ClCompile Include="..\krnln\krnln_FileDateTime.cpp" />
    <ClCompile Include="..\krnln\krnln_FileLen.cpp" />
    <ClCompile Include="..\krnln\krnln_FileMove.cpp" />
    <ClCompile Include="..\krnln\krnln_fix.cpp" />
    <ClCompile Include="..\krnln\krnln_fputs.cpp" />
    <ClCompile Include="..\krnln\krnln_FSeek.cpp" />
    <ClCompile Include="..\krnln\krnln_GetAllPY.cpp" />
    <ClCompile Include="..\krnln\krnln_GetAttr.cpp" />
    <ClCompile Include="..\krnln\krnln_GetBackColor.cpp" />
    <ClCompile Include="..\krnln\krnln_GetBinElement.cpp" />
    <ClCompile Include="..\krnln\krnln_GetBinRegItem.cpp" />
    <ClCompile Include="..\krnln\krnln_GetClipBoardText.cpp" />
    <ClCompile Include="..\krnln\krnln_GetCmdLine.cpp" />
    <ClCompile Include="..\krnln\krnln_GetColorCount.cpp" />
    <ClCompile Include="..\krnln\krnln_GetCursorHorzPos.cpp" />
    <ClCompile Include="..\krnln\krnln_GetCursorVertPos.cpp" />
    <ClCompile Include="..\krnln\krnln_GetDataTypeSize.cpp" />
    <ClCompile Include="..\krnln\krnln_GetDatePart.cpp" />
    <ClCompile Include="..\krnln\krnln_GetDaysOfSpecMonth.cpp" />
    <ClCompile Include="..\krnln\krnln_GetDiskFreeSpace.cpp" />
    <ClCompile Include="..\krnln\krnln_GetDiskLabel.cpp" />
    <ClCompile Include="..\krnln\krnln_GetDiskTotalSpace.cpp" />
    <ClCompile Include="..\krnln\krnln_GetEnv.cpp" />
    <ClCompile Include="..\krnln\krnln_GetHDiskCode.cpp" />
    <ClCompile Include="..\krnln\krnln_GetHostName.cpp" />
    <ClCompile Include="..\krnln\krnln_GetIntInsideBin.cpp" />
    <ClCompile Include="..\krnln\krnln_GetKeyText.cpp" />
    <ClCompile Include="..\krnln\krnln_GetLastError.cpp" />
    <ClCompile Include="..\krnln\krnln_GetNumRegItem.cpp" />
    <ClCompile Include="..\krnln\krnln_GetRunFileName.cpp" />
    <ClCompile Include="..\krnln\krnln_GetRunPath.cpp" />
    <ClCompile Include="..\krnln\krnln_GetRuntimeDataType.cpp" />
    <ClCompile Include="..\krnln\krnln_GetScreenHeight.cpp" />
    <ClCompile Include="..\krnln\krnln_GetScreenWidth.cpp" />
    <ClCompile Include="..\krnln\krnln_GetSectionNames.cpp" />
    <ClCompile Include="..\krnln\krnln_GetSpecTime.cpp" />
    <ClCompile Include="..\krnln\krnln_GetSysVer.cpp" />
    <ClCompile Include="..\krnln\krnln_GetTempFileName.cpp" />
    <ClCompile Include="..\krnln\krnln_GetTextRegItem.cpp" />
    <ClCompile Include="..\krnln\krnln_GetTickCount.cpp" />
    <ClCompile Include="..\krnln\krnln_GetTimePart.cpp" />
    <ClCompile Include="..\krnln\krnln_GetWinPic.cpp" />
    <ClCompile Include="..\krnln\krnln_hex.cpp" />
    <ClCompile Include="..\krnln\krnln_HostNameToIP.cpp" />
    <ClCompile Include="..\krnln\krnln_hour.cpp" />
    <ClCompile Include="..\krnln\krnln_IDiv.cpp" />
    <ClCompile Include="..\krnln\krnln_InBin.cpp" />
    <ClCompile Include="..\krnln\krnln_InBinRev.cpp" />
    <ClCompile Include="..\krnln\krnln_InputBox.cpp" />
    <ClCompile Include="..\krnln\krnln_InsBin.cpp" />
    <ClCompile Include="..\krnln\krnln_InsLine.cpp" />
    <ClCompile Include="..\krnln\krnln_InsText.cpp" />
    <ClCompile Include="..\krnln\krnln_InStr.cpp" />
    <ClCompile Include="..\krnln\krnln_InStrRev.cpp" />
    <ClCompile Include="..\krnln\krnln_int.cpp" />
    <ClCompile Include="..\krnln\krnln_IPToHostName.cpp" />
    <ClCompile Include="..\krnln\krnln_IsCalcOK.cpp" />
    <ClCompile Include="..\krnln\krnln_IsDebugVer.cpp" />
    <ClCompile Include="..\krnln\krnln_IsFileExist.cpp" />
    <ClCompile Include="..\krnln\krnln_IsHaveTextInClip.cpp" />
    <ClCompile Include="..\krnln\krnln_IsRegItemExist.cpp" />
    <ClCompile Include="..\krnln\krnln_kill.cpp" />
    <ClCompile Include="..\krnln\krnln_LCase.cpp" />
    <ClCompile Include="..\krnln\krnln_left.cpp" />
    <ClCompile Include="..\krnln\krnln_len.cpp" />
    <ClCompile Include="..\krnln\krnln_like.cpp" />
    <ClCompile Include="..\krnln\krnln_loc.cpp" />
    <ClCompile Include="..\krnln\krnln_lock.cpp" />
    <ClCompile Include="..\krnln\krnln_lof.cpp" />
    <ClCompile Include="..\krnln\krnln_log.cpp" />
    <ClCompile Include="..\krnln\krnln_LTrim.cpp" />
    <ClCompile Include="..\krnln\krnln_MakeLong.cpp" />
    <ClCompile Include="..\krnln\krnln_MakeWord.cpp" />
    <ClCompile Include="..\krnln\krnln_mid.cpp" />
    <ClCompile Include="..\krnln\krnln_minute.cpp" />
    <ClCompile Include="..\krnln\krnln_MkDir.cpp" />
    <ClCompile Include="..\krnln\krnln_mod.cpp" />
    <ClCompile Include="..\krnln\krnln_month.cpp" />
    <ClCompile Include="..\krnln\krnln_MsgBox.cpp" />
    <ClCompile Include="..\krnln\krnln_name.cpp" />
    <ClCompile Include="..\krnln\krnln_now.cpp" />
    <ClCompile Include="..\krnln\krnln_NumToRMB.cpp" />
    <ClCompile Include="..\krnln\krnln_NumToText.cpp" />
    <ClCompile Include="..\krnln\krnln_oct.cpp" />
    <ClCompile Include="..\krnln\krnln_open.cpp" />
    <ClCompile Include="..\krnln\krnln_OpenManyFileDialog.cpp" />
    <ClCompile Include="..\krnln\krnln_OpenMemFile.cpp" />
    <ClCompile Include="..\krnln\krnln_p2double.cpp" />
    <ClCompile Include="..\krnln\krnln_p2float.cpp" />
    <ClCompile Include="..\krnln\krnln_p2int.cpp" />
    <ClCompile Include="..\krnln\krnln_pbin.cpp" />
    <ClCompile Include="..\krnln\krnln_ping.cpp" />
    <ClCompile Include="..\krnln\krnln_PlayMID.cpp" />
    <ClCompile Include="..\krnln\krnln_PlayMusic.cpp" />
    <ClCompile Include="..\krnln\krnln_PlayStop.cpp" />
    <ClCompile Include="..\krnln\krnln_pow.cpp" />
    <ClCompile Include="..\krnln\krnln_pstr.cpp" />
    <ClCompile Include="..\krnln\krnln_PutEnv.cpp" />
    <ClCompile Include="..\krnln\krnln_QJCase.cpp" />
    <ClCompile Include="..\krnln\krnln_randomize.cpp" />
    <ClCompile Include="..\krnln\krnln_read.cpp" />
    <ClCompile Include="..\krnln\krnln_ReadBin.cpp" />
    <ClCompile Include="..\krnln\krnln_ReadFile.cpp" />
    <ClCompile Include="..\krnln\krnln_ReadLine.cpp" />
    <ClCompile Include="..\krnln\krnln_ReadText.cpp" />
    <ClCompile Include="..\krnln\krnln_RemoveData.cpp" />
    <ClCompile Include="..\krnln\krnln_ReplaceText.cpp" />
    <ClCompile Include="..\krnln\krnln_reset.cpp" />
    <ClCompile Include="..\krnln\krnln_RestroeCursor.cpp" />
    <ClCompile Include="..\krnln\krnln_ReverseIntBytes.cpp" />
    <ClCompile Include="..\krnln\krnln_rgb.cpp" />
    <ClCompile Include="..\krnln\krnln_right.cpp" />
    <ClCompile Include="..\krnln\krnln_RmDir.cpp" />
    <ClCompile Include="..\krnln\krnln_rnd.cpp" />
    <ClCompile Include="..\krnln\krnln_round.cpp" />
    <ClCompile Include="..\krnln\krnln_RpBin.cpp" />
    <ClCompile Include="..\krnln\krnln_RpSubBin.cpp" />
    <ClCompile Include="..\krnln\krnln_RpSubText.cpp" />
    <ClCompile Include="..\krnln\krnln_RTrim.cpp" />
    <ClCompile Include="..\krnln\krnln_run.cpp" />
    <ClCompile Include="..\krnln\krnln_RunConsoleApp.cpp" />
    <ClCompile Include="..\krnln\krnln_SaveRegItem.cpp" />
    <ClCompile Include="..\krnln\krnln_second.cpp" />
    <ClCompile Include="..\krnln\krnln_SeekToBegin.cpp" />
    <ClCompile Include="..\krnln\krnln_SeekToEnd.cpp" />
    <ClCompile Include="..\krnln\krnln_SetAttr.cpp" />
    <ClCompile Include="..\krnln\krnln_SetClipBoardText.cpp" />
    <ClCompile Include="..\krnln\krnln_SetDiskLabel.cpp" />
    <ClCompile Include="..\krnln\krnln_SetIntInsideBin.cpp" />
    <ClCompile Include="..\krnln\krnln_SetKeyText.cpp" />
    <ClCompile Include="..\krnln\krnln_SetSysTime.cpp" />
    <ClCompile Include="..\krnln\krnln_SetWaitCursor.cpp" />
    <ClCompile Include="..\krnln\krnln_sgn.cpp" />
    <ClCompile Include="..\krnln\krnln_shl.cpp" />
    <ClCompile Include="..\krnln\krnln_shr.cpp" />
    <ClCompile Include="..\krnln\krnln_sin.cpp" />
    <ClCompile Include="..\krnln\krnln_sleep.cpp" />
    <ClCompile Include="..\krnln\krnln_SortAry.cpp" />
    <ClCompile Include="..\krnln\krnln_space.cpp" />
    <ClCompile Include="..\krnln\krnln_SpaceBin.cpp" />
    <ClCompile Include="..\krnln\krnln_split.cpp" />
    <ClCompile Include="..\krnln\krnln_SplitBin.cpp" />
    <ClCompile Include="..\krnln\krnln_sqr.cpp" />
    <ClCompile Include="..\krnln\krnln_str.cpp" />
    <ClCompile Include="..\krnln\krnln_StrComp.cpp" />
    <ClCompile Include="..\krnln\krnln_string.cpp" />
    <ClCompile Include="..\krnln\krnln_StrToUTF8.cpp" />
    <ClCompile Include="..\krnln\krnln_tan.cpp" />
    <ClCompile Include="..\krnln\krnln_TimeChg.cpp" />
    <ClCompile Include="..\krnln\krnln_TimeDiff.cpp" />
    <ClCompile Include="..\krnln\krnln_TimePart.cpp" />
    <ClCompile Include="..\krnln\krnln_TimeToText.cpp" />
    <ClCompile Include="..\krnln\krnln_ToBin.cpp" />
    <ClCompile Include="..\krnln\krnln_ToByte.cpp" />
    <ClCompile Include="..\krnln\krnln_ToFloat.cpp" />
    <ClCompile Include="..\krnln\krnln_ToInt.cpp" />
    <ClCompile Include="..\krnln\krnln_ToLong.cpp" />
    <ClCompile Include="..\krnln\krnln_ToShort.cpp" />
    <ClCompile Include="..\krnln\krnln_ToTime.cpp" />
    <ClCompile Include="..\krnln\krnln_trim.cpp" />
    <ClCompile Include="..\krnln\krnln_TrimAll.cpp" />
    <ClCompile Include="..\krnln\krnln_UCase.cpp" />
    <ClCompile Include="..\krnln\krnln_Unlock.cpp" />
    <ClCompile Include="..\krnln\krnln_UNum.cpp" />
    <ClCompile Include="..\krnln\krnln_UTF8ToStr.cpp" />
    <ClCompile Include="..\krnln\krnln_val.cpp" />
    <ClCompile Include="..\krnln\krnln_Variant.cpp" />
    <ClCompile Include="..\krnln\krnln_WeekDay.cpp" />
    <ClCompile Include="..\krnln\krnln_write.cpp" />
    <ClCompile Include="..\krnln\krnln_WriteBin.cpp" />
    <ClCompile Include="..\krnln\krnln_WriteFile.cpp" />
    <ClCompile Include="..\krnln\krnln_WriteLine.cpp" />
    <ClCompile Include="..\krnln\krnln_WriteMem.cpp" />
    <ClCompile Include="..\krnln\krnln_WriteText.cpp" />
    <ClCompile Include="..\krnln\krnln_year.cpp" />
    <ClCompile Include="..\krnln\krnln_ZeroAry.cpp" />
    <ClCompile Include="..\krnln\LTrimZeroChr.cpp" />
    <ClCompile Include="..\krnln\md5t.cpp" />
    <ClCompile Include="..\krnln\mem.cpp" />
    <ClCompile Include="..\krnln\midi.cpp" />
    <ClCompile Include="..\krnln\Myfunctions.cpp" />
    <ClCompile Include="..\krnln\MyMemFile.cpp" />
    <ClCompile Include="..\krnln\NumToChinese.cpp" />
    <ClCompile Include="..\krnln\replaceText.cpp" />
    <ClCompile Include="..\krnln\SDataToStr.cpp" />
    <ClCompile Include="..\krnln\StdAfx.cpp" />
  </ItemGroup>
  <ItemGroup>
    <Object Include="..\krnln\Diskid32.obj" />
    <Object Include="..\krnln\PY.OBJ" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="..\krnln\lib2.h" />
    <ClInclude Include="..\krnln\LTrimZeroChr.h" />
    <ClInclude Include="..\krnln\md5t.h" />
    <ClInclude Include="..\krnln\mem.h" />
    <ClInclude Include="..\krnln\midi.h" />
    <ClInclude Include="..\krnln\Myfunctions.h" />
    <ClInclude Include="..\krnln\MyMemFile.h" />
    <ClInclude Include="..\krnln\StdAfx.h" />
  </ItemGroup>
  <ItemGroup>
    <Text Include="..\Readme.txt" />
  </ItemGroup>
  <PropertyGroup Label="Globals">
    <VCProjectVersion>16.0</VCProjectVersion>
    <ProjectGuid>{90C7C825-74BF-4F91-BF9C-4A1E762F24B9}</ProjectGuid>
    <Keyword>Win32Proj</Keyword>
    <RootNamespace>krnln</RootNamespace>
    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
    <ProjectName>krnln</ProjectName>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v142</PlatformToolset>
    <CharacterSet>MultiByte</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v142</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>MultiByte</CharacterSet>
    <EnableUnitySupport>false</EnableUnitySupport>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v142</PlatformToolset>
    <CharacterSet>MultiByte</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v142</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>MultiByte</CharacterSet>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
  </ImportGroup>
  <ImportGroup Label="Shared">
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <LinkIncremental>true</LinkIncremental>
    <TargetName>krnln</TargetName>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <LinkIncremental>true</LinkIncremental>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <LinkIncremental>false</LinkIncremental>
    <TargetName>krnln</TargetName>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <LinkIncremental>false</LinkIncremental>
  </PropertyGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <ClCompile>
      <PrecompiledHeader>NotUsing</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <SDLCheck>false</SDLCheck>
      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <PrecompiledHeaderFile>StdAfx.h</PrecompiledHeaderFile>
      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <ClCompile>
      <PrecompiledHeader>Use</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <ClCompile>
      <PrecompiledHeader>NotUsing</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>false</SDLCheck>
      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <PrecompiledHeaderFile>StdAfx.h</PrecompiledHeaderFile>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <WholeProgramOptimization>false</WholeProgramOptimization>
      <MultiProcessorCompilation>
      </MultiProcessorCompilation>
      <BufferSecurityCheck>true</BufferSecurityCheck>
      <PrecompiledHeaderOutputFile />
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <ClCompile>
      <PrecompiledHeader>Use</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
</Project>

================================================
FILE: Project/krnln_VS2019.vcxproj.filters
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <Filter Include="源文件">
      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
    </Filter>
    <Filter Include="头文件">
      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
      <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
    </Filter>
    <Filter Include="资源文件">
      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
    </Filter>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="..\krnln\BlackMoonCallPropertyVaule.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\BlackMoonCallUserDll.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\BlackMoonLibNotifySys.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\CloneBinData.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\CloneTextData.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\DateTimeFormat.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\DllEntryFunc.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\eHelpFunc.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\FileManager.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\FreeAryElement.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\GetAryElementInf.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\GetDataTypeType.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\GetDatePart.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\GetDaysOfSpecMonth.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\GetRegRootVal.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\GetSpecTime.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\GetSysDataTypeDataSize.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\GetTimePart.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\GetWeekDay.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\HelpFunc12.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\IsInFileMangerList.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_abs.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_asc.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_atn.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_band.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_beep.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_bin.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_BinLeft.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_BinLen.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_BinMid.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_BinRight.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_BJCase.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_bnot.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_bor.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_bxor.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ChDir.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ChDrive.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_chr.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ClearClipBoard.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_close.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_cos.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_CryptOpen.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_CurDir.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_day.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_DeleteRegItem.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_Dispatch.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_DoEvents.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_exp.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_feof.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_fgets.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_FileCopy.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_FileDateTime.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_FileLen.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_FileMove.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_fix.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_fputs.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_FSeek.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetAllPY.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetAttr.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetBackColor.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetBinElement.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetBinRegItem.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetClipBoardText.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetCmdLine.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetColorCount.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetCursorHorzPos.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetCursorVertPos.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetDataTypeSize.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetDatePart.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetDaysOfSpecMonth.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetDiskFreeSpace.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetDiskLabel.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetDiskTotalSpace.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetEnv.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetHDiskCode.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetHostName.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetIntInsideBin.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetKeyText.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetLastError.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetNumRegItem.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetRunFileName.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetRunPath.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetRuntimeDataType.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetScreenHeight.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetScreenWidth.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetSectionNames.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetSpecTime.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetSysVer.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetTempFileName.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetTextRegItem.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetTickCount.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetTimePart.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_GetWinPic.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_hex.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_HostNameToIP.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_hour.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_IDiv.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_InBin.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_InBinRev.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_InputBox.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_InsBin.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_InsLine.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_InsText.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_InStr.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_InStrRev.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_int.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_IPToHostName.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_IsCalcOK.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_IsDebugVer.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_IsFileExist.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_IsHaveTextInClip.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_IsRegItemExist.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_kill.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_LCase.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_left.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_len.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_like.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_loc.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_lock.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_lof.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_log.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_LTrim.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_MakeLong.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_MakeWord.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_mid.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_minute.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_MkDir.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_mod.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_month.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_MsgBox.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_name.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_now.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_NumToRMB.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_NumToText.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_oct.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_open.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_OpenManyFileDialog.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_OpenMemFile.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_p2double.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_p2float.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_p2int.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_pbin.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ping.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_PlayMID.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_PlayMusic.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_PlayStop.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_pow.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_pstr.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_PutEnv.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_QJCase.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_randomize.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_read.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ReadBin.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ReadFile.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ReadLine.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ReadText.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_RemoveData.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ReplaceText.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_reset.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_RestroeCursor.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ReverseIntBytes.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_rgb.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_right.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_RmDir.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_rnd.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_round.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_RpBin.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_RpSubBin.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_RpSubText.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_RTrim.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_run.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_RunConsoleApp.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_SaveRegItem.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_second.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_SeekToBegin.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_SeekToEnd.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_SetAttr.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_SetClipBoardText.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_SetDiskLabel.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_SetIntInsideBin.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_SetKeyText.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_SetSysTime.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_SetWaitCursor.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_sgn.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_shl.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_shr.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_sin.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_sleep.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_SortAry.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_space.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_SpaceBin.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_split.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_SplitBin.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_sqr.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_str.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_StrComp.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_string.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_StrToUTF8.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_tan.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_TimeChg.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_TimeDiff.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_TimePart.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_TimeToText.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ToBin.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ToByte.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ToFloat.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ToInt.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ToLong.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ToShort.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ToTime.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_trim.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_TrimAll.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_UCase.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_Unlock.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_UNum.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_UTF8ToStr.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_val.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_Variant.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_WeekDay.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_write.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_WriteBin.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_WriteFile.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_WriteLine.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_WriteMem.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_WriteText.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_year.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_ZeroAry.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\LTrimZeroChr.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\md5t.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\mem.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\midi.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\Myfunctions.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\MyMemFile.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\NumToChinese.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\replaceText.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\SDataToStr.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\StdAfx.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\krnln_create.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <Object Include="..\krnln\Diskid32.obj" />
    <Object Include="..\krnln\PY.OBJ" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="..\krnln\lib2.h">
      <Filter>头文件</Filter>
    </ClInclude>
    <ClInclude Include="..\krnln\LTrimZeroChr.h">
      <Filter>头文件</Filter>
    </ClInclude>
    <ClInclude Include="..\krnln\md5t.h">
      <Filter>头文件</Filter>
    </ClInclude>
    <ClInclude Include="..\krnln\mem.h">
      <Filter>头文件</Filter>
    </ClInclude>
    <ClInclude Include="..\krnln\midi.h">
      <Filter>头文件</Filter>
    </ClInclude>
    <ClInclude Include="..\krnln\Myfunctions.h">
      <Filter>头文件</Filter>
    </ClInclude>
    <ClInclude Include="..\krnln\MyMemFile.h">
      <Filter>头文件</Filter>
    </ClInclude>
    <ClInclude Include="..\krnln\StdAfx.h">
      <Filter>头文件</Filter>
    </ClInclude>
  </ItemGroup>
  <ItemGroup>
    <Text Include="..\Readme.txt" />
  </ItemGroup>
</Project>

================================================
FILE: Project/krnln_VS2019.vcxproj.user
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <LocalDebuggerWorkingDirectory>$(ProjectDir)</LocalDebuggerWorkingDirectory>
    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
  </PropertyGroup>
  <PropertyGroup>
    <ShowAllFiles>false</ShowAllFiles>
  </PropertyGroup>
</Project>

================================================
FILE: Project/krnln_VS2019_Obj.vcxproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup Label="ProjectConfigurations">
    <ProjectConfiguration Include="Debug|Win32">
      <Configuration>Debug</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Debug|x64">
      <Configuration>Debug</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|x64">
      <Configuration>Release</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="..\krnln\BlackMoonDll.cpp" />
    <ClCompile Include="..\krnln\BlackMoonDll2.cpp" />
    <ClCompile Include="..\krnln\BlackMoonExe.cpp" />
    <ClCompile Include="..\krnln\BlackMoonResDll.cpp" />
    <ClCompile Include="..\krnln\EyComInit.cpp" />
    <ClCompile Include="..\krnln\EyInit.cpp" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="..\krnln\StdAfx.h" />
  </ItemGroup>
  <PropertyGroup Label="Globals">
    <VCProjectVersion>16.0</VCProjectVersion>
    <ProjectGuid>{9EF1C5E2-3C57-47CE-9F68-DACA1CD298D4}</ProjectGuid>
    <Keyword>Win32Proj</Keyword>
    <RootNamespace>krnln_Obj</RootNamespace>
    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
    <ProjectName>krnln_Obj</ProjectName>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v142</PlatformToolset>
    <CharacterSet>MultiByte</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v142</PlatformToolset>
    <WholeProgramOptimization>false</WholeProgramOptimization>
    <CharacterSet>MultiByte</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v142</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v142</PlatformToolset>
    <WholeProgramOptimization>true</WholeProgramOptimization>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
  </ImportGroup>
  <ImportGroup Label="Shared">
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <LinkIncremental>true</LinkIncremental>
    <TargetName>krnln</TargetName>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <LinkIncremental>true</LinkIncremental>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <LinkIncremental>false</LinkIncremental>
    <TargetName>krnln</TargetName>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <LinkIncremental>false</LinkIncremental>
  </PropertyGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <ClCompile>
      <PrecompiledHeader>NotUsing</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <SDLCheck>false</SDLCheck>
      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <PrecompiledHeaderFile>StdAfx.h</PrecompiledHeaderFile>
      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
      <PrecompiledHeaderOutputFile />
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
    <PostBuildEvent>
      <Command>
      </Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <ClCompile>
      <PrecompiledHeader>Use</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <ClCompile>
      <PrecompiledHeader>NotUsing</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>false</SDLCheck>
      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <PrecompiledHeaderFile>StdAfx.h</PrecompiledHeaderFile>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <PrecompiledHeaderOutputFile />
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <ClCompile>
      <PrecompiledHeader>Use</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>MaxSpeed</Optimization>
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
    </Link>
  </ItemDefinitionGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
</Project>

================================================
FILE: Project/krnln_VS2019_Obj.vcxproj.filters
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <Filter Include="源文件">
      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
    </Filter>
    <Filter Include="头文件">
      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
      <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
    </Filter>
    <Filter Include="资源文件">
      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
    </Filter>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="..\krnln\BlackMoonDll.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\BlackMoonDll2.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\BlackMoonResDll.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\EyComInit.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\EyInit.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
    <ClCompile Include="..\krnln\BlackMoonExe.cpp">
      <Filter>源文件</Filter>
    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="..\krnln\StdAfx.h">
      <Filter>头文件</Filter>
    </ClInclude>
  </ItemGroup>
</Project>

================================================
FILE: Project/krnln_VS2019_Obj.vcxproj.user
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup />
</Project>

================================================
FILE: README.md
================================================
## 黑月核心静态库

[![BlackMoon Krnln](https://github.com/TheSnowfield/BlackMoonKernelStaticLib/workflows/BlackMoon%20Krnln/badge.svg)](#)
[![BlackMoon Krnln OBJ](https://github.com/TheSnowfield/BlackMoonKernelStaticLib/workflows/BlackMoon%20Krnln%20OBJ/badge.svg)](#)
[![BlackMoon MFC](https://github.com/TheSnowfield/BlackMoonKernelStaticLib/workflows/BlackMoon%20MFC/badge.svg)](#)

## 编译与安装
  1. 根据你电脑上所安装的VS版本，打开对应的工程文件
  2. 打开工程后能看见三个方案：krnln、krnln_Obj、MFCBlackMoon。  
    通常情况下你不需要理会后两者，除非你知道它的作用。选中krnln方案，切换配置为Release，并编译。
  3. 编译后，将release目录下的kernel.lib替换到易语言安装目录的  
  \BlackMoon\obj\kernel.lib。(黑月4.0以上版本)  
  \BlackMoon\lib\kernel.lib。(黑月4.0以下版本)

## 源码使用事项
  原则上，只要不是商业用途及非法用途，源码可以任意使用及传播，
  编译后的静态库文件kernel.lib可以用于编译链接到商业作品中。  
  在复制与传播时，必须注明开源地址：  
  https://github.com/zhongjianhua163/BlackMoonKernelStaticLib (国外服务器)  
  https://gitee.com/zhongjianhua163/BlackMoonKernelStaticLib (国内服务器)

## 代码编写规范
  如果你想参与更新、优化或修复BUG，请仔细阅读以下事项：
  1. 代码的必须能让所有版本的VS通过编译，若需要使用特定版本的VS的特性，
    则需要合理使用宏 _MSC_VER 来进行兼容。
  2. 变量、常量、函数等命名时尽量能准确表达其属性及用途。
  3. 少用或尽量不要用内联汇编。
    如果必须要用到内联汇编，则尽量不要使用新的指令集，如SSE\AVX等。
    如果必须要用到新的指令集，请务必做好自适配代码，确保老的CPU及远古级别的
    32位CPU能正常运行，并实现指定效果。(常规做法是编写两份代码，一份使用新
    的指令集，另一份使用常规指令集，并根据用户的CPU所支持的指令集来进行调用)
  4. 确保代码的简洁美观、高效、稳定及安全性。
  5. 确保函数的参数、返回值及运行效果与易语言原生核心库保持一致。
  6. 编辑的源代码文件的时候，请使用ANSI和GB2312编码，切勿使用UTF8或其他编码。
  7. 使用git来push前，请将自动替换换行符功能: autoCRLF 设置为 false。

## 参与贡献
  1. 可以加入此开源项目的管理团队
  2. 可以在GitHub或Gitee中通过Issues页面提交错误和改进建议
  3. 可以在GitHub或Gitee中`Fork`, 修改后通过`Pull Request`合并代码


## 许可证
原作者：云外归鸟  
后续升级：泪闯天涯(邓学彬)  
后续优化：被封七号  
  
根据 `BSD 3-Clause` 获得许可


================================================
FILE: Readme.txt
================================================
========================================================================
       黑月编译器插件的核心静态库开源相关事项
========================================================================

原作者：云外归鸟
后续升级：泪闯天涯(邓学彬)
后续优化：被封七号

一、编译与安装
  1.根据你电脑上所安装的VS版本，打开对应的工程文件
  2.打开工程后能看见三个方案：krnln、krnln_Obj、MFCBlackMoon。
    通常情况下你不需要理会后两者，除非你知道它的作用。
	选中krnln方案，切换配置为Release，并编译。
  3.编译后，将release目录下的kernel.lib替换到易语言安装目录的
    \BlackMoon\obj\kernel.lib。(黑月4.0以上版本)
	\BlackMoon\lib\kernel.lib。(黑月4.0以下版本)

二、源码使用事项
  原则上，只要不是商业用途及非法用途，源码可以任意使用及传播，
  编译后的静态库文件kernel.lib可以用于编译链接到商业作品中。
  在复制与传播时，必须注明开源地址：
  https://github.com/zhongjianhua163/BlackMoonKernelStaticLib  (国外服务器)
  https://gitee.com/zhongjianhua163/BlackMoonKernelStaticLib   (国内服务器)
  
三、代码编写规范
  如果你想参与更新、优化或修复BUG，请仔细阅读以下事项：
  0.代码的必须能让所有版本的VS通过编译，若需要使用特定版本的VS的特性，
    则需要合理使用宏 _MSC_VER 来进行兼容。
  1.变量、常量、函数等命名时尽量能准确表达其属性及用途。
  2.少用或尽量不要用内联汇编。
    如果必须要用到内联汇编，则尽量不要使用新的指令集，如SSE\AVX等。
    如果必须要用到新的指令集，请务必做好自适配代码，确保老的CPU及远古级别的
    32位CPU能正常运行，并实现指定效果。(常规做法是编写两份代码，一份使用新
    的指令集，另一份使用常规指令集，并根据用户的CPU所支持的指令集来进行调用)
  3.确保代码的简洁美观、高效、稳定及安全性。
  4.确保函数的参数、返回值及运行效果与易语言原生核心库保持一致。
  5.编辑的源代码文件的时候，请使用ANSI和GB2312编码，切勿使用UTF8或其他编码。
  6.使用git来push前，请将自动替换换行符功能: autoCRLF 设置为 false。

四、如何参与到项目开发中来？
  1.可以加入此开源项目的管理团队
  2.可以在github或gitee中通过Issues页面提交错误和改进建议
  3.可以在github或gitee中 fork, 修改后通过 pull request 合并代码

  
/////////////////////////////////////////////////////////////////////////////


================================================
FILE: krnln/BlackMoonCallPropertyVaule.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
EXTERN_C void  _cdecl BlackMoonGetClassPropertyVaule(
	INT nIDX,HUNIT hUnit, INT nPropertyIndex,INT nRevrev)
{
	PFN_GET_PROPERTY_DATA pfn;
	_asm mov pfn,eax;
	UNIT_PROPERTY_VALUE sProperty;
	sProperty.m_data.m_nDataSize=0;
	sProperty.m_data.m_pData = 0;
	pfn(hUnit,nPropertyIndex,&sProperty);

	if(nIDX && nPropertyIndex < 32)
	{

		BOOL bIsText = (nIDX >> nPropertyIndex) & 1;
		if(bIsText)
		{
			char* pStr=CloneTextData(sProperty.m_szText,mystrlen(sProperty.m_szText));
			sProperty.m_szText = pStr;
		}
	}

	_asm mov eax,sProperty.m_int;
	_asm mov edx,sProperty.m_data.m_nDataSize;
}

EXTERN_C void  _cdecl BlackMoonSetClassPropertyVaule(
	INT nIDX,HUNIT hUnit, INT nPropertyIndex,INT nRevrev,UNIT_PROPERTY_VALUE sProperty,...)
{

	PFN_NOTIFY_PROPERTY_CHANGED pfn;
	_asm mov pfn,eax;
	pfn(hUnit, nPropertyIndex, &sProperty, NULL);

}

================================================
FILE: krnln/BlackMoonCallUserDll.cpp
================================================
#include "stdafx.h"
extern "C" PDESTROY BlackMoonFreeAllUserDll;

HMODULE BMUserDllList[100] = {0};
INT nBMUserDllCount = 0;

void BlackMoonFreeALLUserDllFunc(){
	for(INT i=0;i<100;i++){
		if(BMUserDllList[i]==NULL)
			break;
		::FreeLibrary (BMUserDllList[i]);

	}

}
extern "C" 
void* _stdcall BlackMoonCallUserDllFunc (char* pDll,char* pName,void** pFunc)
{
	char ErrorString [1024];
	HMODULE hMod = ::GetModuleHandle (pDll);
	int nNoErrorBox = 0;
	if(hMod==NULL){
		hMod = ::LoadLibrary (pDll);
		if(hMod==NULL){

  			wsprintf(ErrorString, "ͬĿ¼޷ҵDLLļ:\"%s\".ϵ.", pDll);
			if (fnEError_callback)
				nNoErrorBox = fnEError_callback(0, ErrorString);

			if (!nNoErrorBox)
  				MessageBox(0, ErrorString, "DLL ERROR", MB_ICONERROR);
			E_End(0);
		}
		BMUserDllList[nBMUserDllCount] = hMod;
		
		if(nBMUserDllCount==0)
			BlackMoonFreeAllUserDll = (PDESTROY)BlackMoonFreeALLUserDllFunc;
		nBMUserDllCount++;
	}
	char* pFuncName = NULL;
	if(pName[0]=='#')
		pFuncName=(char*)atoi(pName+1);
	else
	{
		strcpy(ErrorString, pName);
		pFuncName = ErrorString;
		char* pStr = strchr(pFuncName,'@');
		if(pStr && pStr[1]=='@')
			pStr[0]=0;
		
	}

	FARPROC pf = ::GetProcAddress (hMod,pFuncName);
	if(pf==NULL){
  		wsprintf(ErrorString, "޷λDLLļ:\"%s\"е\"%s\".", pDll,pName);
		if (fnEError_callback)
			nNoErrorBox = fnEError_callback(0, ErrorString);

		if (!nNoErrorBox)
  			MessageBox(0, ErrorString, "DLL ERROR", MB_ICONERROR);
		E_End(0);
	}
	
	*pFunc = pf;
		
	return pf;
}

================================================
FILE: krnln/BlackMoonDll.cpp
================================================
#include "stdafx.h"
INT nBMProtectESP = 0;
INT nBMProtectEBP = 0;
PDESTROY DllEntryFunc();
extern HANDLE hBlackMoonInstanceHandle;
extern "C" PDESTROY DestroyAddress;
extern "C" {

	//PDESTROY ECodeStart();

	int __stdcall DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
	{

		switch (ul_reason_for_call)
		{
		case DLL_PROCESS_ATTACH:
			hBlackMoonInstanceHandle = hModule;
			E_Init();
			DestroyAddress = DllEntryFunc();
			break;
		case DLL_PROCESS_DETACH:
			E_DestroyRes();
			break;
			
			
		}
		
		return 1;
		
	}

}

================================================
FILE: krnln/BlackMoonDll2.cpp
================================================
#include "stdafx.h"
INT nBMProtectESP = 0;
INT nBMProtectEBP = 0;
PDESTROY DllEntryFunc();
extern HANDLE hBlackMoonInstanceHandle;
extern "C" PDESTROY DestroyAddress;
extern "C" {

	//PDESTROY ECodeStart();
	int __stdcall EDllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 );

	int __stdcall DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
	{

		switch (ul_reason_for_call)
		{
		case DLL_PROCESS_ATTACH:
			hBlackMoonInstanceHandle = hModule;
			E_Init();			
			DestroyAddress = DllEntryFunc();
			break;
		case DLL_PROCESS_DETACH:
			E_DestroyRes();
			break;
		}
		
		return EDllMain(hModule,ul_reason_for_call,lpReserved);
		
	}

}

================================================
FILE: krnln/BlackMoonExe.cpp
================================================
#include "stdafx.h"
extern "C" int ECodeStart();
//BOOL bIsEnterFromBMEntrypoint = FALSE;
INT nBMProtectESP = 0;
INT nBMProtectEBP = 0;
extern "C" {


	int _cdecl BMEntrypoint (){
		//bIsEnterFromBMEntrypoint = TRUE;

		E_Init();
		ECodeStart();
		return 0;

	}
}




int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
		E_Init();
		int nRet;
//		int nRet = ECodeStart();
		_asm{
			mov nBMProtectESP,esp;
			mov nBMProtectEBP,ebp;
			call ECodeStart;
			mov nRet,eax;

		}
		//MessageBox(NULL,"I am Back",NULL,nRet);
		return nRet;
}

int main(int argc, char* argv[])
{
		E_Init();
		int nRet;
//		int nRet = ECodeStart();
		_asm{
			mov nBMProtectESP,esp;
			mov nBMProtectEBP,ebp;
			call ECodeStart;
			mov nRet,eax;

		}
		return nRet;
}


================================================
FILE: krnln/BlackMoonLibNotifySys.cpp
================================================
#include "stdafx.h"

#pragma comment(lib,"gdi32.lib") 
#pragma comment(lib,"winspool.lib") 
#pragma comment(lib,"comdlg32.lib") 
#pragma comment(lib,"advapi32.lib")  
#pragma comment(lib,"shell32.lib")  
#pragma comment(lib,"ole32.lib")  
#pragma comment(lib,"oleaut32.lib")  
#pragma comment(lib,"uuid.lib")  
#pragma comment(lib,"odbc32.lib")  
#pragma comment(lib,"odbccp32.lib")  
char strBlackMoonFileName_Path[MAX_PATH];
char strBlackMoonFileName_Name[MAX_PATH];
EXTERN_C INT WINAPI BlackMoonFuncForeLibNotifySys(INT nMsg, DWORD dwParam1, DWORD dwParam2)
{

	switch (nMsg)
	{
	case  NRS_MALLOC:
		// ָռڴ棬׳򽻻ڴ涼ʹñ֪ͨ䡣
		//   dwParam1Ϊڴֽ
		//   dwParam2Ϊ0ʧܾԶʱ˳
		// 粻Ϊ0ʧܾͷNULL
		//   ڴ׵ַ
		return (INT)E_MAlloc(dwParam1);
	case  NRS_MFREE:
		// ͷѷָڴ档
		// dwParam1Ϊͷڴ׵ַ
		E_MFree((void*)dwParam1);
		break;
	case  NRS_MREALLOC:
		// ·ڴ档
		//   dwParam1Ϊ·ڴߴ׵ַ
		//   dwParam2Ϊ·ڴֽ
		// ·ڴ׵ַʧԶʱ˳
		return (INT)E_MRealloc((void*)dwParam1, dwParam2);

	case  NRS_FREE_ARY:
		// ͷָݡ
		// dwParam1ΪݵDATA_TYPEֻΪϵͳ͡
		// dwParam2Ϊָݵָ롣
		switch (dwParam1)
		{
		case SDT_TEXT:
		case SDT_BIN:
			FreeAryElement((void*)dwParam2);
			break;
		case SDT_INT:
		case SDT_BYTE:
		case SDT_SHORT:
		case SDT_FLOAT:
		case SDT_INT64:
		case SDT_DOUBLE:
		case SDT_SUB_PTR:
		case SDT_BOOL:
		case SDT_DATE_TIME:
			E_MFree((void*)dwParam2);
			break;
		default:
			break;

		}
		break;

	case 	NRS_RUNTIME_ERR:
		// ֪ͨϵͳѾʱ
		// dwParam1Ϊchar*ָ룬˵ı
	{
		char ErrorString[1024];
		wsprintfA(ErrorString, "BlackMoon RunTime Error:\r\n\r\n%s", dwParam1);
		MessageBoxA(0, ErrorString, "ERROR", MB_ICONERROR);
		E_End(0);
	}
	break;
	case 	NRS_EXIT_PROGRAM:
		// ֪ͨϵͳ˳û
		// dwParam1Ϊ˳룬ô뽫صϵͳ
		E_End(dwParam1);
		break;
	case  NRS_GET_PRG_TYPE:
		// صǰûͣΪPT_DEBUG_RUN_VER԰棩PT_RELEASE_RUN_VER棩
		return PT_RELEASE_RUN_VER;
	case 	NRS_DO_EVENTS:
		// ֪ͨϵͳд¼
	{
		MSG Msg;
		while (PeekMessage(&Msg, NULL, NULL, NULL, PM_NOREMOVE))
		{
			if (Msg.message == WM_QUIT)
				break;
			GetMessage(&Msg, NULL, 0, 0);
			TranslateMessage(&Msg);
			DispatchMessage(&Msg);
		}
	}
	break;
	case  NRS_GET_CMD_LINE_STR:
		// ȡǰı
		// ıָ룬пΪմ
	{
		LPSTR p = GetCommandLineA();
		// ó
		char ch = ' ';
		if (*p++ == '\"')
			ch = '\"';
		while (*p++ != ch);
		if (ch != ' ' && *p == ' ')  p++;    // һո
		return (INT)p;
	}
	case  NRS_GET_EXE_PATH_STR:
		// ȡǰִļĿ¼
		// صǰִļĿ¼ıָ롣
		if (::GetModuleFileNameA(NULL, strBlackMoonFileName_Path, MAX_PATH))
		{
			char* pFind = strrchr(strBlackMoonFileName_Path, '\\');
			//	pFind++;
			*pFind = 0;
			return (INT)&strBlackMoonFileName_Path;

		}
		break;

	case  NRS_GET_EXE_NAME:
		// ȡǰִļ
		// صǰִļıָ롣
		if (::GetModuleFileNameA(NULL, strBlackMoonFileName_Path, MAX_PATH))
		{
			char* pFind = strrchr(strBlackMoonFileName_Path, '\\');
			//pFind++;
			*pFind = 0;
			pFind++;
			return (INT)pFind;
		}
		break;
	case  NRS_CONVERT_NUM_TO_INT:
	{
		// תֵʽ
		// dwParam1Ϊ PMDATA_INF ָ룬 m_dtDataType Ϊֵ͡
		// תֵ
		PMDATA_INF pArgInf = (PMDATA_INF)dwParam1;
		INT nNewVal = pArgInf->m_int;
		switch (pArgInf->m_dtDataType)
		{
		case SDT_INT:
		case SDT_BYTE:
		case SDT_SHORT:
			break;
		case SDT_FLOAT:
			nNewVal = (INT)pArgInf->m_float;
			break;
		case SDT_INT64:
			nNewVal = (INT)pArgInf->m_int64;
			break;
		case SDT_DOUBLE:
			nNewVal = (INT)pArgInf->m_double;
			break;
		default:
			break;

		}
		return nNewVal;
	}
	break;
	case  NAS_GET_PATH:
		/* صǰлijһĿ¼ļĿ¼ԡ\
		dwParam1: ָҪĿ¼Ϊֵ
		Aл¾ЧĿ¼:
		1: лϵͳĿ¼
		BЧĿ¼(Ч):
		1001: ϵͳֿ̺֧Ŀ¼
		1002: ϵͳĿ¼
		1003: ϵͳϢĿ¼
		1004: еǼǵϵͳģĿ¼
		1005: ֿ֧ڵĿ¼
		1006: װĿ¼
		CлЧĿ¼(лЧ):
		2001: ûEXEļĿ¼
		2002: ûEXEļ
		dwParam2: ջַߴΪMAX_PATH
		*/
		if (::GetModuleFileNameA(NULL, strBlackMoonFileName_Path, MAX_PATH))
		{
			char* pFind = strrchr(strBlackMoonFileName_Path, '\\');
			pFind++;
			*pFind = 0;
			pFind++;
			strcpy(strBlackMoonFileName_Name, pFind);
		}
		else {
			strBlackMoonFileName_Path[0] = 0;
			strBlackMoonFileName_Name[0] = 0;
		}

		switch (dwParam1)
		{
		case 1:
			strcpy((char*)dwParam2, strBlackMoonFileName_Path);
			return (INT)strBlackMoonFileName_Path;
			break;
		case 2001:
			strcpy((char*)dwParam2, strBlackMoonFileName_Path);
			return (INT)strBlackMoonFileName_Path;
			break;
		case 2002:
			strcpy((char*)dwParam2, strBlackMoonFileName_Name);
			return (INT)strBlackMoonFileName_Name;
			break;
		default:
			return NULL;
		}
	case  NAS_GET_LANG_ID:
		// صǰϵͳлֵ֧IDIDֵlang.h
		return 1;
	case  NAS_GET_VER:
		// صǰϵͳлİ汾ţLOWORDΪ汾ţHIWORDΪΰ汾š
		return 0x00000004;
	case  NRS_GET_WINFORM_COUNT:
		// صǰĴĿ
		return 0;
	case  NRS_GET_WINFORM_HWND:
		// ָĴھôδ룬NULL
		// dwParam1Ϊ
		return NULL;
	case NAS_GET_APP_ICON:
		// ֪ͨϵͳسͼꡣ
		// dwParam1ΪPAPP_ICONָ롣
	case  NAS_GET_LIB_DATA_TYPE_INFO:
		// ָⶨ͵PLIB_DATA_TYPE_INFOϢָ롣
		// dwParam1Ϊ͡
		// Ч߲Ϊⶨͣ򷵻NULL򷵻PLIB_DATA_TYPE_INFOָ롣
	case  NAS_GET_HBITMAP:
		// dwParam1ΪͼƬָ룬dwParam2ΪͼƬݳߴ硣
		// ɹطNULLHBITMAPעʹϺͷţ򷵻NULL

	case  NAS_CREATE_CWND_OBJECT_FROM_HWND:
		// ָͨHWNDһCWND󣬷ָ룬סָͨNRS_DELETE_CWND_OBJECTͷ
		// dwParam1ΪHWND
		// ɹCWnd*ָ룬ʧܷNULL
	case  NAS_DELETE_CWND_OBJECT:
		// ɾͨNRS_CREATE_CWND_OBJECT_FROM_HWNDCWND
		// dwParam1ΪɾCWndָ
	case  NAS_DETACH_CWND_OBJECT:
		// ȡͨNRS_CREATE_CWND_OBJECT_FROM_HWNDCWNDHWNDİ
		// dwParam1ΪCWndָ
		// ɹHWND,ʧܷ0
	case  NAS_GET_HWND_OF_CWND_OBJECT:
		// ȡͨNRS_CREATE_CWND_OBJECT_FROM_HWNDCWNDеHWND
		// dwParam1ΪCWndָ
		// ɹHWND,ʧܷ0
	case  NAS_ATTACH_CWND_OBJECT:
		// ָHWNDͨNRS_CREATE_CWND_OBJECT_FROM_HWNDCWND
		// dwParam1ΪHWND
		// dwParam2ΪCWndָ
		// ɹ1,ʧܷ0
	case 	NAS_IS_EWIN:
		// ָΪԴڻ棬򷵻ؼ١
		// dwParam1ΪԵHWND.
// NRS_ Ϊܱл֪ͨ
	case  NRS_UNIT_DESTROIED:
		// ֪ͨϵͳָѾ١
		// dwParam1ΪdwFormID
		// dwParam2ΪdwUnitID
	case  NRS_GET_UNIT_PTR:
		// ȡָ
		// dwParam1ΪWinFormID
		// dwParam2ΪWinUnitID
		// ɹЧCWnd*ָ룬ʧܷ0
	case  NRS_GET_AND_CHECK_UNIT_PTR:
		// ȡָ
		// dwParam1ΪWinFormID
		// dwParam2ΪWinUnitID
		// ɹЧCWnd*ָ룬ʧܱʱ˳
	case  NRS_EVENT_NOTIFY:
		// Եһ෽ʽ֪ͨϵͳ¼
		// dwParam1ΪPEVENT_NOTIFYָ롣
		//    0 ʾ¼ѱϵͳʾϵͳѾɹݴ¼û
		// ¼ӳ
	case  NRS_GET_UNIT_DATA_TYPE:
		// dwParam1ΪWinFormID
		// dwParam2ΪWinUnitID
		// ɹЧ DATA_TYPE ʧܷ 0 

	case  NRS_EVENT_NOTIFY2:
		// Եڶ෽ʽ֪ͨϵͳ¼
		// dwParam1ΪPEVENT_NOTIFY2ָ롣
		//    0 ʾ¼ѱϵͳʾϵͳѾɹݴ¼û
		// ¼ӳ

	case  NRS_GET_BITMAP_DATA:
		// ָHBITMAPͼƬݣɹذBMPͼƬݵHGLOBALʧܷNULL
		// dwParam1ΪȡͼƬݵHBITMAP
	case  NRS_FREE_COMOBJECT:
		// ֪ͨϵͳͷָDTP_COM_OBJECTCOM
		// dwParam1ΪCOMĵַָ롣
	case  NRS_CHK_TAB_VISIBLE:
	default:
	{
		char ErrorString[255];
		wsprintfA(ErrorString, "֧ϵͳܺ%d. 뽫Ϣ", nMsg);
		MessageBoxA(0, ErrorString, "blackmoon", MB_ICONERROR);
		break;
	}
	}
	return NULL;

}

EXTERN_C INT WINAPI BlackMoonReplac_NotifySys(INT nMsg, DWORD dwParam1, DWORD dwParam2)
{
	return NR_OK;
}

INT WINAPI NotifySys(INT nMsg, DWORD dwParam1, DWORD dwParam2)
{

	return BlackMoonFuncForeLibNotifySys(nMsg, dwParam1, dwParam2);
}

// ʹָıݽ׳ʹõıݡ
/*
char* CloneTextData (char* ps)
{
	if (ps == NULL || *ps == '\0')
		return NULL;

	INT nTextLen = strlen (ps);
	char* pd = (char*)NotifySys (NRS_MALLOC, (DWORD)(nTextLen + 1), 0);
	memcpy (pd, ps, nTextLen);
	pd [nTextLen] = '\0';
	return pd;
}*/
/*
// ʹָıݽ׳ʹõıݡ
//   nTextLenָıֵijȣ㣩
// Ϊ-1ȡpsȫȡ
char* CloneTextData (char* ps, INT nTextLen)
{
	if (nTextLen <= 0)
		return NULL;

	char* pd = (char*)NotifySys (NRS_MALLOC, (DWORD)(nTextLen + 1), 0);
	memcpy (pd, ps, nTextLen);
	pd [nTextLen] = '\0';
	return pd;
}

// ʹָݽ׳ʹõֽڼݡ
LPBYTE CloneBinData (LPBYTE pData, INT nDataSize)
{
	if (nDataSize == 0)
		return NULL;

	LPBYTE pd = (LPBYTE)NotifySys (NRS_MALLOC, (DWORD)(sizeof (INT) * 2 + nDataSize), 0);
	*(LPINT)pd = 1;
	*(LPINT)(pd + sizeof (INT)) = nDataSize;
	memcpy (pd + sizeof (INT) * 2, pData, nDataSize);
	return pd;
}

// ʱ
void GReportError (char* szErrText)
{
	NotifySys (NRS_RUNTIME_ERR, (DWORD)szErrText, 0);
}

void* MMalloc (INT nSize)
{
	return (void*)NotifySys (NRS_MALLOC, (DWORD)nSize, 0);
}

void MFree (void* p)
{
	NotifySys (NRS_MFREE, (DWORD)p, 0);
}
*/
// ݲ׵ַԱĿ
LPBYTE GetAryElementInf(void* pAryData, LPINT pnElementCount)
{
	LPINT pnData = (LPINT)pAryData;
	INT nArys = *pnData++;  // ȡά
	// ԱĿ
	INT nElementCount = 1;
	while (nArys > 0)
	{
		nElementCount *= *pnData++;
		nArys--;
	}

	if (pnElementCount != NULL)
		*pnElementCount = nElementCount;
	return (LPBYTE)pnData;
}
/*
#define DTT_IS_NULL_DATA_TYPE   0
#define DTT_IS_SYS_DATA_TYPE    1
#define DTT_IS_USER_DATA_TYPE   2
#define DTT_IS_LIB_DATA_TYPE    3
// ȡ͵
INT GetDataTypeType (DATA_TYPE dtDataType)
{
	if (dtDataType == _SDT_NULL)
		return DTT_IS_NULL_DATA_TYPE;

	DWORD dw = dtDataType & 0xC0000000;
	return dw == DTM_SYS_DATA_TYPE_MASK ? DTT_IS_SYS_DATA_TYPE :
			dw == DTM_USER_DATA_TYPE_MASK ? DTT_IS_USER_DATA_TYPE :
			DTT_IS_LIB_DATA_TYPE;
}
*/

//liigo


/*
//!!! º֮ԱȫΪINT(ͬռ4ֽ)
//index: 0..*/


void* _GetPointerByIndex(void* pBase, int index)
{
	return (void*)((INT)pBase + index * sizeof(INT));
}

INT _GetIntByIndex(void* pBase, INT index)
{
	return *((INT*)_GetPointerByIndex(pBase, index));
}

void _SetIntByIndex(void* pBase, INT index, INT value)
{
	*((INT*)_GetPointerByIndex(pBase, index)) = value;
}


INT GetIntByIndex(PMDATA_INF pArgInf, INT index)
{
	return _GetIntByIndex(pArgInf->m_pCompoundData, index);
}

void SetIntByIndex(PMDATA_INF pArgInf, INT index, INT value)
{
	_SetIntByIndex(pArgInf->m_pCompoundData, index, value);
}

void* GetPointerByIndex(PMDATA_INF pArgInf, INT index)
{
	return _GetPointerByIndex(pArgInf->m_pCompoundData, index);
}

void SetLogfont_CompileLanVer(LPLOGFONT pLogfont)
{
	::GetObject(::GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONT), pLogfont);

}


================================================
FILE: krnln/BlackMoonResDll.cpp
================================================
#include "stdafx.h"


extern "C" {


	int __stdcall DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
	{

		return 1;
		
	}

}

================================================
FILE: krnln/CloneBinData.cpp
================================================
#include "StdAfx.h"

// ʹָݽ׳ʹõֽڼݡ
LPBYTE CloneBinData (LPBYTE pData, INT nDataSize)
{
	if (nDataSize == 0)
		return NULL;
	
	LPBYTE pd = (LPBYTE)E_MAlloc_Nzero ((DWORD)(sizeof (INT) * 2 + nDataSize));
	*(LPINT)pd = 1;
	*(LPINT)(pd + sizeof (INT)) = nDataSize;
	memcpy (pd + sizeof (INT) * 2, pData, nDataSize);
	return pd;
}

================================================
FILE: krnln/CloneTextData.cpp
================================================
#include "StdAfx.h"
#include "Myfunctions.h"

// ʹָıݽ׳ʹõıݡ
//   nTextLenָıֵijȣ㣩
// Ϊ-1ȡpsȫȡ
char* CloneTextData (char* ps, INT nTextLen)
{
	if (nTextLen <= 0)
		return NULL;
	
	char* pd = (char*)E_MAlloc_Nzero ((DWORD)(nTextLen + 1));
	memcpy (pd, ps, nTextLen);
	pd [nTextLen] = '\0';
	return pd;
}
// ʹָıݽ׳ʹõıݡ
char* CloneTextData (char* ps)
{
    if (ps == NULL || *ps == '\0')
        return NULL;

    INT nTextLen = mystrlen (ps);
    char* pd = (char*)E_MAlloc_Nzero ((DWORD)(nTextLen + 1));
    memcpy (pd, ps, nTextLen);
    pd [nTextLen] = '\0';
    return pd;
}

================================================
FILE: krnln/DateTimeFormat.cpp
================================================
#include "stdafx.h"
#include <stdio.h>
#include <math.h>

#include <oleauto.h>
#pragma comment(lib, "OleAut32.lib")

//ʽʱı
void DateTimeFormat(LPSTR strValue,DATE dtDt,BOOL bOnlyDatePart)
{
	SYSTEMTIME st = {0};
	VariantTimeToSystemTime(dtDt, &st);
	
	char strFormat [128];
	strcpy(strFormat,"%d%d%d");


	//ʽʱ䲿
	char strFormatTime [128];
	
	if(st.wSecond)
		strcpy(strFormatTime,"%dʱ%d%d");
	else if(st.wMinute && st.wSecond ==0)
		strcpy(strFormatTime,"%dʱ%d");
	else if(st.wHour && st.wMinute==0 && st.wSecond ==0)
		strcpy(strFormatTime,"%dʱ");
	else
		strFormatTime[0]=0;

	if(bOnlyDatePart==FALSE)
		strcat(strFormat,strFormatTime);

	sprintf(strValue, strFormat, st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);

}

================================================
FILE: krnln/DllEntryFunc.cpp
================================================
#include "stdafx.h"


extern "C" PDESTROY ECodeStart();
PDESTROY DllEntryFunc(){
	DWORD dwReturn;//ҪĴȻʱ
	__asm{
        push esi
        push edi
        push ebx
        call ECodeStart
        pop ebx
        pop edi
        pop esi
		mov dwReturn,eax
 	}
	return (PDESTROY)dwReturn;

}




================================================
FILE: krnln/EyComInit.cpp
================================================
#include "stdafx.h"

extern "C" PDESTROY DestroyAddress;

extern "C" PDESTROY HFileDestroyAddress;

extern "C" PDESTROY DestroyMidiPlayer;

extern "C" HANDLE hBlackMoonHeap;
extern "C" {


	void  _cdecl E_Init(){
		hBlackMoonHeap =::GetProcessHeap();
		CoInitialize(0);
		BlackMoonInitAllElib();
	}

	void  _cdecl E_DestroyRes(){
		
		if(DestroyAddress)
			DestroyAddress();

		if(HFileDestroyAddress)
			HFileDestroyAddress();

		if(DestroyMidiPlayer)
			DestroyMidiPlayer();
		BlackMoonFreeAllElib();
		CoUninitialize();
	}


}

================================================
FILE: krnln/EyInit.cpp
================================================
#include "stdafx.h"

extern "C" PDESTROY DestroyAddress;

extern "C" PDESTROY HFileDestroyAddress;

extern "C" PDESTROY DestroyMidiPlayer;
extern "C" HANDLE hBlackMoonHeap;
extern "C" {


	void  _cdecl E_Init(){
		
		hBlackMoonHeap =::GetProcessHeap();
		//CoInitialize(0);
		BlackMoonInitAllElib();
	}

	
	void  _cdecl E_DestroyRes(){
		
		if(DestroyAddress)
			DestroyAddress();

		if(HFileDestroyAddress)
			HFileDestroyAddress();

		if(DestroyMidiPlayer)
			DestroyMidiPlayer();
		BlackMoonFreeAllElib();
	}

}

================================================
FILE: krnln/FileManager.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"

PFILEELEMENT pFileList = NULL;
extern "C" PDESTROY HFileDestroyAddress;

CRITICAL_SECTION csFileMan;
BOOL bIsCSinit = FALSE;

void enterfm()
{
	if (!bIsCSinit)
	{
		InitializeCriticalSection(&csFileMan);
		bIsCSinit = TRUE;
	}
	EnterCriticalSection(&csFileMan);
}

void leavefm()
{
	if (bIsCSinit)
		LeaveCriticalSection(&csFileMan);
}

void ResetFileIO()
{
	enterfm();
	PFILEELEMENT pObjFile = pFileList;
	pFileList = NULL;
	HFileDestroyAddress = NULL;

	while(pObjFile)
	{

		if(pObjFile->FileHandle)
		{
			if(pObjFile->nType ==1 || pObjFile->nType ==3)
				CloseHandle((HANDLE)pObjFile->FileHandle);
			else if(pObjFile->nType ==2)
				delete (CMyMemFile*)pObjFile->FileHandle;
		}

		PFILEELEMENT pPreFile = pObjFile;
		pObjFile = (PFILEELEMENT)pObjFile->pLast;
		memset(pPreFile,0,sizeof(FILEELEMENT));
		delete pPreFile;
	}
	leavefm();
}
void CloseEfile(PFILEELEMENT pFile)
{
	PFILEELEMENT pObjFile = pFileList;
	PFILEELEMENT pPreFile = NULL;
	
	enterfm();
	while(pObjFile)
	{
		if(pObjFile == pFile)
		{
			if(pPreFile)
			{//ڱ
				pPreFile->pLast = pObjFile->pLast;
			}
			else
			{ //
				pFileList = (PFILEELEMENT)pObjFile->pLast;
				if(pFileList==NULL)
					HFileDestroyAddress = NULL;

			}
			if(pObjFile->FileHandle)
			{
				if(pObjFile->nType ==1 || pObjFile->nType == 3)
					CloseHandle((HANDLE)pObjFile->FileHandle);
				else if(pObjFile->nType ==2)
					delete (CMyMemFile*)pObjFile->FileHandle;
			}
			memset(pObjFile,0,sizeof(FILEELEMENT));
			delete pObjFile;
			break;

		}
		pPreFile = pObjFile;
		pObjFile = (PFILEELEMENT)pObjFile->pLast;
	}
	leavefm();
}


void AddFileMangerList(PFILEELEMENT pFile)
{
	enterfm();
	if(pFileList==NULL)//׸
		HFileDestroyAddress = (PDESTROY)ResetFileIO;
	pFile->pLast = pFileList;
	pFileList = pFile;
	leavefm();
}

================================================
FILE: krnln/FreeAryElement.cpp
================================================
#include "stdafx.h"



void FreeAryElement (void* pAryData)//ıֽڼЧ
{
	DWORD AryElementCount = 0;
	LPINT* pArryPtr = (LPINT*)GetAryElementInf(pAryData ,AryElementCount);

	for(INT i=0;i < (INT)AryElementCount;i++)
	{
		void* pElementData = *pArryPtr;
		if(pElementData)
		{
			E_MFree(pElementData);
			*pArryPtr = NULL;
		}
		pArryPtr++;
	}

	E_MFree(pAryData);
}

================================================
FILE: krnln/GetAryElementInf.cpp
================================================
#include "stdafx.h"

void* GetAryElementInf(void* pAryData ,DWORD& AryElementCount)
{
    LPINT pnData;
    INT nArys;
    UINT nElementCount;
    
    pnData = (LPINT)pAryData;
    
    nArys=*pnData; //ȡά
    pnData +=1;

     // ԱĿ
    nElementCount = 1;
    while (nArys > 0)
	{
        nElementCount *= pnData[0];
        pnData ++;
        nArys--;
    }

    AryElementCount = nElementCount;
    return pnData;
}

================================================
FILE: krnln/GetDataTypeType.cpp
================================================
#include "StdAfx.h"


// ȡ͵
INT GetDataTypeType (DATA_TYPE dtDataType)
{
	if (dtDataType == _SDT_NULL)
		return DTT_IS_NULL_DATA_TYPE;
	
	DWORD dw = dtDataType & 0xC0000000;
	return dw == DTM_SYS_DATA_TYPE_MASK ? DTT_IS_SYS_DATA_TYPE :
	dw == DTM_USER_DATA_TYPE_MASK ? DTT_IS_USER_DATA_TYPE :
	DTT_IS_LIB_DATA_TYPE;
}

================================================
FILE: krnln/GetDatePart.cpp
================================================
#include "stdafx.h"
#include <math.h>
#include <stdio.h>
#include <oleauto.h>
#pragma comment(lib, "OleAut32.lib")

//ȡڲ,1ΪֻڲֵDATE
//189912300ʱ0000 Ϊ0׼,λΪСֵ

void GetDatePart(DATE dt,INT& nYear,INT& nMonth,INT& nDay)
{
	SYSTEMTIME st = {0};
	VariantTimeToSystemTime(dt, &st);
	nYear = (INT)st.wYear;
	nMonth = (INT)st.wMonth;
	nDay = (INT)st.wDay;
	/*
	if(dt==0 || dt==1)
	{
		nYear = 1899;
		nMonth = 12;
		nDay = 30 + (INT)dt;
		return;
	}
	INT nCountDay;
	INT nStatrYear;
	INT nYearDay;
	INT nStep;
	if(dt>0)
	{
		nCountDay = (INT)(dt-1);//190011Ϊ׼
		nStatrYear = 1900;
		nStep=1;
	}
	else
	{
		nCountDay = (INT)fabs(dt-1);//18991231Ϊ׼
		nStatrYear = 1899;
		nStep = -1;
	}

	while(1)
	{
		nYearDay = 365;
		if((nStatrYear % 400==0) || (nStatrYear % 100 !=0) && (nStatrYear %4 ==0))//
			nYearDay ++;
		if(nCountDay <= nYearDay)//ķΧ
		{
			nYear = nStatrYear;
			if(nStep==-1)
			{
				nCountDay = nYearDay - nCountDay;
			}

			break;
		}
		nCountDay -=nYearDay;
		nStatrYear +=nStep;
	}
	DWORD nMonDay [12] = {31,28,31,30,31,30,31,31,30,31,30,31};
	if((nYear % 400==0) || (nYear % 100 != 0) && (nYear %4 ==0))//
		nMonDay [1] = 29; //

	for(INT i=0;i <12;i++)
	{
		if(nCountDay <= (INT)(nMonDay[i]))
		{
			nMonth = i+1;
			nDay = nCountDay;
			break;
		}
		nCountDay-=nMonDay[i];

	}
		*/
}

//СϵһaΪ,bΪС,aΪ׼
//ȷaֻbֻС
double makedb(double a, double b)
{
	if (((*(INT64*)&a)&0x8000000000000000) == ((*(INT64*)&b)&0x8000000000000000))
	{//ֱͬӼ
		return a+b;
	}
	//Ųͬ
	return a-b;
}

DATE toMyDate(DATE dt)
{
	if (dt > -1.0e-7) return dt; //ڵ0

	DATE dtZS;
	DATE dtXS = modf(dt, &dtZS);
	return dtZS + fabs(dtXS);
}

DATE toEDate(DATE dt)
{
	if (dt > -1.0e-7) return dt; //ڵ0

	DATE dtZS;
	DATE dtXS = modf(dt, &dtZS);
	if (fabs(dtXS) < 1.0e-7) { //СΪ0
		return dtZS;//ֱӷ
	}
	dtZS -= 2.0;
	return dtZS - dtXS;
}

================================================
FILE: krnln/GetDaysOfSpecMonth.cpp
================================================
#include "stdafx.h"

INT GetDaysOfSpecMonth(INT nYear,INT nMonth)
{
	DWORD nMonDay [12] = {31,28,31,30,31,30,31,31,30,31,30,31};
	if((nYear % 400==0) || (nYear % 100 != 0) && (nYear %4 ==0))//
		nMonDay [1] = 29; //
	return nMonDay [nMonth-1];
}

================================================
FILE: krnln/GetRegRootVal.cpp
================================================
#include "stdafx.h"
// 1#ࣻ 2#ã 3#û 4#ػ 5#û
HKEY GetRegRootVal(INT nVal)
{
	HKEY hkey = NULL;
	switch(nVal)
	{
	case 1:
		hkey = HKEY_CLASSES_ROOT;
		break;
	case 2:
		hkey = HKEY_CURRENT_CONFIG;
		break;
	case 3:
		hkey = HKEY_CURRENT_USER;
		break;
	case 4:
		hkey = HKEY_LOCAL_MACHINE;
		break;
	case 5:
		hkey = HKEY_USERS;
		break;
	}
	return hkey;
}

================================================
FILE: krnln/GetSpecTime.cpp
================================================
#include "stdafx.h"
#include <math.h>

#include <oleauto.h>
#pragma comment(lib, "OleAut32.lib")

//ȡָʱ ʱֵȷ
//189912300ʱ0000 Ϊ0׼,λΪСֵ
double GetSpecDateTime(INT nYear, INT nMonth, INT nDay, INT nHour,INT nMinute,INT nSecond)
{
	double dDate = 0;
	SYSTEMTIME st = {0};
	st.wYear = (WORD)nYear;
	st.wMonth = (WORD)nMonth;
	st.wDay = (WORD)nDay;
	st.wHour = (WORD)nHour;
	st.wMinute = (WORD)nMinute;
	st.wSecond = (WORD)nSecond;
	SystemTimeToVariantTime(&st, &dDate);
	return dDate;
	/*
	double nSecCount = nHour * 3600;//
	nSecCount+=(nMinute*60);
	nSecCount+=nSecond;
	double dTime = nSecCount/86400;
	double dDate = 0;
	INT nStep;

	
	if(nYear==1899)
	{
		if(nMonth==12)
		{
			if(nDay >= 30)
			{
				dDate = nDay - 30;
				return (dDate + dTime); 
			}

		}

		nStep = -1;
	}
	else if (nYear > 1899)
	{
		nStep = 1;

	}else
		nStep = -1;

	

	INT nStatrYear;
	INT nYearDay;
	INT nCountDay = 0;
	if(nStep==1)
		nStatrYear = 1900;//190011Ϊ׼
	else
		nStatrYear = 1899;

		

	while(1)
	{

		if(nStatrYear==nYear)
		{
			DWORD nMonDay [12] = {31,28,31,30,31,30,31,31,30,31,30,31};
			if((nYear % 400==0) || (nYear % 100 != 0) && (nYear %4 ==0))//
				nMonDay [1] = 29; //
			if(nStep==1)
			{
				for(INT i=0;i <12;i++)
				{
					if(i == nMonth - 1)
					{
						nCountDay += nDay;
						break;
					}
					nCountDay += nMonDay[i];
				}
			}else{

				for(INT i = 11;i >=0;i--)
				{
					if(i == nMonth - 1)
					{
						nCountDay += (nMonDay[i]-nDay);

						break;
					}
					nCountDay += nMonDay[i];
				}

			}
			break;

		}
		nYearDay = 365;
		if((nStatrYear % 400==0) || (nStatrYear % 100 !=0) && (nStatrYear %4 ==0))//
			nYearDay ++;
		nCountDay += nYearDay;
		nStatrYear+=nStep;

	}

	if(nStep==1)
	{
		dDate = nCountDay + 1;
		return (dDate + dTime); 
	}


	dDate = -(nCountDay - 1 + dTime);
	return dDate; 
	
	*/
}


================================================
FILE: krnln/GetSysDataTypeDataSize.cpp
================================================
#include "StdAfx.h"


// 
INT GetSysDataTypeDataSize (DATA_TYPE dtSysDataType)
{
	ASSERT (sizeof (DWORD) == 4);
	
	switch (dtSysDataType)
	{
	case SDT_BYTE:
		ASSERT (sizeof (BYTE) == 1);
		return sizeof (BYTE);
	case SDT_SHORT:
		ASSERT (sizeof (SHORT) == 2);
		return sizeof (SHORT);
	case SDT_BOOL:
		ASSERT (sizeof (BOOL) == 4);
		return sizeof (BOOL);
	case SDT_INT:
		ASSERT (sizeof (INT) == 4);
		return sizeof (INT);
	case SDT_FLOAT:
		ASSERT (sizeof (FLOAT) == 4);
		return sizeof (FLOAT);
	case SDT_SUB_PTR:    // ¼ӳĵַָ
		return sizeof (DWORD);
	case SDT_TEXT:    // ıͺֽڼΪһָ,Ϊĸֽ.
	case SDT_BIN:
		return sizeof (DWORD);
	case SDT_INT64:
		ASSERT (sizeof (INT64) == 8);
		return sizeof (INT64);
	case SDT_DOUBLE:
		ASSERT (sizeof (DOUBLE) == 8);
		return sizeof (DOUBLE);
	case SDT_DATE_TIME:
		ASSERT (sizeof (DATE) == 8);
		return sizeof (DATE);
	default:
		ASSERT (FALSE);
		return 0;
	}
	
	return 0;
}

================================================
FILE: krnln/GetTimePart.cpp
================================================
#include "stdafx.h"
#include <math.h>
#include <oleauto.h>
#pragma comment(lib, "OleAut32.lib")

//ȡʱ䲿,1Ϊֻʱ䲿ֵDATE
void GetTimePart(DATE dt,INT& nHour,INT& nMinute,INT& nSecond)
{
	SYSTEMTIME st = {0};
	VariantTimeToSystemTime(dt, &st);
	nHour = (INT)st.wHour;
	nMinute = (INT)st.wMinute;
	nSecond = (INT)st.wSecond;
	/*
	INT nSecCount = (INT)DATE( 86400 * fabs(dt)+0.5);//
	nHour = nSecCount / 3600;
	nSecCount %= 3600;
	nMinute = nSecCount / 60;
	nSecond = nSecCount % 60;
	*/
}

================================================
FILE: krnln/GetWeekDay.cpp
================================================
#include "stdafx.h"
#include <math.h>
#include <oleauto.h>
#pragma comment(lib, "OleAut32.lib")

INT GetWeekDay(DATE date)
{
	SYSTEMTIME st = {0};
	VariantTimeToSystemTime(date, &st);
	return st.wDayOfWeek + 1;
	/*
	DATE dt,dd;
	dt = modf(date,&dd);
	INT nRet = (INT)fmod(dd,7);
	if(nRet <= 0)
		nRet += 7;
	return nRet;
	*/
}

================================================
FILE: krnln/HelpFunc12.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

extern "C" {

	char*  _cdecl E_FindFile (LPCSTR strFile,UINT nAttrib,BOOL bIsMissing,HANDLE* phFile){
//12ź,EAXΪ 0
		HANDLE hFile = *phFile;

		WIN32_FIND_DATA FindFileData;
		BOOL bFind = FALSE;
	//	nAttrib &= 55;//
		if(strFile != NULL && mystrlen(strFile)>0)//һβ
		{
			
			
			if(hFile && hFile != INVALID_HANDLE_VALUE) //رϴξɵľ 
				FindClose(hFile); 

				
			
			hFile = FindFirstFile(strFile,&FindFileData);
			*phFile = hFile;
			if(hFile ==INVALID_HANDLE_VALUE)
				return NULL;
					
			

			if(bIsMissing)
			{
			//char ErrorString [255];
	  		//wsprintf(ErrorString, "(0x%Xh) (0x%Xh)", FindFileData.dwFileAttributes,(FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY));
			//MessageBox(0, ErrorString, FindFileData.cFileName, MB_OK);

				if ((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != FILE_ATTRIBUTE_DIRECTORY)//Ŀ¼
					bFind = TRUE;

			}else {

				if ((FindFileData.dwFileAttributes & nAttrib) != 0)//
					bFind = TRUE;
			}

		}

		if(hFile==NULL || hFile == INVALID_HANDLE_VALUE) return NULL;

		if(bFind==FALSE)
		{
			if(bIsMissing)
			{
				while(FindNextFile(hFile,&FindFileData))
				{
					if((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != FILE_ATTRIBUTE_DIRECTORY)//Ŀ¼
					{
						bFind = TRUE;
						break;
					}
					
				}				
			}else {

				while(FindNextFile(hFile,&FindFileData))
				{
					if((FindFileData.dwFileAttributes & nAttrib) != 0)//
					{
						bFind = TRUE;
						break;
					}
					
				}				
				
			}
		}

		if(bFind)
		{
			//	MessageBox(0, FindFileData.cFileName, "FILE", MB_OK);
			INT nLen = mystrlen(FindFileData.cFileName);
			char* str = (char*)E_MAlloc_Nzero(nLen+1);
			strcpy(str,FindFileData.cFileName);
			return str;
		}
		return NULL;

	}
	void  _cdecl E_CloseFindFile (HANDLE hFile){
		//12ź,EAXΪ 1
		//char t[12];
		//itoa((int)hFile,t,16);

		//MessageBox(NULL,t,"file2",MB_OK);
		//HANDLE hFile = *phFile;
		if(hFile==NULL || hFile == INVALID_HANDLE_VALUE) return ;
		
		FindClose(hFile); //رϴξɵľ 
		//*phFile = NULL;
		
	}

}

================================================
FILE: krnln/IsInFileMangerList.cpp
================================================
#include "stdafx.h"

extern PFILEELEMENT pFileList;

BOOL IsInFileMangerList(PFILEELEMENT pFile)
{
	PFILEELEMENT pObjFile = pFileList;

	while(pObjFile)
	{
		if(pObjFile == pFile)
			return TRUE;
		if (pObjFile == (PFILEELEMENT)pObjFile->pLast)
			break;
		pObjFile = (PFILEELEMENT)pObjFile->pLast;
	}
	return FALSE;
}

================================================
FILE: krnln/LTrimZeroChr.cpp
================================================
#include "stdafx.h"
//#include "Myfunctions.h"

void LTrimZeroChr(char* str)
{
	char *z = NULL;
	char *p = NULL;

	//С
	for (; *str ; str++)
	{
		if(*str == '.')
		{
			p = str++;
			break;
		}
	}
	//
	if(p) //С
	{
		for (; *str; str++)
		{
			if (*str == '0')
			{
				if(!z)
				{
					z = str;
				}
			}
			else
			{
				z = NULL;
			}
		}
		//
		if (z)
		{
			
			if(z == p + 1) //СβɾС
			{
				*p = '\0';
			}
			else
			{
				*z = '\0';
			}
		}
	}
}

/*
	int nLen = mystrlen(str);
	char * pend = str + nLen;
	do
	{

		pend--;

		if(*pend =='.')
		{
			
			*pend = 0;
			break;
		} else if(*pend !='0')
		{
			pend++;
			*pend = 0;
			break;
		}

	}while(* pend =='0' && pend > str);
*/
//}

================================================
FILE: krnln/LTrimZeroChr.h
================================================
void LTrimZeroChr(char* str);

================================================
FILE: krnln/MyMemFile.cpp
================================================
// MyMemFile.cpp: implementation of the CMyMemFile class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "MyMemFile.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////
// CMyMemFile implementation

CMyMemFile::CMyMemFile(UINT nGrowBytes)
{
	m_nGrowBytes = nGrowBytes;
	m_nPosition = 0;
	m_nBufferSize = 0;
	m_nFileSize = 0;
	m_lpBuffer = NULL;
	m_bAutoDelete = TRUE;
}

CMyMemFile::CMyMemFile(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes)
{

	m_nGrowBytes = nGrowBytes;
	m_nPosition = 0;
	m_nBufferSize = nBufferSize;
	m_nFileSize = nGrowBytes == 0 ? nBufferSize : 0;
	m_lpBuffer = lpBuffer;
	m_bAutoDelete = FALSE;
}

void CMyMemFile::Attach(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes)
{

	m_nGrowBytes = nGrowBytes;
	m_nPosition = 0;
	m_nBufferSize = nBufferSize;
	m_nFileSize = nGrowBytes == 0 ? nBufferSize : 0;
	m_lpBuffer = lpBuffer;
	m_bAutoDelete = FALSE;
}

BYTE* CMyMemFile::Detach()
{
	BYTE* lpBuffer = m_lpBuffer;
	m_lpBuffer = NULL;
	m_nFileSize = 0;
	m_nBufferSize = 0;
	m_nPosition = 0;

	return lpBuffer;
}

CMyMemFile::~CMyMemFile()
{
	// Close should have already been called, but we check anyway
	if (m_lpBuffer)
		Close();
	m_nGrowBytes = 0;
	m_nPosition = 0;
	m_nBufferSize = 0;
	m_nFileSize = 0;
}

BYTE* CMyMemFile::Alloc(DWORD nBytes)
{
	return (BYTE*)malloc((UINT)nBytes);
}

BYTE* CMyMemFile::Realloc(BYTE* lpMem, DWORD nBytes)
{
	return (BYTE*)realloc(lpMem, (UINT)nBytes);
}



void CMyMemFile::Free(BYTE* lpMem)
{
	free(lpMem);
}

DWORD CMyMemFile::GetPosition() const
{

	return m_nPosition;
}

void CMyMemFile::GrowFile(DWORD dwNewLen)
{

	if (dwNewLen > m_nBufferSize)
	{
		// grow the buffer
		DWORD dwNewBufferSize = (DWORD)m_nBufferSize;

		// watch out for buffers which cannot be grown!
		if (m_nGrowBytes == 0)
			return;

		// determine new buffer size
		while (dwNewBufferSize < dwNewLen)
			dwNewBufferSize += m_nGrowBytes;

		// allocate new buffer
		BYTE* lpNew;
		if (m_lpBuffer == NULL)
			lpNew = Alloc(dwNewBufferSize);
		else
			lpNew = Realloc(m_lpBuffer, dwNewBufferSize);

		if (lpNew == NULL)
			return;

		m_lpBuffer = lpNew;
		m_nBufferSize = dwNewBufferSize;
	}
}

void CMyMemFile::SetLength(DWORD dwNewLen)
{

	if (dwNewLen > m_nBufferSize)
		GrowFile(dwNewLen);

	if (dwNewLen < m_nPosition)
		m_nPosition = dwNewLen;

	m_nFileSize = dwNewLen;

}

UINT CMyMemFile::Read(void* lpBuf, UINT nCount)
{

	if (nCount == 0)
		return 0;


	if (m_nPosition > m_nFileSize)
		return 0;

	UINT nRead;
	if (m_nPosition + nCount > m_nFileSize)
		nRead = (UINT)(m_nFileSize - m_nPosition);
	else
		nRead = nCount;

	memcpy((BYTE*)lpBuf, (BYTE*)m_lpBuffer + m_nPosition, nRead);
	m_nPosition += nRead;


	return nRead;
}

void CMyMemFile::Write(const void* lpBuf, UINT nCount)
{


	if (nCount == 0)
		return;


	if (m_nPosition + nCount > m_nBufferSize)
		GrowFile(m_nPosition + nCount);


	memcpy((BYTE*)m_lpBuffer + m_nPosition, (BYTE*)lpBuf, nCount);

	m_nPosition += nCount;

	if (m_nPosition > m_nFileSize)
		m_nFileSize = m_nPosition;

}

LONG CMyMemFile::Seek(LONG lOff, UINT nFrom)
{

	LONG lNewPos = m_nPosition;

	if (nFrom == begin)
		lNewPos = lOff;
	else if (nFrom == current)
		lNewPos += lOff;
	else if (nFrom == end)
		lNewPos = m_nFileSize + lOff;
	else
		return -1;

	if (lNewPos < 0)
		return -1;

	m_nPosition = lNewPos;

	return m_nPosition;
}
/*
void CMyMemFile::Flush()
{
	ASSERT_VALID(this);
}
*/
void CMyMemFile::Close()
{
	ASSERT((m_lpBuffer == NULL && m_nBufferSize == 0) ||
		!m_bAutoDelete || AfxIsValidAddress(m_lpBuffer, (UINT)m_nBufferSize, FALSE));
	ASSERT(m_nFileSize <= m_nBufferSize);

	m_nGrowBytes = 0;
	m_nPosition = 0;
	m_nBufferSize = 0;
	m_nFileSize = 0;
	if (m_lpBuffer && m_bAutoDelete)
		Free(m_lpBuffer);
	m_lpBuffer = NULL;
}

void CMyMemFile::Abort()
{
	Close();
}

// only CMyMemFile supports "direct buffering" interaction with CArchive
UINT CMyMemFile::GetBufferPtr(UINT nCommand, UINT nCount,
	void** ppBufStart, void**ppBufMax)
{


	if (nCommand == bufferCheck)
		return 1;   // just a check for direct buffer support

	if (nCommand == bufferCommit)
	{
		// commit buffer
		m_nPosition += nCount;
		if (m_nPosition > m_nFileSize)
			m_nFileSize = m_nPosition;
		return 0;
	}


	// when storing, grow file as necessary to satisfy buffer request
	if (nCommand == bufferWrite && m_nPosition + nCount > m_nBufferSize)
		GrowFile(m_nPosition + nCount);

	// store buffer max and min
	*ppBufStart = m_lpBuffer + m_nPosition;

	// end of buffer depends on whether you are reading or writing
	if (nCommand == bufferWrite)
		*ppBufMax = m_lpBuffer + min(m_nBufferSize, m_nPosition + nCount);
	else
	{
		if (nCount == (UINT)-1)
			nCount = m_nBufferSize - m_nPosition;
		*ppBufMax = m_lpBuffer + min(m_nFileSize, m_nPosition + nCount);
		m_nPosition += LPBYTE(*ppBufMax) - LPBYTE(*ppBufStart);
	}

	// return number of bytes in returned buffer space (may be <= nCount)
	return LPBYTE(*ppBufMax) - LPBYTE(*ppBufStart);
}

DWORD CMyMemFile::GetFileSize()
{
	return m_nFileSize;
}


================================================
FILE: krnln/MyMemFile.h
================================================
// MyMemFile.h: interface for the CMyMemFile class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_MYMEMFILE_H__0D0A64A2_866B_4027_AD22_AEFE48A79B01__INCLUDED_)
#define AFX_MYMEMFILE_H__0D0A64A2_866B_4027_AD22_AEFE48A79B01__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CMyMemFile  
{

public:

// Constructors
	CMyMemFile(UINT nGrowBytes = 1024);
	CMyMemFile(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes = 0);

// Operations
	void Attach(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes = 0);
	BYTE* Detach();

// Advanced Overridables
protected:
	virtual BYTE* Alloc(DWORD nBytes);
	virtual BYTE* Realloc(BYTE* lpMem, DWORD nBytes);
//	virtual BYTE* Memcpy(BYTE* lpMemTarget, const BYTE* lpMemSource, UINT nBytes);
	virtual void Free(BYTE* lpMem);
	virtual void GrowFile(DWORD dwNewLen);

// Implementation
protected:
	UINT m_nGrowBytes;
	DWORD m_nPosition;
	DWORD m_nBufferSize;
	DWORD m_nFileSize;
	BYTE* m_lpBuffer;
	BOOL m_bAutoDelete;

public:
	DWORD GetFileSize();
	virtual ~CMyMemFile();

	virtual DWORD GetPosition() const;
	//BOOL GetStatus(CFileStatus& rStatus) const;
	enum SeekPosition { begin = 0x0, current = 0x1, end = 0x2 };
	virtual LONG Seek(LONG lOff, UINT nFrom);
	virtual void SetLength(DWORD dwNewLen);
	virtual UINT Read(void* lpBuf, UINT nCount);
	virtual void Write(const void* lpBuf, UINT nCount);
	virtual void Abort();
//	virtual void Flush();
	virtual void Close();
	enum BufferCommand { bufferRead, bufferWrite, bufferCommit, bufferCheck };
	virtual UINT GetBufferPtr(UINT nCommand, UINT nCount = 0,
		void** ppBufStart = NULL, void** ppBufMax = NULL);

	// Unsupported APIs
//	virtual CFile* Duplicate() const;
//	virtual void LockRange(DWORD dwPos, DWORD dwCount);
//	virtual void UnlockRange(DWORD dwPos, DWORD dwCount);

};

#endif // !defined(AFX_MYMEMFILE_H__0D0A64A2_866B_4027_AD22_AEFE48A79B01__INCLUDED_)


================================================
FILE: krnln/Myfunctions.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
#include <stdio.h>
#define MAX(x, y) (x) > (y) ? (x) : (y)

unsigned char lowtable[] =
{
	0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
	0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
	0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
	0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
	0x40, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
	'p' , 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',0x5B,0x5C,0x5D,0x5E,0x5F,
	0x60, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
	'p' , 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',0x7B,0x7C,0x7D,0x7E,0x7F,
	0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
	0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
	0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
	0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
	0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
	0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
	0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
	0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
};

unsigned char uptable[] =
{
	0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
	0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
	0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
	0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
	0x40, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
	'P' , 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',0x5B,0x5C,0x5D,0x5E,0x5F,
	0x60, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
	'P' , 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',0x7B,0x7C,0x7D,0x7E,0x7F,
	0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
	0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
	0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
	0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
	0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
	0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
	0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
	0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
};

int __fastcall isSSE2()
{
	static int bIsSSE2 = FALSE;
	static int bIsSSE2Check = FALSE;
	if (bIsSSE2Check)
		return bIsSSE2;
	int res = 0;
	__asm
	{
		mov eax, 01h;
		cpuid;
		mov res, edx;
	}
	bIsSSE2 = res & (1 << 26);
	bIsSSE2Check = TRUE;
	return bIsSSE2;
}

int inline MyMemCmp(unsigned char* a, unsigned char* b, int len)
{
	for (int i = 0; i < (len >> 2); i++)
	{
		if (((int*)a)[0] != ((int*)b)[0])
			return 1;
		a += 4;b += 4;
	}
	if ((len & 2) != 0)
	{
		if (((short*)a)[0] != ((short*)b)[0])
			return 1;
		a += 2;b += 2;
	}
	if ((len & 1) != 0 && a[0] != b[0])
		return 1;
	return 0;
}

static size_t mystrlen_normal(const char* pStr)
{
	const char* char_ptr;
	const unsigned int* longword_ptr;
	register unsigned int longword, himagic, lomagic;
	const char* cp;

	for (char_ptr = pStr; ((unsigned int)char_ptr & (sizeof(unsigned int) - 1)) != 0;
		++char_ptr) {
		if (*char_ptr == '\0')
			return char_ptr - pStr;
	}

	longword_ptr = (unsigned int*)char_ptr;
	himagic = 0x80808080L;
	lomagic = 0x01010101L;
	while (1) {
		longword = *longword_ptr++;
		if (((longword - lomagic) & ~longword & himagic) != 0) {
			cp = (const char*)(longword_ptr - 1);
			if (cp[0] == 0)
				return cp - pStr;
			if (cp[1] == 0)
				return cp - pStr + 1;
			if (cp[2] == 0)
				return cp - pStr + 2;
			if (cp[3] == 0)
				return cp - pStr + 3;
		}
	}
}

static size_t mystrlen_SSE2(const char* pStr)
{
	size_t res = 0;
	__asm
	{
		mov eax, pStr;                        // get pointer to string
		test eax, eax;
		je END__;                            // return 0 if eax is NULL
		mov ecx, eax;                        // copy pointer
		// pxor xmm0,xmm0;                   // set to zero
		_EMIT 0x66;
		_EMIT 0x0F;
		_EMIT 0xEF;
		_EMIT 0xC0;
		and ecx, 0Fh;                        // lower 4 bits indicate misalignment
		and eax, 0FFFFFFF0h;                 // align pointer by 16
		// movdqa xmm1, [eax];               // read from nearest preceding boundary
		_EMIT 0x66;
		_EMIT 0x0F;
		_EMIT 0x6F;
		_EMIT 0x08;
		// pcmpeqb xmm1,xmm0;                // compare 16 bytes with zero
		_EMIT 0x66;
		_EMIT 0x0F;
		_EMIT 0x74;
		_EMIT 0xC8;
		// pmovmskb edx, xmm1;               // get one bit for each byte result
		_EMIT 0x66;
		_EMIT 0x0F;
		_EMIT 0xD7;
		_EMIT 0xD1;
		shr edx, cl;                         // shift out false bits
		shl edx, cl;                         // shift back again
		bsf edx, edx;                        // find first 1 - bit
		jne A200;                            // found

		//; Main loop, search 16 bytes at a time
	A100:
		add eax, 10h;                        // increment pointer by 16
		// movdqa   xmm1, [eax];             // read 16 bytes aligned
		_EMIT 0x66;
		_EMIT 0x0F;
		_EMIT 0x6F;
		_EMIT 0x08;
		// pcmpeqb  xmm1, xmm0;              // compare 16 bytes with zero
		_EMIT 0x66;
		_EMIT 0x0F;
		_EMIT 0x74;
		_EMIT 0xC8;
		// pmovmskb edx, xmm1;               // get one bit for each byte result
		_EMIT 0x66;
		_EMIT 0x0F;
		_EMIT 0xD7;
		_EMIT 0xD1;
		bsf edx, edx;                        // find first 1 - bit
		//; (moving the bsf out of the loop and using test here would be faster for long strings on old processors,
		//;  but we are assuming that most strings are short, and newer processors have higher priority)
		je A100;                            // loop if not found

	A200: //; Zero - byte found.Compute string length
		sub eax, pStr;                        // subtract start address
		add eax, edx;                        // add byte index
		mov res, eax;
	END__:
	}
	return res;
}

size_t mystrlen_auto(const char* pStr)
{ // ˺Ϊ亯ֻᱻһΡ
	if (isSSE2())
	{ // ֧SSE2ָ
		mystrlen = mystrlen_SSE2;
		return mystrlen_SSE2(pStr);
	}
	else
	{
		mystrlen = mystrlen_normal;
		return mystrlen_normal(pStr);
	}
	return 0;
}
MYSTRLEN mystrlen = mystrlen_auto;

int __fastcall mymemchr(unsigned char* pSrc, int nLen, unsigned char Des)
{
	register unsigned int longword, dmagic, * longword_ptr;
	unsigned char* cp;
	unsigned char* char_ptr = pSrc;
	for (int i = 0; i < (nLen & 3);i++)
		if (*char_ptr++ == Des)
			return char_ptr - pSrc - 1;

	dmagic = Des | (Des << 8) | (Des << 16) | (Des << 24);
	for (longword_ptr = (unsigned int*)char_ptr; longword_ptr < (unsigned int*)(pSrc + nLen); longword_ptr++)
	{
		longword = *longword_ptr ^ dmagic;
		if (((longword - 0x01010101) & ~longword & 0x80808080) != 0)
		{
			cp = (unsigned char*)(longword_ptr);
			if (cp[0] == Des)
				return cp - pSrc;
			if (cp[1] == Des)
				return cp - pSrc + 1;
			if (cp[2] == Des)
				return cp - pSrc + 2;
			if (cp[3] == Des)
				return cp - pSrc + 3;
		}
	}
	return -1;
}

int __fastcall myinstring(unsigned char* src, int slen, unsigned char* des, int dlen)
{
	//	register unsigned char* naddr;
	//	int sl;int i;int j;
	int i;
	if (!src || !des || !slen || !dlen || dlen > slen)
		return -1;

	switch (dlen)
	{
	case 1:  // Ӵֱӱ
		return mymemchr(src, slen, des[0]);
	case 2:
		for (i = 0; i < slen - 1; i++)
			if (((short*)(src + i))[0] == ((short*)des)[0])
				return i;
		return -1;
	case 3:
		for (i = 0; i < slen - 2; i++)
			if (((short*)(src + i))[0] == ((short*)des)[0])
				if (src[i + 2] == des[2])
					return i;
		return -1;
	case 4:
		for (i = 0; i < slen - 3; i++)
			if (((int*)(src + i))[0] == ((int*)des)[0])
				return i;
		return -1;
	case 5:
		for (i = 0; i < slen - 4; i++)
			if (((int*)(src + i))[0] == ((int*)des)[0])
				if (src[i + 4] == des[4])
					return i;
		return -1;
	case 6:
		for (i = 0; i < slen - 5; i++)
			if (((int*)(src + i))[0] == ((int*)des)[0])
				if (((short*)(src + i + 4))[0] == ((short*)(des + 4))[0])
					return i;
		return -1;
	default:// ӴʹBM㷨,
		return boyer_moore(src, slen, des, dlen);
	}

}

char* TBR::toString()
{
	if (m_nCount <= 0 || m_nTLen <= 0 || !m_data)
	{
		return NULL;
	}
	char* pText = (char*)E_MAlloc_Nzero(m_nTLen + 1);
	char* pRetnTmp = pText;

	for (int i = 0; i < m_nCount; i++)
	{
		memcpy(pRetnTmp, m_data[i].addr, m_data[i].len);
		pRetnTmp += m_data[i].len;
	}
	pText[m_nTLen] = '\0';
	return pText;
}

TBR::TBR()
{
	m_nCount = 0;
	m_nTCount = 0;
	m_nTLen = 0;
	m_data = NULL;
}
TBR::~TBR()
{
	if (m_data)
	{
		free(m_data);
	}
}
void TBR::add(PVOID addr, size_t len)
{
	if (!m_data)
	{
		m_data = (PTBRECORD)malloc(512 * sizeof(TBRECORD));
		if (!m_data)
			return;
		m_nTCount = 512;
	}
	if (m_nCount >= m_nTCount)
	{
		int nNewCount = m_nTCount << 1;
		PVOID pNewData = realloc(m_data, nNewCount * sizeof(TBRECORD));
		if (!pNewData)
		{
			pNewData = malloc(sizeof(TBRECORD) * nNewCount);
			if (!pNewData)
				return;
			memcpy(pNewData, m_data, sizeof(TBRECORD) * m_nTCount);
			free(m_data);
		}
		m_data = (TBRECORD*)pNewData;
		m_nTCount = nNewCount;
	}
	if (len < 0)
	{
		len = 0;
	}
	m_data[m_nCount].addr = addr;
	m_data[m_nCount++].len = len;
	m_nTLen += len;
}

INT __fastcall mystristr(char* str1, char* str2)
{
	register char* cp = str1;
	register char* s1, * s2;
	register unsigned char* lt = lowtable;
	while (*cp)
	{
		s1 = cp;
		s2 = str2;
		while (*s1 && *s2 && (*s1 == *s2 || lt[(unsigned char)(*s1)] == lt[(unsigned char)(*s2)]))
			s1++, s2++;
		if (!*s2)
			return cp - str1;

		if (*cp < 0)
		{
			cp++;
			if (!*cp)
				return -1;
		}
		cp++;
	}
	return -1;
}

INT __fastcall mystrstr(char* str1, char* str2)
{
	register char* cp = str1;
	register char* s1, * s2;
	while (*cp)
	{
		s1 = cp;
		s2 = str2;
		while (*s1 && *s2 && !(*s1 - *s2))
			s1++, s2++;
		if (!*s2)
			return cp - str1;

		if (*cp < 0)
		{
			cp++;
			if (!*cp)
				return -1;
		}
		cp++;
	}
	return -1;
}

#define ALPHABET_LEN 256
#define NOT_FOUND patlen

// delta1 table: delta1[c] contains the distance between the last
// character of pat and the rightmost occurrence of c in pat.
// If c does not occur in pat, then delta1[c] = patlen.
// If c is at string[i] and c != pat[patlen-1], we can
// safely shift i over by delta1[c], which is the minimum distance
// needed to shift pat forward to get string[i] lined up
// with some character in pat.
// this algorithm runs in alphabet_len+patlen time.
void make_delta1(int* delta1, unsigned char* pat, int patlen) {
	int i;

	for (i = 0; i < ALPHABET_LEN; i++) {
		delta1[i] = NOT_FOUND;
	}
	for (i = 0; i < patlen - 1; i++) {
		delta1[pat[i]] = patlen - 1 - i;
	}
}

// true if the suffix of word starting from word[pos] is a prefix
// of word
int is_prefix(unsigned char* word, int wordlen, int pos) {
	int i;
	int suffixlen = wordlen - pos;

	for (i = 0; i < suffixlen; i++) {
		if (word[i] != word[pos + i]) {
			return 0;
		}
	}
	return 1;
}

// length of the longest suffix of word ending on word[pos].
// suffix_length("dddbcabc", 8, 4) = 2
int suffix_length(unsigned char* word, int wordlen, int pos) {
	int i;
	// increment suffix length i to the first mismatch or beginning
	// of the word
	for (i = 0; (word[pos - i] == word[wordlen - 1 - i]) && (i < pos); i++);
	return i;
}

// delta2 table: given a mismatch at pat[pos], we want to align
// with the next possible full match could be based on what we
// know about pat[pos+1] to pat[patlen-1].
//
// In case 1:
// pat[pos+1] to pat[patlen-1] does not occur elsewhere in pat,
// the next plausible match starts at or after the mismatch.
// If, within the substring pat[pos+1 .. patlen-1], lies a prefix
// of pat, the next plausible match is here (if there are multiple
// prefixes in the substring, pick the longest). Otherwise, the
// next plausible match starts past the character aligned with
// pat[patlen-1].
//
// In case 2:
// pat[pos+1] to pat[patlen-1] does occur elsewhere in pat. The
// mismatch tells us that we are not looking at the end of a match.
// We may, however, be looking at the middle of a match.
//
// The first loop, which takes care of case 1, is analogous to
// the KMP table, adapted for a 'backwards' scan order with the
// additional restriction that the substrings it considers as
// potential prefixes are all suffixes. In the worst case scenario
// pat consists of the same letter repeated, so every suffix is
// a prefix. This loop alone is not sufficient, however:
// Suppose that pat is "ABYXCDEYX", and text is ".....ABYXCDEYX".
// We will match X, Y, and find B != E. There is no prefix of pat
// in the suffix "YX", so the first loop tells us to skip forward
// by 9 characters.
// Although superficially similar to the KMP table, the KMP table
// relies on information about the beginning of the partial match
// that the BM algorithm does not have.
//
// The second loop addresses case 2. Since suffix_length may not be
// unique, we want to take the minimum value, which will tell us
// how far away the closest potential match is.
void make_delta2(int* delta2, unsigned char* pat, int patlen) {
	int p;
	int last_prefix_index = 1;

	// first loop, prefix pattern
	for (p = patlen - 1; p >= 0; p--) {
		if (is_prefix(pat, patlen, p + 1)) {
			last_prefix_index = p + 1;
		}
		delta2[p] = (patlen - 1 - p) + last_prefix_index;
	}

	// this is overly cautious, but will not produce anything wrong
	// second loop, suffix pattern
	for (p = 0; p < patlen - 1; p++) {
		int slen = suffix_length(pat, patlen, p);
		if (pat[p - slen] != pat[patlen - 1 - slen]) {
			delta2[patlen - 1 - slen] = patlen - 1 - p + slen;
		}
	}
}

int boyer_moore(unsigned char* string, int stringlen, unsigned char* pat, int patlen) {
	int i;
	int delta1[ALPHABET_LEN];
	int* delta2 = (int*)malloc(patlen * sizeof(int));
	if (!delta2)
		return -1;
	make_delta1(delta1, pat, patlen);
	make_delta2(delta2, pat, patlen);
	int n_shifts = 0;

	i = patlen - 1;
	while (i < stringlen) {
		int j = patlen - 1;
		while (j >= 0 && (string[i] == pat[j])) {
			--i;
			--j;
		}

		if (j < 0) {
			free(delta2);
			return i + 1;
		}

		i += max(delta1[string[i]], delta2[j]);
	}
	free(delta2);
	return -1;
}


void swap_hex(unsigned char* str, int len)
{
	for (int i = 0; i < len / 2; i += sizeof(WORD))
	{
		WORD temp = *(WORD*)(str + len - i - sizeof(WORD));
		*(WORD*)(str + len - i - sizeof(WORD)) = *(WORD*)(str + i);
		*(WORD*)(str + i) = temp;
	}
}

void E_RC4_init(unsigned char* keytable, unsigned char* key, int keylen)
{
	int i = 0, j = 0;
	unsigned char k[256] = { 0 };
	unsigned char tmp = 0;
	for (i = 0; i < 256; i++) {
		keytable[i] = i;
		k[i] = key[i % keylen];
	}
	for (i = 0; i < 256; i++) {
		tmp = keytable[i];
		j = (j + tmp + k[i]) % 256;
		keytable[i] = keytable[j];//s[i]s[j]
		keytable[j] = tmp;
	}
	keytable[256] = 0;
	keytable[257] = 0;
}

void E_RC4_updatetable(int len, unsigned char* keytable)
{
	int i;
	unsigned char tmp;
	unsigned char x = keytable[256];
	unsigned char y = keytable[257];
	for (i = 0; i < len; i++)
	{
		x = (x + 1);
		tmp = keytable[x];
		y = (y + tmp);
		keytable[x] = keytable[y];//s[x]s[y]
		keytable[y] = tmp;
	}
	keytable[256] = x;
	keytable[257] = y;
}

void E_RC4(unsigned char* data, int datalen, unsigned char* keytable)
{
	int i;
	unsigned char tmp;
	unsigned char x = keytable[256];
	unsigned char y = keytable[257];
	for (i = 0; i < datalen; i++)
	{
		x = (x + 1);
		tmp = keytable[x];
		y = (y + tmp);
		keytable[x] = keytable[y];//s[x]s[y]
		keytable[y] = tmp;
		data[i] ^= keytable[(unsigned char)(keytable[x] + tmp)];
	}
	keytable[256] = x;
	keytable[257] = y;
}

#define ERC4_TLEN 258
#define ERC4_CHUNK 4096
BOOL E_RC4_Calc(int pos, unsigned char* pData, int nDlen, unsigned char* pKeytable, int nCryptStart, unsigned char* pMD5)
{
	int nCTLen, nCTRemain;
	int nTableLen, nTableIndex;
	int nChunk, nOChunk;
	int nF, nB;
	unsigned char pTableTMP[ERC4_TLEN];
	unsigned char* pTableData, * pTableData2;
	unsigned char pNewPass[40]; // 4 + 32 + 4

	memcpy(pTableTMP, pKeytable, ERC4_TLEN);

	nCTLen = nCryptStart;
	nCTRemain = nCTLen - pos;
	if (nCTRemain > 0)
	{
		pData += nCTRemain;
		nDlen -= nCTRemain;
		if (nDlen <= 0)
			return FALSE;
		pos = nCTLen;
	}

	E_RC4_updatetable(4 * (pos / ERC4_CHUNK), pTableTMP);
	nTableLen = 4 * (nDlen / ERC4_CHUNK) + 8;
	if (nTableLen % 4 > 0)
		nTableLen = nTableLen + nTableLen % 4;

	pTableData = new unsigned char[nTableLen];
	memset(pTableData, 0, nTableLen);
	pTableData2 = pTableData;
	E_RC4(pTableData, nTableLen, pTableTMP);

	nTableIndex = pos / ERC4_CHUNK;
	nChunk = pos % ERC4_CHUNK;
	if (nChunk >= 0)
	{
		nF = *((int*)pTableData);
		nB = nTableIndex ^ nF;

		*((int*)pNewPass) = nF;
		memcpy(pNewPass + 4, pMD5, 32);
		*((int*)(pNewPass + 36)) = nB;

		nTableIndex++;
		pTableData += 4;

		E_RC4_init(pTableTMP, pNewPass, 40);
		E_RC4_updatetable(nChunk + 36, pTableTMP);

		nOChunk = min(ERC4_CHUNK - nChunk, nDlen);
		E_RC4(pData, nOChunk, pTableTMP);

		nDlen -= nOChunk;
		pData += nOChunk;
	}

	while (nDlen > 0)
	{
		nF = *((int*)pTableData);
		nB = nTableIndex ^ nF;

		*((int*)pNewPass) = nF;
		memcpy(pNewPass + 4, pMD5, 32);
		*((int*)(pNewPass + 36)) = nB;

		nTableIndex++;
		pTableData += 4;

		E_RC4_init(pTableTMP, pNewPass, 40);
		E_RC4_updatetable(nChunk + 36, pTableTMP);

		if (nDlen <= ERC4_CHUNK)
		{
			E_RC4(pData, nDlen, pTableTMP);
			pData += nDlen;
			nDlen = 0;
			break;
		}
		E_RC4(pData, ERC4_CHUNK, pTableTMP);
		nDlen -= ERC4_CHUNK;
		pData += ERC4_CHUNK;
	}

	delete[]pTableData2;
	return TRUE;
}

================================================
FILE: krnln/Myfunctions.h
================================================
#ifndef _MY_FUNCS_
#define _MY_FUNCS_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

typedef struct _MEMSP_{
	char* pData;
	int nLen;
}MEMSP, *PMEMSP;

typedef struct _TBRECORD{
	PVOID	addr;	//ݵַ
	DWORD	len;	//ݳ
}TBRECORD, *PTBRECORD;

class TBR
{
public:
	TBR();
	~TBR();
	void add(PVOID addr, size_t len);
	char* toString(); //ֵҪͷ
	int m_nCount;
	int m_nTCount;
	size_t m_nTLen;
	PTBRECORD m_data;
};

extern unsigned char lowtable[];
extern unsigned char uptable[];

int __fastcall mymemchr(unsigned char *pSrc, int nLen, unsigned char Des);
int boyer_moore(unsigned char* string, int stringlen, unsigned char* pat, int patlen);

int inline MyMemCmp(unsigned char* a, unsigned char* b, int len);

typedef size_t (*MYSTRLEN)(const char *str);
// ȡַ
extern MYSTRLEN mystrlen;

int __fastcall myinstring(unsigned char *src, int slen,unsigned char *des, int dlen);
INT __fastcall mystristr(char* str1, char* str2);
INT __fastcall mystrstr(char* str1, char* str2);

void swap_hex(unsigned char* string, int length);
void E_RC4_init(unsigned char* keytable, unsigned char* key, int keylen);
void E_RC4_updatetable(int len, unsigned char* keytable);
void E_RC4(unsigned char* data, int datalen, unsigned char* keytable);
BOOL E_RC4_Calc(int pos, unsigned char *pData,int nDlen, unsigned char *pKeytable, int nCryptStart, unsigned char *pMD5);

#endif


================================================
FILE: krnln/NumToChinese.cpp
================================================
#include "stdafx.h"
#include <stdio.h>
#include <math.h>
#include "Myfunctions.h"

char bigChn []= "\0Ҽ\0\0\0\0\0½\0\0\0\0";//48-57
char smlChn []= "\0һ\0\0\0\0\0\0\0\0\0";
char strNumLeven1 []= "\0Ǫ\0\0ʰ\0\0";
char strNumLeven2 []= "\0ǧ\0\0ʮ\0\0";

BOOL ReadChnNum(LPSTR pText,LPSTR pStrSrc,LPSTR pNumStr,LPSTR pNumLeven,INT nNum,INT& nPre)
{

	pNumLeven += ((5-nNum)*3);
	BOOL bAllZero = TRUE;

	for(INT i=0;i<nNum;i++)
	{
		INT nOffset = pStrSrc[i]-48;
		LPSTR pStr = pNumStr + nOffset*3;

		if(nOffset !=0)
		{
			if(nPre ==0)
				strcat(pText,"");
			strcat(pText,pStr);
			pStr = pNumLeven + i*3;
			strcat(pText,pStr);
			bAllZero = FALSE;
		}
		nPre = nOffset;

	}
	return bAllZero;

}
LPSTR IntNumToChn (double dNum,BOOL bSml,INT& nPre)
{
	char str [MAX_PATH];
	LPSTR pText = NULL;
	sprintf(str,"%.0lf",dNum);
	INT nLen = mystrlen(str);
	if(nLen>13)
	{
		pText = (LPSTR)malloc (3);
		strcpy(pText,"");
		return pText;
	}
	pText = (LPSTR)malloc (nLen*4+4);
	*pText=0;
	LPSTR pNum;
	LPSTR pNumLeven;
	if(bSml)
	{
		pNum = smlChn;
		pNumLeven = strNumLeven2;
	}
	else
	{
		pNum = bigChn;
		pNumLeven = strNumLeven1;
	}

	LPSTR pSrc = str;
	if(*pSrc==45)
	{
		pSrc++;
		strcat(pText,"");
	}
	//Ǫʰ-Ǫʰ-Ǫʰ
	nPre = -1;
	if(nLen > 8)
	{
		INT nNum = nLen - 8;
		ReadChnNum(pText,pSrc,pNum,pNumLeven,nNum,nPre);
		strcat(pText,"");
		pSrc+=nNum;
		BOOL nAll0 = ReadChnNum(pText,pSrc,pNum,pNumLeven,4,nPre);
		if(!nAll0)
			//strcat(pText,"");
		//else
			strcat(pText,"");
		pSrc+=4;
		ReadChnNum(pText,pSrc,pNum,pNumLeven,4,nPre);


	}else if(nLen > 4)
	{
		INT nNum = nLen - 4;
		ReadChnNum(pText,pSrc,pNum,pNumLeven,nNum,nPre);
		strcat(pText,"");
		pSrc+=nNum;
		ReadChnNum(pText,pSrc,pNum,pNumLeven,4,nPre);
	}
	else 
	{
		ReadChnNum(pText,pSrc,pNum,pNumLeven,nLen,nPre);
	}


	
	return pText;
	

}
LPSTR FloatNumToChn (double dNum,BOOL bSml)//ﲻܴ0ֵ
{
	char str [MAX_PATH];
	dNum = fabs(dNum);

	sprintf(str,"%.2lf",dNum);
	LPSTR pSrc = str;
	while(*pSrc !=0 && *pSrc != '.')
		pSrc++;
	if(*pSrc ==0)
		return NULL;
	pSrc++;

	LPSTR pNum;

	if(bSml)
		pNum = smlChn;
	else
		pNum = bigChn;

	LPSTR pText = (LPSTR)malloc (64);
	strcpy(pText,"");

	INT nOffset = pSrc[0]-48;
	LPSTR pStr = pNum + nOffset*3;
	strcat(pText,pStr);
	nOffset = pSrc[1]-48;
	if(nOffset)
	{
		pStr = pNum + nOffset*3;
		strcat(pText,pStr);
	}

	return pText;
}

LPSTR FloatNumToRMB (double dNum,BOOL bSml)//ﲻܴ0ֵ
{
	char str [MAX_PATH];
	dNum = fabs(dNum);

	sprintf(str,"%.2lf",dNum);
	LPSTR pSrc = str;
	while(*pSrc !=0 && *pSrc != '.')
		pSrc++;
	if(*pSrc ==0)
		return NULL;
	pSrc++;

	LPSTR pNum;

	if(bSml)
		pNum = smlChn;
	else
		pNum = bigChn;

	LPSTR pText = (LPSTR)malloc (64);
	*pText=0;


	INT nOffset = pSrc[0]-48;
	if(nOffset)
	{
		LPSTR pStr = pNum + nOffset*3;
		strcat(pText,pStr);
		strcat(pText,"");
	}
	nOffset = pSrc[1]-48;
	if(nOffset)
	{
		LPSTR pStr = pNum + nOffset*3;
		strcat(pText,pStr);
		strcat(pText,"");
	}

	return pText;
}

================================================
FILE: krnln/SDataToStr.cpp
================================================
#include "stdafx.h"
#include <stdio.h>
#include "LTrimZeroChr.h"
#include "Myfunctions.h"
char* SDataToStr(PMDATA_INF pArgInf)
{
	char* pSrc = NULL;
	char str[MAX_PATH];
	if ((pArgInf->m_dtDataType & DT_IS_ARY) == 0)//
	{


		switch (pArgInf->m_dtDataType)
		{
		case SDT_BYTE:
		case SDT_SHORT:
		case SDT_INT:
		case SDT_SUB_PTR:
			sprintf(str, "%d", pArgInf->m_int);
			pSrc = str;
			break;
		case SDT_INT64:
			sprintf(str, "%I64d", pArgInf->m_int64);
			pSrc = str;
			break;
		case SDT_FLOAT:
			sprintf(str, "%f", pArgInf->m_float);
			LTrimZeroChr(str);
			pSrc = str;
			break;
		case SDT_DOUBLE:
			sprintf(str, "%.13g", pArgInf->m_double);
			LTrimZeroChr(str);
			pSrc = str;
			break;
		case SDT_BOOL:
			if (pArgInf->m_bool)
				strcpy(str, "");
			else
				strcpy(str, "");
			pSrc = str;
			break;

		case SDT_DATE_TIME:
			DateTimeFormat(str, pArgInf->m_double);
			pSrc = str;
			break;
		}
		if (pSrc)
		{
			INT nLen = mystrlen(str);
			pSrc = (LPSTR)malloc(nLen + 1);
			strcpy(pSrc, str);
		}
	}
	return pSrc;
}

================================================
FILE: krnln/StdAfx.cpp
================================================
// stdafx.cpp : source file that includes just the standard includes
//	krnln.pch will be the pre-compiled header
//	stdafx.obj will contain the pre-compiled type information

#include "stdafx.h"



================================================
FILE: krnln/StdAfx.h
================================================
// stdafx.h : include file for standard system include files,
//  or project specific include files that are used frequently, but
//      are changed infrequently
//

#if !defined(AFX_STDAFX_H__F1B1835D_D6C8_463B_BD64_E80802519246__INCLUDED_)
#define AFX_STDAFX_H__F1B1835D_D6C8_463B_BD64_E80802519246__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000


#define VC_EXTRALEAN		// Exclude rarely-used stuff from Windows headers

//#include <afx.h>
//#include <afxwin.h>
#include <windows.h>

// TODO: reference additional headers your program requires here
#ifndef DOUBLE
typedef double DOUBLE;
#endif

#ifndef DATE
typedef double DATE;
#endif

#include "lib2.h"


//**********************************************//
// øʽ LIBAPI (ֵ,  )
// nArgCount	
// ArgInf		һȡָ PMDATA_INF pArgInf = &ArgInf;Ȼ
//					pArgInf[0] һ
//					pArgInf[1] ڶ
//					... 
//**********************************************//
#define LIBAPI(rType, fnName) extern "C" rType _cdecl fnName(INT nArgCount,MDATA_INF ArgInf,...)

typedef void (*PDESTROY)(void);
extern "C" {
	void  _cdecl E_DestroyRes();
	void  _cdecl E_Init();
	void  _cdecl E_End (DWORD Param1);
	void  _cdecl E_ReportError (DWORD Param1, DWORD MethodId, DWORD position);
	void*  _cdecl E_MAlloc (DWORD Param1);
	void*  _cdecl E_MAlloc_Nzero (DWORD Param1);
	void*  _cdecl E_MRealloc (void * Param1,DWORD Param2);
	void  _cdecl E_MFree (void * Param1);
	void  _cdecl E_Destroy (PDESTROY Param1);
	char* _cdecl krnln_BJCase (INT nArgCount,MDATA_INF ArgInf,...);
	char* _cdecl krnln_LTrim (INT nArgCount,MDATA_INF ArgInf,...);
	void*  _cdecl E_NULLARRAY ();
}

void* GetAryElementInf(void* pAryData ,DWORD& AryElementCount);
void FreeAryElement (void* pAryData);
void GetTimePart(DATE dt,INT& nHour,INT& nMinute,INT& nSecond);
void GetDatePart(DATE dt,INT& nYear,INT& nMonth,INT& nDay);
//СϵһaΪ,bΪС,aΪ׼
//ȷaֻbֻС
double makedb(double a, double b);
//׵ʱͣתԶʱͣλ 
DATE toMyDate(DATE dt);
//Զʱת׵ʱ
DATE toEDate(DATE dt);
void DateTimeFormat(LPSTR strValue,DATE dt,BOOL bOnlyDatePart=FALSE);
double GetSpecDateTime(INT nYear, INT nMonth, INT nDay, INT nHour,INT nMinute,INT nSecond);

#define DTT_IS_NULL_DATA_TYPE   0
#define DTT_IS_SYS_DATA_TYPE    1
#define DTT_IS_USER_DATA_TYPE   2
#define DTT_IS_LIB_DATA_TYPE    3
#define ASSERT(x)
INT GetDataTypeType (DATA_TYPE dtDataType);
LPBYTE CloneBinData (LPBYTE pData, INT nDataSize);
char* CloneTextData (char* ps, INT nTextLen);
char* CloneTextData (char* ps);
INT GetSysDataTypeDataSize (DATA_TYPE dtSysDataType);

#define		VAR_BYTE		MAKELONG (MAKEWORD (1, 1), 0xa000)		// ֽ
#define		VAR_SHORT		MAKELONG (MAKEWORD (1, 2), 0xa000)		// 
#define		VAR_INT			MAKELONG (MAKEWORD (1, 3), 0xa000)		// 
#define		VAR_INT64		MAKELONG (MAKEWORD (1, 4), 0xa000)		// 
#define		VAR_FLOAT		MAKELONG (MAKEWORD (1, 5), 0xa000)		// С
#define		VAR_DOUBLE		MAKELONG (MAKEWORD (1, 6), 0xa000)		// ˫С
#define		VAR_BOOL		MAKELONG (MAKEWORD (2, 0), 0xa000)		// ߼
#define		VAR_DATE_TIME	MAKELONG (MAKEWORD (3, 0), 0xa000)		// ʱ
#define		VAR_TEXT		MAKELONG (MAKEWORD (4, 0), 0xa000)		// ı
#define		VAR_BIN			MAKELONG (MAKEWORD (5, 0), 0xa000)		// ֽڼ
#define		VAR_SUB_PTR		MAKELONG (MAKEWORD (6, 0), 0xa000)		// ¼ûӳĴַ

LPSTR IntNumToChn (double dNum,BOOL bSml,INT& nPre);
LPSTR FloatNumToChn (double dNum,BOOL bSml);
LPSTR FloatNumToRMB (double dNum,BOOL bSml);

INT GetDaysOfSpecMonth(INT nYear,INT nMonth);
INT GetWeekDay(DATE date);

typedef struct
{
	INT nType;  
	void* FileHandle;
	void* pLast;
	INT nCryptStart;
	unsigned char strMD5[36];
	unsigned char strTable[258];
}
FILEELEMENT, *PFILEELEMENT;

BOOL IsInFileMangerList(PFILEELEMENT pFile);
void ResetFileIO();
void CloseEfile(PFILEELEMENT pFile);
void AddFileMangerList(PFILEELEMENT pFile);

char* SDataToStr (PMDATA_INF pArgInf);
HKEY GetRegRootVal(INT nVal);

typedef struct
{
	LPDISPATCH pDisp;  
	HRESULT hRet;
}
EYDISPATCH, *PEYDISPATCH;

typedef INT (__stdcall*EError_CALLBACK)(int nCode, char* errText);
extern EError_CALLBACK fnEError_callback;

BOOL replaceText(LPSTR& pDest,LPSTR pSub,LPSTR pRplStr,BOOL bNeedFree);
//ֵֿ֧֧ʵֺ
void BlackMoonInitAllElib();
void BlackMoonFreeAllElib();
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_STDAFX_H__F1B1835D_D6C8_463B_BD64_E80802519246__INCLUDED_)


================================================
FILE: krnln/eHelpFunc.cpp
================================================
#include "stdafx.h"

#pragma comment(lib,"kernel32.lib") 
#pragma comment(lib,"user32.lib") 

HANDLE hBlackMoonInstanceHandle = NULL;
DWORD dwBlackMoonPESizeOfImage = 0;
DWORD dwBlackMoonPEAddrrStart;
DWORD dwBlackMoonPEAddrrEnd;

EError_CALLBACK fnEError_callback = NULL;
INT isErrorCallBack = 0;

void GetBlackMoonPESizeOfImage()
{
	PBYTE module;
	if(hBlackMoonInstanceHandle)
		module = (PBYTE)hBlackMoonInstanceHandle;
	else
		module = (PBYTE)::GetModuleHandle(NULL);
	dwBlackMoonPESizeOfImage = ((PIMAGE_NT_HEADERS)(module+((PIMAGE_DOS_HEADER)module)->e_lfanew))->OptionalHeader.SizeOfImage;
	dwBlackMoonPEAddrrStart = (DWORD)module;
	dwBlackMoonPEAddrrEnd = (DWORD)module+dwBlackMoonPESizeOfImage;

}
LPSTR sErrorListForE []=
{
(LPSTR)"Ա±곬巶Χ",
(LPSTR)"δõҪֵ",
(LPSTR)"ԱʱάΪ1ҲڸĿǰеά",
(LPSTR)"Ա±ڵ1",
(LPSTR)"ݻͲƥ",
(LPSTR)"DLLֶջͨDLLĿȷ",
(LPSTR)"δݻ߷˷ϵͳͻ",
(LPSTR)"Ƚֻʹõڻ򲻵Ƚ",
(LPSTR)"ѡֵС򳬳ṩΧ",
(LPSTR)"ض顱άֵάʱڵ",
(LPSTR)"ṩͲҪ"
};
//extern BOOL bIsEnterFromBMEntrypoint;
extern INT nBMProtectESP;
extern INT nBMProtectEBP;
extern "C" {



PDESTROY DestroyAddress = NULL;

PDESTROY HFileDestroyAddress = NULL;

PDESTROY DestroyMidiPlayer = NULL;

HANDLE hBlackMoonHeap = NULL;

PDESTROY BlackMoonFreeAllUserDll = NULL;

#pragma warning(push)
#pragma warning(disable : 4731)
	void  _cdecl E_End (DWORD Param1){

		E_DestroyRes();
		//if(bIsEnterFromBMEntrypoint)
		if(nBMProtectESP==0){
			 ExitProcess(Param1);
			 return;
		}

		__asm {
			mov eax,Param1;
			mov ebp,nBMProtectEBP;
			mov esp,nBMProtectESP;
			sub esp,4;
			ret;
		}

	}
#pragma warning(pop)

	void  _cdecl E_ReportError (DWORD Param1, DWORD MethodId, DWORD position){
		char ErrorString [255];
//		int nEbx;
		//__asm mov nEbx,ebx;
		LPSTR ptxt = NULL;
		if(0 <Param1 && Param1<12)
			ptxt = sErrorListForE[Param1-1];

		BOOL bThreeParam = FALSE;
		char *pRetnAddr = (char*)*(&Param1-1); // ȡصַ
		if (NULL != pRetnAddr)
		{
			if (0xC483 == *(unsigned short*)(pRetnAddr)) // ǷΪadd esp, xxx;
			{
				bThreeParam = (0x0C <= *(pRetnAddr+2)); // ƽջΪ12ʾ
			}
		}
		if (bThreeParam) // 5.8汾ϲŻɵİ汾ֻһ
		{ wsprintf(ErrorString, "program internal error number is %d. \r\n%s\r\nλ:%d,%d", Param1, ptxt, MethodId, position); }
		else
		{ wsprintf(ErrorString, "program internal error number is %d. \r\n%s\r\n", Param1, ptxt); }

		INT nNoErrorBox = 0;
  		if (fnEError_callback && !isErrorCallBack)
		{
			isErrorCallBack = 1;
			nNoErrorBox = fnEError_callback(Param1, ErrorString);
			isErrorCallBack = 0;
		}

		if (!nNoErrorBox)
  			MessageBox(0, ErrorString, "error", MB_ICONERROR);

		E_End(0);

	}

	void*  _cdecl E_MAlloc (DWORD Param1){
		
		if(hBlackMoonHeap==NULL)
			hBlackMoonHeap =::GetProcessHeap();
		void * pData = HeapAlloc(hBlackMoonHeap, HEAP_ZERO_MEMORY, Param1);//malloc(Param1);//
		
		if(!pData)
			//ZeroMemory(pData,Param1);
		//else
		{
			char ErrorString[255];
			char** pRetnAddr = (char**)(&Param1 - 1); // ȡصַ
			wsprintf(ErrorString, "%dֽڴʧ.\r\n"
				"ջϢ:\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n", 
				Param1,
				pRetnAddr[0], pRetnAddr[1],
				pRetnAddr[2], pRetnAddr[3],
				pRetnAddr[4], pRetnAddr[5],
				pRetnAddr[6], pRetnAddr[7],
				pRetnAddr[8], pRetnAddr[9],
				pRetnAddr[10], pRetnAddr[11],
				pRetnAddr[12], pRetnAddr[13],
				pRetnAddr[14], pRetnAddr[15]);
			MessageBox(0, ErrorString, "error", MB_ICONERROR);
			E_End (0);
		}

		return pData;
	}

	void*  _cdecl E_MAlloc_Nzero (DWORD Param1){
		
		if(hBlackMoonHeap==NULL)
			hBlackMoonHeap =::GetProcessHeap();
		void * pData = HeapAlloc(hBlackMoonHeap, NULL, Param1);//malloc(Param1);//
		
		if(!pData)
		{
			char ErrorString[255];
			char** pRetnAddr = (char**)(&Param1 - 1); // ȡصַ
			wsprintf(ErrorString, "%dֽڴʧ.\r\n"
				"ջϢ:\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n", 
				Param1,
				pRetnAddr[0], pRetnAddr[1],
				pRetnAddr[2], pRetnAddr[3],
				pRetnAddr[4], pRetnAddr[5],
				pRetnAddr[6], pRetnAddr[7],
				pRetnAddr[8], pRetnAddr[9],
				pRetnAddr[10], pRetnAddr[11],
				pRetnAddr[12], pRetnAddr[13],
				pRetnAddr[14], pRetnAddr[15]);
			MessageBox(0, ErrorString, "error", MB_ICONERROR);
			E_End (0);
		}
		
		return pData;
	}

	void*  _cdecl E_MRealloc (void * Param1,DWORD Param2){
		void * pData;
		if(hBlackMoonHeap==NULL)
			hBlackMoonHeap =::GetProcessHeap();
		
		if(Param1)
			pData = HeapReAlloc(hBlackMoonHeap, 0, Param1, Param2);//realloc(Param1, Param2);//
		else
			pData = HeapAlloc(hBlackMoonHeap, HEAP_ZERO_MEMORY, Param2);//malloc(Param2);//
	
		if(!pData)
		{
			char ErrorString[255];
			char** pRetnAddr = (char**)(&Param2 - 2); // ȡصַ
			wsprintf(ErrorString, "%dֽڴʧ.\r\n"
				"ջϢ:\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n"
				"0x%08X\r\n0x%08X\r\n", 
				Param1,
				pRetnAddr[0], pRetnAddr[1],
				pRetnAddr[2], pRetnAddr[3],
				pRetnAddr[4], pRetnAddr[5],
				pRetnAddr[6], pRetnAddr[7],
				pRetnAddr[8], pRetnAddr[9],
				pRetnAddr[10], pRetnAddr[11],
				pRetnAddr[12], pRetnAddr[13],
				pRetnAddr[14], pRetnAddr[15]);
			MessageBox(0, "ڴ治", "error", MB_ICONERROR);
			E_End (0);
		}

		return pData;

	}
	

	void  _cdecl E_MFree (void * Param1){




		if((DWORD)Param1 > 0xFFFF)
		{
			if(dwBlackMoonPESizeOfImage==0)
				GetBlackMoonPESizeOfImage();


			if(dwBlackMoonPEAddrrStart <= (DWORD)Param1 && (DWORD)Param1 <= dwBlackMoonPEAddrrEnd)
			{
				//MessageBox(NULL,"ErrorString","ָ",MB_OK);
				return;
				
			}
		
			//жǷЧĶڴ
			if (HeapValidate(hBlackMoonHeap, HEAP_NO_SERIALIZE, Param1) == 0)
			{
				return;
			}


			HeapFree(hBlackMoonHeap, 0 , Param1);  //free(Param1);//


			

		}


	}

	void  _cdecl E_Destroy (PDESTROY Param1){
		//int nIdx;
		//__asm mov nIdx,eax;	
		//if(nIdx==3)	//2
			DestroyAddress = Param1; 

	}

	void  _cdecl E_HelpFunc12 (DWORD Param1){
		int nIdx;
		__asm mov nIdx,eax;	
	//	if(nIdx==3)	//12ź,2

	}
	
	void*  _cdecl E_CloneConstArray (DWORD Param1,void** Param2){
		void *result;
		result = (void *)1;
		if(dwBlackMoonPESizeOfImage==0)
			GetBlackMoonPESizeOfImage();
		void* pAryData = *Param2;
		
		
		if(dwBlackMoonPEAddrrStart <= (DWORD)pAryData && (DWORD)pAryData <= dwBlackMoonPEAddrrEnd)
		{
			LPINT pnData;
			INT nArys,nDim;
			UINT nElementCount;
			
			pnData = (LPINT)pAryData;
			
			nArys=*pnData; //ȡά
			nDim = nArys;
			pnData +=1;
			
			// ԱĿ
			nElementCount = 1;
			while (nArys > 0)
			{
				nElementCount *= pnData[0];
				pnData ++;
				nArys--;
			}
			
			DWORD dwSize = Param1 * nElementCount + (nDim+1)*sizeof(INT);
			result = E_MAlloc_Nzero(dwSize);
			memcpy(result,pAryData,dwSize);
			*Param2 = result;

			
		}

		return result;
	}

	void*  _cdecl E_NULLARRAY ()
	{
		LPBYTE p = (LPBYTE)E_MAlloc_Nzero (sizeof (INT) * 2);
		*(LPINT)p = 1;  // ά
		*(LPINT)(p + sizeof (INT)) = 0;
		return p;
	}

	void BlackMoonCalleLibFunctionHelper(INT nArgCount,MDATA_INF ArgInf,...)
	{
		PFN_EXECUTE_CMD pfn;
		__asm mov pfn, eax;
		MDATA_INF RetData={0};
		pfn(&RetData,nArgCount,&ArgInf);
		__asm{
			mov eax, RetData.m_unit.m_dwFormID;
			mov edx, RetData.m_unit.m_dwUnitID;
			mov ecx, RetData.m_dtDataType
		}		
	}
//	void main(){};
}
extern "C" INT BlackMoonCalleLibList;
extern "C" DWORD BlackMoonFuncForeLib;

void BlackMoonInitAllElib(){
	LPINT pfnNotifySys = &BlackMoonCalleLibList;
	while(*pfnNotifySys){
		PFN_NOTIFY_SYS g_fnNotifySys = (PFN_NOTIFY_SYS)*pfnNotifySys;
		g_fnNotifySys(NL_SYS_NOTIFY_FUNCTION,BlackMoonFuncForeLib,0);
		pfnNotifySys++;
	}
}

void BlackMoonFreeAllElib(){
	LPINT pfnNotifySys = &BlackMoonCalleLibList;
	while(*pfnNotifySys){
		PFN_NOTIFY_SYS g_fnNotifySys = (PFN_NOTIFY_SYS)*pfnNotifySys;
		g_fnNotifySys(NL_FREE_LIB_DATA,0,0);
		pfnNotifySys++;
	}
	if(BlackMoonFreeAllUserDll)
		BlackMoonFreeAllUserDll();
}


// - ôʾ
/*
    øʽ ޷ֵ ôʾ ӳָ дʾӳݣ - ϵͳֿ֧->
    ӢƣSetErrorManger
    õʱ˵³شʱԸôϸʾӳַδдãشʱʱԶʾôϸϢֱ˳Ϊ߼
    <1>Ϊдʾӳ򡱣Ϊӳָ루SubPtrԱʡԡעӳһΪͣմ룬
	ڶΪıͣϸıͬʱӳ뷵һ߼ֵʾѾдϣϵͳʾôϢؼٱʾϵͳʾôϢ
	ñȫȷԤ⣬⣬ע¼㣺 
	1ôʾӳҪµĴ 
	2ڽôʾӳϵͳԶر¼Ϣ֪ͨƣҲ˵κ¼޷õӦ 
	3Σӳ˳ϵͳԶӦóرա  ʡԱϵͳָʾĬϴʽ
*/
LIBAPI(void, krnln_SetErrorManger)
{
	if (ArgInf.m_dtDataType == SDT_SUB_PTR && ArgInf.m_pdwSubCodeAdr)
		fnEError_callback = (EError_CALLBACK)ArgInf.m_pdwSubCodeAdr;
	else
		fnEError_callback = NULL;
}

/*
	øʽ ı͡ DLLװĿ¼ ı DLLװĿ¼ݣ - ϵͳֿ֧->
	ӢƣSetDllCmdLoadPath
	õִеDLLʱװDLLļװ·ϵͳȵ·ȥװָDLLļýDLLеδָȫ·DLLļװؾӰ죬ڳڼȫЧִк󷵻ϵͳڱǰֵΪ߼
	<1>ΪDLLװĿ¼ΪıͣtextԱʡԡָϵͳDLLDLLļװ·ʡԣĬֵΪı

	ϵͳ Windows
*/

#if _MSC_VER < 1916 //VS2017 VS2019
typedef BOOL (WINAPI *MySetDllDirectoryA)(LPCSTR lpPathName);
typedef DWORD (WINAPI *MyGetDllDirectoryA)(DWORD nBufferLength, LPSTR lpBuffer);
#endif

LIBAPI(char*, _krnln_SetDllCmdLoadPath)
{
	char szPath[MAX_PATH];
#if _MSC_VER >= 1916 //VS2017 VS2019
	DWORD dwLen = GetDllDirectoryA(MAX_PATH, szPath);
	if (ArgInf.m_pText) {
		SetDllDirectoryA(ArgInf.m_pText);
	}
#else
	HMODULE hKernel32 = GetModuleHandle("Kernel32.dll");
	if (!hKernel32)
		return NULL;

	MyGetDllDirectoryA MyGetDllDirectory = (MyGetDllDirectoryA)GetProcAddress(hKernel32, "GetDllDirectoryA");
	MySetDllDirectoryA MySetDllDirectory = (MySetDllDirectoryA)GetProcAddress(hKernel32, "SetDllDirectoryA");

	if(!MyGetDllDirectory || !MySetDllDirectory)
		return NULL;

	DWORD dwLen = MyGetDllDirectory(MAX_PATH, szPath);
	if (ArgInf.m_pText) {
		MySetDllDirectory(ArgInf.m_pText);
	}
#endif
	char* pText = NULL;
	if (dwLen > 0 && dwLen < MAX_PATH) {
		pText = (char*)E_MAlloc_Nzero(dwLen);
		memcpy(pText, szPath, dwLen);
		pText[dwLen] = '\0';
	}
	return pText;
}

================================================
FILE: krnln/krnln_BJCase.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"


//ı - 
/*
    øʽ ı͡  ı 任ı - ϵͳֿ֧->ı
    ӢƣBJCase
    ıеȫĸոֱ任Ϊǣر任ĽıΪ
    <1>Ϊ任ıΪıͣtext

' ַΧ163ͷ176--185
' дĸ163ͷ193--218
' Сдĸ163ͷ225--250
' ///////////Ϊȫǵģǰǵ
' ַΧ48--57
' дĸ65--90
' Сдĸ97-122
ֽڼ ()  ' 163,174,163,173
*/
LIBAPI(char*, krnln_BJCase)
{
	PMDATA_INF pArgInf = &ArgInf;
	size_t nLen = mystrlen(ArgInf.m_pText);
	if (nLen == 0) return NULL;

	char* pszLast = ArgInf.m_pText + nLen;
	char* pszFirst = ArgInf.m_pText;
	char* pszSrc = (char*)malloc(nLen + 1);
	char* pszTmp = pszSrc;
	size_t sSublen;
	for (;;)
	{
		char* pPos = strstr(pszFirst, "");
		if (!pPos) break;
		sSublen = pPos - pszFirst;
		if (sSublen > 0)
		{
			memcpy(pszTmp, pszFirst, sSublen);
		}
		pszTmp[sSublen] = '\\';
		pszTmp += sSublen + 1;
		pszFirst = pPos	+ 2;
	}
	sSublen = pszLast - pszFirst;
	if (sSublen > 0)
	{
		memcpy(pszTmp, pszFirst, sSublen);
		pszTmp += sSublen;
	}
	pszTmp[0] = '\0';

	nLen = mystrlen(pszSrc);
	INT nBufLen = nLen + 1;
	char *pBJText = (char*)E_MAlloc(nBufLen);
	LCMapString (2052, LCMAP_HALFWIDTH, pszSrc, nLen, pBJText, nBufLen);
	free(pszSrc);
	return pBJText;
}


================================================
FILE: krnln/krnln_BinLeft.cpp
================================================
#include "stdafx.h"

//ֽڼ - ȡֽڼ
/*
    øʽ ֽڼ ȡֽڼ ֽڼ ȡ䲿ֵֽڼ ȡֽڵĿ - ϵͳֿ֧->ֽڼ
    ӢƣBinLeft
    һֽڼаָֽڼдָֽڡΪ
    <1>Ϊȡ䲿ֵֽڼΪֽڼbin
    <2>ΪȡֽڵĿΪͣint
*/
LIBAPI(void*, krnln_BinLeft)
{
	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[0].m_pBin == NULL)
		return NULL;
	INT nDataSize = pArgInf[0].m_pInt[1];
	if(nDataSize == 0 || pArgInf[1].m_int <= 0 )
		return NULL;
	if(nDataSize > pArgInf[1].m_int)
		nDataSize = pArgInf[1].m_int;

	return CloneBinData ((LPBYTE)(pArgInf[0].m_pInt + 2),nDataSize);
}


================================================
FILE: krnln/krnln_BinLen.cpp
================================================
#include "stdafx.h"

//ֽڼ - ȡֽڼ
/*
    øʽ ͡ ȡֽڼ ֽڼ ֽڼݣ - ϵͳֿ֧->ֽڼ
    ӢƣBinLen
    ȡֽڼݵijȡΪ
    <1>ΪֽڼݡΪֽڼbinֵָ䳤ȵֽڼݡ
*/
LIBAPI(int, krnln_BinLen)
{
	if(ArgInf.m_pBin == NULL) return 0;
	return ArgInf.m_pInt[1];
}


================================================
FILE: krnln/krnln_BinMid.cpp
================================================
#include "stdafx.h"

//ֽڼ - ȡֽڼм
/*
    øʽ ֽڼ ȡֽڼм ֽڼ ȡ䲿ֵֽڼ ʼȡλã ȡֽڵĿ - ϵͳֿ֧->ֽڼ
    ӢƣBinMid
    һֽڼаָֽڼдָλָֽڡΪ
    <1>Ϊȡ䲿ֵֽڼΪֽڼbin
    <2>ΪʼȡλáΪͣint1Ϊλã2Ϊ2λãơ
    <3>ΪȡֽڵĿΪͣint
*/
LIBAPI(void*, krnln_BinMid)
{
	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[0].m_pBin == NULL)
		return NULL;
	INT nDataSize = pArgInf[0].m_pInt[1];
	INT nObjLen = pArgInf[2].m_int;
	if(nDataSize == 0 ||  nObjLen<= 0 )
		return NULL;
	INT nStart = pArgInf[1].m_int;
	if(nStart-1 > nDataSize)
		return NULL;
	if(nStart<=0)
		nStart = 1;
	if(nStart-1 + nObjLen >= nDataSize)
		nObjLen = nDataSize - nStart+1;
	nDataSize = nObjLen;


	return CloneBinData ((LPBYTE)(pArgInf[0].m_pBin + 2*sizeof(INT)+ nStart-1),nDataSize);
}


================================================
FILE: krnln/krnln_BinRight.cpp
================================================
#include "stdafx.h"

//ֽڼ - ȡֽڼұ
/*
    øʽ ֽڼ ȡֽڼұ ֽڼ ȡ䲿ֵֽڼ ȡֽڵĿ - ϵͳֿ֧->ֽڼ
    ӢƣBinRight
    һֽڼаָֽڼдұָֽڡΪ
    <1>Ϊȡ䲿ֵֽڼΪֽڼbin
    <2>ΪȡֽڵĿΪͣint
*/
LIBAPI(void*, krnln_BinRight)
{
	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[0].m_pBin == NULL)
		return NULL;
	INT nDataSize = pArgInf[0].m_pInt[1];
	if(nDataSize == 0 || pArgInf[1].m_int <= 0 )
		return NULL;
	INT nOffset = nDataSize - pArgInf[1].m_int;
	if(nOffset < 0)
		nOffset = 0;
	nDataSize = pArgInf[1].m_int;
	if (nDataSize > pArgInf[0].m_pInt[1]) {
		nDataSize = pArgInf[0].m_pInt[1];
	}
	return CloneBinData ((LPBYTE)(pArgInf[0].m_pBin + 2*sizeof(INT) + nOffset), nDataSize);
}


================================================
FILE: krnln/krnln_ChDir.cpp
================================================
#include "stdafx.h"

//̲ - ıĿ¼
/*
    øʽ ߼͡ ıĿ¼ ı ı䵽Ŀ¼ - ϵͳֿ֧->̲
    ӢƣChDir
    ı䵱ǰĿ¼ıȱʡλáɹ棬ʧܷؼ١Ϊ
    <1>Ϊı䵽Ŀ¼ΪıͣtextֵָĸĿ¼ΪµȱʡĿ¼ܻûָڵǰϸıȱʡĿ¼
*/
LIBAPI(BOOL, krnln_ChDir)
{
	return SetCurrentDirectory(ArgInf.m_pText);
}


================================================
FILE: krnln/krnln_ChDrive.cpp
================================================
#include "stdafx.h"

//̲ - ı
/*
    øʽ ߼͡ ı ı ı䵽 - ϵͳֿ֧->̲
    ӢƣChDrive
    ı䵱ǰȱʡɹ棬ʧܷؼ١Ϊ
    <1>Ϊı䵽ΪıͣtextֵָһڵơABCȣֻȡøıĵһַʹ㳤ȵıǰı䡣
*/
LIBAPI(BOOL, krnln_ChDrive)
{
	char DirName [MAX_PATH];

	if(!*(ArgInf.m_pText))
		return FALSE;

	DirName[0]=*ArgInf.m_pText;
	DirName[1]=':';
	DirName[2]='\\';
	DirName[3]=0;

	return SetCurrentDirectory(DirName);
}


================================================
FILE: krnln/krnln_ClearClipBoard.cpp
================================================
#include "stdafx.h"

//ϵͳ - 
/*
    øʽ ޷ֵ   - ϵͳֿ֧->ϵͳ
    ӢƣClearClipBoard
    ǰ Windows ϵͳеݡΪ
*/
LIBAPI(void, krnln_ClearClipBoard)
{
	if(OpenClipboard(NULL))
	{
		EmptyClipboard();
		CloseClipboard();
	}
}


================================================
FILE: krnln/krnln_CryptOpen.cpp
================================================
#include "stdafx.h"
#include "md5t.h"
#include "Myfunctions.h"

// øʽ ͡ 򿪼ļ ı 򿪵ļƣ 򿪷ʽݣ ʽݣı ļݣ ȣݣ - ϵͳֿ֧->ļд
// ӢƣCryptOpen
// һָܵļԶԴļпٰȫʣִ֧ߴļɹرļļţʧܷ 0Ϊ
// <1>Ϊ򿪵ļơΪıͣtext
// <2>Ϊ򿪷ʽΪͣintԱʡԡֵ˵ļIJʽʡԱĬΪ#дʽֵΪ³֮һ
// 1#룺ָļݣļʧܣ
// 2#ддݵָļļʧܣ
// 3#дļжݻдݵļļʧܣ
// 4#ддݵָļļȴһļѾھеݣ
// 5#ддݵָļļ򴴽һļѾھֱӴ򿪣
// 6#Ķļжݻдݵļļ򴴽һļѾھֱӴ򿪡
// <3>ΪʽΪͣintԱʡԡֵָ̲ļķʽʡԱĬΪ#ơʽֵΪ³֮һ
// 1#ƣдļ
// 2#̶ֹֹļ
// 3#ֹдֹдļ
// 4#ֹд̶ֹдļ
// <4>Ϊļ롱ΪıͣtextԱʡԡ򿪵ļвκݣΪļ򽫴ļָļʱʹõ룬Ժдļеݶʹôܺд롣볤Ϊ6ַϣûʹú֡ĸ֡ţԱ֤뱾İȫԡ򿪵ļѾݣṩʴʱҪȷ룬ûмܣṩıԱʾҪ롣עϵͳȥУȷԣṩ룬дļݽõĽǧע⡣ҪУǷȷڼܺļбȷııժҪϢݲֿ֧һеġȡժҪȻڴ򿪼ļϢ֤ϵͳʹõļ㷨ǹʱ׼RC4㷨Ա֤ݵİȫԡʡԣĬΪı롣
// <5>ΪȡΪͣintԱʡԡָļײʼϣֵܲijȣϵͳڶдڵʱʹмӽܲ˲ļΪ֣ԷijЩӦóͬʱһЩݡע⵱мݵļʱ˲ֵ½˼ļʱṩIJֵһ£ݷʴʡԣĬֵΪ0û
// 
// ϵͳ Windows
LIBAPI(void*, krnln_CryptOpen) // δ 
{
	PMDATA_INF pArgInf = &ArgInf;
	DWORD dwDesiredAccess,dwShareMode,dwCreationDisposition;
	
	if(pArgInf[1].m_dtDataType == _SDT_NULL)
	{//#д
		dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
		dwCreationDisposition = OPEN_EXISTING;
	}
	else
	{
		switch (pArgInf[1].m_int)
		{
		case 1://#
			dwDesiredAccess = GENERIC_READ;
			dwCreationDisposition = OPEN_EXISTING;
			break;
		case 2://#д
			dwDesiredAccess = GENERIC_WRITE;
			dwCreationDisposition = OPEN_EXISTING;
			break;
		case 4://#д
			dwDesiredAccess = GENERIC_WRITE;
			dwCreationDisposition = CREATE_ALWAYS;
			break;
		case 5://#д
			dwDesiredAccess = GENERIC_WRITE;
			dwCreationDisposition = OPEN_ALWAYS;
			break;
		case 6://#Ķ
			dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
			dwCreationDisposition = OPEN_ALWAYS;
			break;
		default://#д
			dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
			dwCreationDisposition = OPEN_EXISTING;
			break;
		}
	}
	
	if(pArgInf[2].m_dtDataType == _SDT_NULL)
		dwShareMode = (FILE_SHARE_READ | FILE_SHARE_WRITE );
	else
	{
		if(pArgInf[2].m_int ==2)
			dwShareMode = FILE_SHARE_WRITE ;
		else if(pArgInf[2].m_int ==3)
			dwShareMode = FILE_SHARE_READ ;
		else if(pArgInf[2].m_int ==4)
			dwShareMode = 0;
		else
			dwShareMode = (FILE_SHARE_READ | FILE_SHARE_WRITE );
	}
	
	HANDLE hFile = CreateFile(ArgInf.m_pText,
		dwDesiredAccess,
		dwShareMode,
		NULL,
		dwCreationDisposition,
		FILE_ATTRIBUTE_ARCHIVE,
		0);
	
	
	if(hFile != INVALID_HANDLE_VALUE)
	{
		PFILEELEMENT pFile = new FILEELEMENT;
		if (pArgInf[3].m_dtDataType == _SDT_NULL || !pArgInf[3].m_pText || !*(pArgInf[3].m_pText))
			pFile->nType = 1; // ͨļ
		else
		{
			int nKeylen = mystrlen(pArgInf[3].m_pText);
			pFile->nType = 3; // ļ

			GetBufMD5(pFile->strMD5, (unsigned char*)pArgInf[3].m_pText, nKeylen);
			swap_hex(pFile->strMD5, 32); //תMD5

			memset(pFile->strTable,0,258);
			E_RC4_init(pFile->strTable, (unsigned char*)pArgInf[3].m_pText, nKeylen);

			//
			if(pArgInf[4].m_dtDataType == _SDT_NULL)
				pFile->nCryptStart = 0;
			else
				pFile->nCryptStart = pArgInf[4].m_int;
		}

		pFile->FileHandle = hFile;
		AddFileMangerList(pFile);
		return pFile;
	}
	return NULL;
}



================================================
FILE: krnln/krnln_CurDir.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
//̲ - ȡǰĿ¼
/*
    øʽ ı͡ ȡǰĿ¼  - ϵͳֿ֧->̲
    ӢƣCurDir
    һıǰĿ¼ʧܣؿıΪ
*/
LIBAPI(char*, krnln_CurDir)
{
	char DirName [MAX_PATH];
	char* pText = NULL;

	if(GetCurrentDirectory(MAX_PATH,DirName))
	{
		INT nLen = mystrlen(DirName);
		pText = CloneTextData(DirName,nLen);
	}
	return pText;
}


================================================
FILE: krnln/krnln_DeleteRegItem.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
#pragma comment(lib,"advapi32.lib") 
//ϵͳ - ɾע
/*
    øʽ ߼͡ ɾע  Ŀ¼ı ȫ·ע - ϵͳֿ֧->ϵͳ
    ӢƣDeleteRegItem
     Windows עɾָעעĿ¼ɾעĬֵĿӡ\ţ硰test\ɹ棬򷵻ؼ١עɾĿ¼֮ǰɾĿ¼еĿΪм
    <1>ΪĿ¼ΪͣintΪ³ֵ֮һ 1#ࣻ 2#ã 3#û 4#ػ 5#û
    <2>Ϊȫ·עΪıͣtext
*/
LIBAPI(BOOL, krnln_DeleteRegItem)
{
	PMDATA_INF pArgInf = &ArgInf;
	HKEY hRootkey = GetRegRootVal(pArgInf[0].m_int);
	BOOL bRet = FALSE;
	INT nLen = mystrlen(pArgInf[1].m_pText);
	if(hRootkey && nLen)
	{
		HKEY hkey;
		LPSTR pSubkey = new char [nLen +1];
		strcpy(pSubkey,pArgInf[1].m_pText);
		LPSTR pKeyname = strrchr(pSubkey,'\\');
		if(pKeyname)
		{
			*pKeyname = 0;
			pKeyname++;
		}
		if(RegOpenKeyEx(hRootkey,pSubkey,0,KEY_ALL_ACCESS,&hkey)==ERROR_SUCCESS)
		{
			bRet = (RegDeleteValue(hkey,pKeyname)==ERROR_SUCCESS);
			RegCloseKey(hkey);
		}
		if(bRet == FALSE)
		{
			bRet = (RegDeleteKey(hRootkey,pArgInf[1].m_pText)==ERROR_SUCCESS);
		}

		delete [] pSubkey;
	}

	return bRet;
}


================================================
FILE: krnln/krnln_Dispatch.cpp
================================================
#include "stdafx.h"
#include "OLECTL.H"
#include "Myfunctions.h"
#include <stdio.h>
#pragma comment(lib,"ole32.lib")
#pragma comment(lib,"oleaut32.lib")

#define		DTC_COM_OBJECT  		48
#define     DTC_VARIANT             49
#define		DTP_COM_OBJECT      MAKELONG (DTC_COM_OBJECT, 1)
#define     DTP_VARIANT         MAKELONG (DTC_VARIANT, 1)



LPOLESTR ASCII2Unicode(LPSTR pAsciiText)
{
	if(pAsciiText==NULL)
		return NULL;
	DWORD dwMinSize;
    dwMinSize = MultiByteToWideChar (CP_ACP, 0, pAsciiText, -1, NULL, 0);
	
    if(dwMinSize==0)
		return NULL;
    LPOLESTR lpwszStr = (LPOLESTR)new USHORT [dwMinSize];
    // Convert headers from ASCII to Unicode.
    MultiByteToWideChar (CP_ACP, 0, pAsciiText, -1, lpwszStr, dwMinSize);  
	return lpwszStr;
}
LPSTR Unicode2EASCII(LPOLESTR pBStrText)
{
	if(pBStrText==NULL)
		return NULL;
	//Ҫתַ 
	DWORD dwLen=WideCharToMultiByte (CP_ACP, 0, pBStrText, -1, NULL,0, NULL, NULL) ; 
	//תַ
	if(dwLen==0)
		return NULL;
	LPSTR pText =(char*)E_MAlloc (dwLen);
	WideCharToMultiByte (CP_ACP, 0, pBStrText, -1, pText,dwLen, NULL, NULL);
	return pText;
}

HRESULT Dispatch_GetIDsOfNames(LPDISPATCH lpDispatch,LPSTR pszName,DISPID* rgDispid)
{
	LPOLESTR lpzCom = ASCII2Unicode(pszName);
	HRESULT hRet = 0;
	/*
	UINT nMax = 0;
	hRet = lpDispatch->GetTypeInfoCount(&nMax);
	if(hRet ==S_OK){

			
		ITypeInfo* pp = NULL;
		for(UINT i=0;i<nMax;i++){
			hRet = lpDispatch->GetTypeInfo(i,0,&pp);
			if(hRet ==S_OK){
				hRet = pp->GetIDsOfNames(&lpzCom,1,rgDispid);

				pp->Release();
				if(hRet ==S_OK){
					
					
					if(lpzCom)
						delete [] lpzCom;
					return hRet;
				}
			char ErrorString [1024];
  			wsprintf(ErrorString, "%x %d", hRet,*rgDispid);
				MessageBox(NULL,ErrorString,NULL,MB_OK);
				pp = NULL;

			}

		}
	}
*/
	

	//hRet = lpDispatch->GetIDsOfNames(IID_NULL,&lpzCom,1, LOCALE_USER_DEFAULT,rgDispid); //ԭ
	hRet = lpDispatch->GetIDsOfNames(IID_NULL,&lpzCom,1, GetUserDefaultLCID(),rgDispid);
	if(lpzCom)
		delete [] lpzCom;
	return hRet;

}

HRESULT Dispatch_InvokeHelper(LPDISPATCH lpDispatch,DISPID dwDispID, WORD wFlags,
	VARIANT* pvarResult, INT nArgCount, PMDATA_INF pArgInf)
{
	DISPPARAMS dispparams;
	memset(&dispparams, 0, sizeof dispparams);

	//Ƿдַ
	BOOL* pbIsRef = NULL;
	if (nArgCount > 0)
	{
		pbIsRef = new BOOL[nArgCount];
		memset(pbIsRef, 0, sizeof(BOOL) * nArgCount);
	}
	
	ITypeInfo* pTypeInfo;
	lpDispatch->GetTypeInfo(0,0,&pTypeInfo);
	
	TYPEATTR* pAttr; 
	INT bIsMethod = FALSE;
	pTypeInfo->GetTypeAttr(&pAttr);
	if(wFlags == DISPATCH_METHOD)
	{
		FUNCDESC* pFuncDesc = NULL; 
		
		for (INT i=0;i <pAttr->cFuncs;i++) 
		{
			HRESULT hr = pTypeInfo->GetFuncDesc(i, &pFuncDesc); 
			if(hr == S_OK && pFuncDesc->memid == dwDispID)
			{
				INT nMax = min(nArgCount,pFuncDesc->cParams);
				for(INT j=0;j<nMax;j++)
				{
					if(pFuncDesc->lprgelemdescParam[j].tdesc.vt==VT_PTR || 
						(pFuncDesc->lprgelemdescParam[j].tdesc.vt & VT_BYREF)==VT_BYREF)
						pbIsRef[j] = TRUE;
				}

				if (pFuncDesc->invkind == INVOKE_PROPERTYPUT && nArgCount == 0) // д Ϊ0
					wFlags = INVOKE_PROPERTYGET;
				else
					wFlags = pFuncDesc->invkind;

				bIsMethod = TRUE;
				pTypeInfo->ReleaseFuncDesc(pFuncDesc); 
				break; 
			}
			pTypeInfo->ReleaseFuncDesc(pFuncDesc); 
			pFuncDesc = NULL; 
		}
	}
	if (!bIsMethod)
	{
		VARDESC* pVarDesc = NULL; 
		
		for (INT i=0;i <pAttr->cVars;i++) 
		{
			HRESULT hr = pTypeInfo->GetVarDesc(i, &pVarDesc); 
			if(hr == S_OK && pVarDesc->memid == dwDispID)
			{
				if(pVarDesc->elemdescVar.tdesc.vt==VT_PTR || 
					(pVarDesc->elemdescVar.tdesc.vt & VT_BYREF)==VT_BYREF)
					pbIsRef[0] = TRUE;
				
				if (wFlags == DISPATCH_METHOD)
					wFlags = INVOKE_PROPERTYGET;

				pTypeInfo->ReleaseVarDesc(pVarDesc); 
				break; 
			}
			pTypeInfo->ReleaseVarDesc(pVarDesc); 
			pVarDesc = NULL; 
		}
	}
	pTypeInfo->ReleaseTypeAttr(pAttr); 
	pTypeInfo->Release ();

	// determine number of arguments
	dispparams.cArgs = nArgCount;
	DISPID dispidNamed = DISPID_PROPERTYPUT;
	if (wFlags & (DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF))
	{
		//ASSERT(dispparams.cArgs > 0);
		dispparams.cNamedArgs = 1;
		dispparams.rgdispidNamedArgs = &dispidNamed;
	}
	if (dispparams.cArgs != 0)
	{
		// allocate memory for all VARIANT parameters
		VARIANT* pArg = new VARIANT[dispparams.cArgs];
		ASSERT(pArg != NULL);   // should have thrown exception
		dispparams.rgvarg = pArg;
		memset(pArg, 0, sizeof(VARIANT) * dispparams.cArgs);

		// get ready to walk vararg list
		pArg += dispparams.cArgs - 1;   // params go in opposite order

		for(INT i=0;i<nArgCount;i++)
		{	
			if((pArgInf[i].m_dtDataType & DT_IS_ARY) == 0)//
			{	
				
				switch(pArgInf[i].m_dtDataType)
				{
				case SDT_BYTE:
					pArg->vt = VT_UI1;
					pArg->intVal = pArgInf[i].m_int;
					break;
				case SDT_SHORT:
					pArg->vt = VT_I2;
					pArg->intVal = pArgInf[i].m_int;
					break;
				case SDT_INT:
					pArg->vt = VT_I4;
					pArg->intVal = pArgInf[i].m_int;
					break;
				case SDT_SUB_PTR:
					pArg->vt = VT_UI4;
					pArg->intVal = pArgInf[i].m_int;
					break;
				case SDT_INT64:
					pArg->vt = VT_I8;
					pArg->date = pArgInf[i].m_date;
					break;
				case SDT_FLOAT:
					pArg->vt = VT_R4;
					pArg->fltVal= pArgInf[i].m_float;
					break;
				case SDT_DOUBLE:
					pArg->vt = VT_R8;
					pArg->date = pArgInf[i].m_date;
					break;
				case SDT_BOOL:
					pArg->vt = VT_BOOL;
					pArg->boolVal = pArgInf[i].m_bool?-1:0;
					break;
				case SDT_DATE_TIME:
					pArg->vt = VT_DATE;
					pArg->date = pArgInf[i].m_date;
					break;
				case SDT_TEXT:
					{
						pArg->vt = VT_BSTR;
						LPOLESTR lpsz = ASCII2Unicode(pArgInf[i].m_pText);
						pArg->bstrVal = ::SysAllocString(lpsz);
						delete [] lpsz;
					}
					break;
				case SDT_BIN:
					{
						pArg->vt = VT_ARRAY | VT_UI1;
						INT nLength=*(LPINT)(pArgInf[i].m_pBin + sizeof (INT));
						BYTE* pbuf=pArgInf[i].m_pBin + sizeof (INT) * 2;

						SAFEARRAY* psa;
						SAFEARRAYBOUND rgsabound[1];
						rgsabound[0].lLbound = 0;
						rgsabound[0].cElements = nLength;
						psa = SafeArrayCreate(VT_UI1, 1, rgsabound);
						psa->pvData=pbuf;
						pArg->parray = psa;
					}
					break;
				case DTP_VARIANT:
					if(pbIsRef[i])
					{
						pArg->vt = VT_VARIANT | VT_BYREF;
						pArg->pvarVal = (VARIANT*)pArgInf[i].m_pCompoundData;
					}else{
						//memcpy(pArg,(VARIANT*)pArgInf[i].m_pCompoundData,sizeof(VARIANT));
						VariantCopy(pArg,(VARIANT*)pArgInf[i].m_pCompoundData);
					}
					break;
				case DTP_COM_OBJECT:
					
					if(pbIsRef[i])
					{
						if(wFlags==DISPATCH_PROPERTYPUT)//ΪַʱתΪдַ־
							 wFlags = DISPATCH_PROPERTYPUTREF;
						pArg->vt = VT_DISPATCH | VT_BYREF;
						PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[i].m_ppCompoundData;
						pArg->ppdispVal = (LPDISPATCH*)pDest;
					}else{			
						pArg->vt = VT_DISPATCH;
						PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[i].m_ppCompoundData;
						pArg->pdispVal = pDest->pDisp;
					}
					break;
				}
			}
			else
			{
				
				DWORD dtDataType = ~DT_IS_ARY & pArgInf[i].m_dtDataType;
				switch(dtDataType)
				{
				case SDT_BYTE:
					if(pbIsRef[i])
					{
						pArg->vt = VT_UI1|VT_BYREF;
						pArg->intVal = pArgInf[i].m_int;
					}
					else
					{
						pArg->vt = VT_UI1;
						pArg->bVal = *pArgInf[i].m_pByte;
					}
					break;
				case SDT_SHORT:
					if(pbIsRef[i])
					{
						pArg->vt = VT_I2|VT_BYREF;
						pArg->intVal = pArgInf[i].m_int;
					}
					else
					{
						pArg->vt = VT_I2;
						pArg->iVal = *pArgInf[i].m_pShort;
					}
					break;
				case SDT_INT:
					if(pbIsRef[i])
					{
						pArg->vt = VT_I4|VT_BYREF;
						pArg->intVal = pArgInf[i].m_int;
					}
					else
					{
						pArg->vt = VT_I4;
						pArg->intVal = *pArgInf[i].m_pInt;
					}
					break;
				case SDT_SUB_PTR:
					if(pbIsRef[i])
					{
						pArg->vt = VT_UI4|VT_BYREF;
						pArg->intVal = pArgInf[i].m_int;
					}
					else
					{
						pArg->vt = VT_UI4;
						pArg->uintVal = *pArgInf[i].m_pdwSubCodeAdr;
					}
	
					break;
				case SDT_INT64:
					if(pbIsRef[i])
					{
						pArg->vt = VT_I8|VT_BYREF;
						pArg->intVal = pArgInf[i].m_int;
					}
					else
					{
						pArg->vt = VT_I8;
						pArg->date = *pArgInf[i].m_pDate;
					}

					break;
				case SDT_FLOAT:
					if(pbIsRef[i])
					{
						pArg->vt = VT_R4|VT_BYREF;
						pArg->intVal = pArgInf[i].m_int;
					}
					else
					{
						pArg->vt = VT_R4;
						pArg->fltVal = *pArgInf[i].m_pFloat;
					}
					
					break;
				case SDT_DOUBLE:
					if(pbIsRef[i])
					{
						pArg->vt = VT_R8|VT_BYREF;
						pArg->intVal = pArgInf[i].m_int;
					}
					else
					{
						pArg->vt = VT_R8;
						pArg->date = *pArgInf[i].m_pDate;
					}
					break;
				case SDT_BOOL:
					if(pbIsRef[i])
					{
						pArg->vt = VT_BOOL|VT_BYREF;
						if(*pArgInf[i].m_pBool)
							*pArgInf[i].m_pBool = -1;
						pArg->intVal = pArgInf[i].m_int;
					}
					else
					{
						pArg->vt = VT_BOOL;
						pArg->boolVal = *pArgInf[i].m_pBool?-1:0;
					}

					break;
				case SDT_DATE_TIME:
					if(pbIsRef[i])
					{
						pArg->vt = VT_DATE|VT_BYREF;
						pArg->intVal = pArgInf[i].m_int;
					}
					else
					{
						pArg->vt = VT_DATE;
						pArg->date = *pArgInf[i].m_pDate;
					}
					break;
				case SDT_TEXT:
					{
						if(pbIsRef[i])
						{
							pArg->vt = VT_BSTR|VT_BYREF;
							if(*pArgInf[i].m_ppText)
							{
								LPOLESTR lpsz = ASCII2Unicode(*pArgInf[i].m_ppText);
								LPOLESTR* pp = &pArg->bstrVal;
								pp++;
								*pp = ::SysAllocString(lpsz);
								pArg->pbstrVal = pp;
								delete [] lpsz;
							}
						}
						else
						{
							pArg->vt = VT_BSTR;
							if(*pArgInf[i].m_ppText)
							{
								LPOLESTR lpsz = ASCII2Unicode(*pArgInf[i].m_ppText);
								pArg->bstrVal = ::SysAllocString(lpsz);
								delete [] lpsz;
							}

						}
					}
					break;
				case SDT_BIN:
					{
						pArg->vt = VT_ARRAY | VT_UI1;
						//pArg->vt = VT_ARRAY | VT_UI1| VT_BYREF;
						LPBYTE pBin = *pArgInf[i].m_ppBin;
						if(pBin)
						{
							INT nLength=*(LPINT)(pBin + sizeof (INT));
							BYTE* pbuf = pBin + sizeof (INT) * 2;
							
							SAFEARRAY* psa;
							SAFEARRAYBOUND rgsabound[1];
							rgsabound[0].lLbound = 0;
							rgsabound[0].cElements = nLength;
							psa = SafeArrayCreate(VT_UI1, 1, rgsabound);
							psa->pvData=pbuf;
							pArg->parray = psa;
							/*
							INT nLength=*(LPINT)(pBin + sizeof (INT));
							BYTE* pbuf=pBin + sizeof (INT) * 2;
							
							SAFEARRAY* psa;
							SAFEARRAYBOUND rgsabound[1];
							rgsabound[0].lLbound = 0;
							rgsabound[0].cElements = nLength;
							psa = SafeArrayCreate(VT_UI1, 1, rgsabound);
							psa->pvData=pbuf;
							
							SAFEARRAY** pp = &pArg->parray;
							pp++;
							*pp = psa;
							pArg->pparray = pp;*/
						}

					}
					break;
				case DTP_VARIANT:
					//if(pbIsRef[i])
				//	{
						pArg->vt = VT_VARIANT | VT_BYREF;
						pArg->pvarVal = (VARIANT*)*pArgInf[i].m_ppCompoundData;
				//	}else
				//		memcpy(pArg,(VARIANT*)*pArgInf[i].m_ppCompoundData,sizeof(VARIANT));
					break;
				case DTP_COM_OBJECT:
					if(pbIsRef[i])
					{
						if(wFlags==DISPATCH_PROPERTYPUT)
							 wFlags = DISPATCH_PROPERTYPUTREF;//ΪַʱתΪдַ־
						pArg->vt = VT_DISPATCH | VT_BYREF;
						PEYDISPATCH pDest = *(PEYDISPATCH*)pArgInf[i].m_ppCompoundData;
						pArg->ppdispVal = (LPDISPATCH*)pDest;
					}else{
						pArg->vt = VT_DISPATCH;
						PEYDISPATCH pDest = *(PEYDISPATCH*)pArgInf[i].m_ppCompoundData;
						pArg->pdispVal = pDest->pDisp;
					}
					break;
				}
			}

					--pArg; // get ready to fill next argument
		}
		delete [] pbIsRef;

	}

	UINT nArgErr = (UINT)-1;  // initialize to invalid arg

	// make the call
	HRESULT hRet = lpDispatch->Invoke(dwDispID, IID_NULL, 0, wFlags,
		&dispparams, pvarResult, NULL, &nArgErr);

	// cleanup any arguments that need cleanup
	if (dispparams.cArgs != 0)
	{
		VARIANT* pArg = dispparams.rgvarg + dispparams.cArgs - 1;
		for(INT i=0;i<nArgCount;i++)
		{
			switch (pArg->vt)
			{
			case VT_BSTR:
				if(pArgInf[i].m_dtDataType !=(DTP_VARIANT |DT_IS_ARY))
					VariantClear(pArg);
				break;
			case VT_BSTR|VT_BYREF:
				if(pArgInf[i].m_dtDataType==VAR_TEXT && pArg->pbstrVal)
				{
					if(*pArgInf[i].m_ppText)
						E_MFree(*pArgInf[i].m_ppText);
					*pArgInf[i].m_ppText = Unicode2EASCII(*pArg->pbstrVal);
				}
				VariantClear(pArg);
				break;
			case VT_ARRAY | VT_UI1:
				SafeArrayDestroy(pArg->parray);
				break;
				/*
			case VT_ARRAY | VT_UI1| VT_BYREF:
				if(pArg->pparray)
					SafeArrayDestroy(*pArg->pparray);
				break;*/
			}
			--pArg;
		}

	}
	delete[] dispparams.rgvarg;

	return hRet;
}

extern "C" 
{
	/*
	ƶ
	
	*/
	void _cdecl krnln_DispCopy (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp)
			pDest->pDisp->Release();
		PEYDISPATCH pSrc = (PEYDISPATCH)pArgInf[1].m_pCompoundData;
		pDest->pDisp = pSrc->pDisp;
		if(pDest->pDisp)
			pDest->pDisp->AddRef();


	}

	/*
    øʽ ߼͡ 󣮴 ı ͣı Ϳļݣ - ϵͳֿ֧->
    ӢƣCreateObject
    ָ͵ COM 󣬱еԭݽͷšɹ棬򷵻ؼ١ΪԱ
    <1>Ϊ͡ΪıͣtextָıƩ硰Word.ApplicationExcel.Application{000209FF-0000-0000-C000-000000000046}Ⱦɡ
    <2>ΪͿļΪıͣtextԱʡԡҪͨͿָܷ󣬿ڱṩͿͿļעûṩļ·ڵǰĿ¼޷ҵļϵͳԶʡԱĬΪҪͿļ

	
	*/
	BOOL _cdecl krnln_DispCreateObject (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp)
		{
			pDest->pDisp->Release();
			pDest->pDisp = NULL;
		}
		LPOLESTR lpzCom = ASCII2Unicode(pArgInf[1].m_pText);
		if(lpzCom==NULL){
			pDest->hRet = 0;
			return FALSE;
		}
		LPUNKNOWN lpUnknown = NULL;
		SCODE sc = S_OK;
		if(pArgInf[2].m_dtDataType != _SDT_NULL && pArgInf[2].m_pText)
		{
			LPOLESTR lpzFile = ASCII2Unicode(pArgInf[2].m_pText);
			ITypeLib * ptlib;
			if(LoadTypeLib(lpzFile,&ptlib) == S_OK)
			{
				ULONG lHash= LHashValOfNameSys(SYS_WIN32,GetUserDefaultLCID(),lpzCom);
				ITypeInfo* pTinfo = NULL;
				MEMBERID rgMid;
				USHORT cFd;
				if(ptlib->FindName(lpzCom,lHash,&pTinfo,&rgMid,&cFd)==S_OK){
					if(cFd == 1){
						if(pTinfo->CreateInstance(NULL,IID_IUnknown, (LPVOID*)&lpUnknown)==S_OK){
							if(strchr(pArgInf[2].m_pText,'\\')!=NULL){
								pDest->hRet = RegisterTypeLib(ptlib,lpzFile,NULL);
							}
						}
						pTinfo->Release();
					}
					
				}
				ptlib->Release();
			}

			delete [] lpzFile;
			if(lpUnknown){
				delete [] lpzCom;
				goto RunCom;
			}
			

		}
		CLSID clsid;

		pDest->hRet = CLSIDFromProgID(lpzCom,&clsid);
		if(FAILED(pDest->hRet))
			pDest->hRet = CLSIDFromString(lpzCom,&clsid);
		delete [] lpzCom;
		if(FAILED(pDest->hRet))
			return FALSE;
		// create an instance of the object
		
		sc = CoCreateInstance(clsid, NULL, CLSCTX_ALL | CLSCTX_REMOTE_SERVER,
			IID_IUnknown, (LPVOID*)&lpUnknown);
		if (sc == E_INVALIDARG)
		{
			// may not support CLSCTX_REMOTE_SERVER, so try without
			sc = CoCreateInstance(clsid, NULL, CLSCTX_ALL & ~CLSCTX_REMOTE_SERVER,
				IID_IUnknown, (LPVOID*)&lpUnknown);
		}

		if (FAILED(sc))
			goto Failed;

RunCom:		
		// make sure it is running
		sc = OleRun(lpUnknown);
		if (FAILED(sc)){
			lpUnknown->Release();
			goto Failed;
		}
		// query for IDispatch interface
	/*	sc = lpUnknown->QueryInterface(IID_IDispatch,(void**)&pDest->pDisp);
		if (pDest->pDisp == NULL)
			goto Failed;*/
		pDest->hRet = sc;
		pDest->pDisp = (IDispatch*)lpUnknown;
		return TRUE;
		
Failed:

		pDest->hRet = sc;
		return FALSE;

	}

	/*
    øʽ ߼͡ 󣮻ȡ ı ͣ - ϵͳֿ֧->
    ӢƣGetObject
    ȡǰϵͳѾڵָ COM 󣬱еԭݽͷšɹ棬򷵻ؼ١ΪԱ
    <1>Ϊ͡ΪıͣtextָıƩ硰Word.ApplicationExcel.Application{000209FF-0000-0000-C000-000000000046}Ⱦɡ
	
	*/
	BOOL _cdecl krnln_DispGetObject (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp)
		{
			pDest->pDisp->Release();
			pDest->pDisp=NULL;
		}
		CLSID clsid;
		LPOLESTR lpzCom = ASCII2Unicode(pArgInf[1].m_pText);
		pDest->hRet = CLSIDFromProgID(lpzCom,&clsid);
		if(FAILED(pDest->hRet))
			pDest->hRet = CLSIDFromString(lpzCom,&clsid);
		delete [] lpzCom;
		if(FAILED(pDest->hRet))
			return FALSE;

		DWORD dwReserved;
		pDest->hRet = GetActiveObject(clsid,&dwReserved,(LPUNKNOWN*)&pDest->pDisp);
		if(FAILED(pDest->hRet))
			return FALSE;
		return TRUE;

	}

	/*
    øʽ ޷ֵ   - ϵͳֿ֧->
    ӢƣClear
    ͷŲաñ˳ʱԶͷš磺ӳֲУӳ˳ʱöᱻԶͷšΪԱ
	
	*/
	void _cdecl krnln_DispClear (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PEYDISPATCH pDest = (PEYDISPATCH)ArgInf.m_pCompoundData;
		if(pDest->pDisp)
		{
			pDest->pDisp->Release();
			pDest->pDisp = NULL;
		}
		pDest->hRet = NULL;
		
	}

	/*
    øʽ ߼͡ ǷΪ  - ϵͳֿ֧->
    ӢƣIsEmpty
    Ϊգ棬򷵻ؼ١ΪԱ	
	*/
	BOOL _cdecl krnln_DispIsEmpty (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PEYDISPATCH pDest = (PEYDISPATCH)ArgInf.m_pCompoundData;
		if(pDest->pDisp)
			return FALSE;
		return TRUE;
		
	}

	/*
    øʽ ߼͡ Ƿ  Ķ - ϵͳֿ֧->
    ӢƣIsEqual
    ָȣ棬򷵻ؼ١ΪԱ
    <1>ΪĶ󡱣ΪComObjectָǷȵĶ
	
	*/
	BOOL _cdecl krnln_DispIsEqual (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		PEYDISPATCH pSrc = (PEYDISPATCH)pArgInf[1].m_pCompoundData;

		if(pDest->pDisp == pSrc->pDisp)
			return TRUE;
		return FALSE;

	}

	/*
    øʽ ı͡ 󣮶ı ı ƣͨ ݣݣ...  - ϵͳֿ֧->
    ӢƣGetTextProperty
    ȡرָıֵʧܽؿıҽִСȡ󡱷طǿıΪԱһԱظӡ
    <1>ΪơΪıͣtext
    <2>ΪݡΪͨͣallԱʡԡչṩдҪݡдԲҪκβ뱣ֱΪա
	*/
	char* _cdecl krnln_DispGetTextProperty (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp == NULL)
		{
			pDest->hRet = E_POINTER;
			return NULL;
		}
		LPDISPATCH lpDispatch = NULL;
		pDest->hRet = pDest->pDisp->QueryInterface(IID_IDispatch,(void **)&lpDispatch);
		if(pDest->hRet != S_OK)
			return NULL;
		DISPID dwDispid;
		pDest->hRet = Dispatch_GetIDsOfNames(lpDispatch,pArgInf[1].m_pText,&dwDispid);
		if(pDest->hRet != S_OK)
			return NULL;
		INT nCount = nArgCount - 2;
// 		if(pArgInf[nArgCount-1].m_dtDataType == _SDT_NULL)
// 			nCount --;
		for (int i = nArgCount - 1; i >= 2 && pArgInf[i].m_dtDataType == _SDT_NULL; i--)
			nCount --;
		
		VARIANT vaResult;
		memset(&vaResult, 0, sizeof vaResult);
		pDest->hRet = Dispatch_InvokeHelper(lpDispatch,
			dwDispid,DISPATCH_PROPERTYGET,&vaResult,nCount,&pArgInf[2]);

		lpDispatch->Release();

		LPSTR pText = NULL;
		if(vaResult.vt != VT_BSTR)
		{
			VARIANTARG vargDest;
			memcpy(&vargDest,&vaResult,sizeof(VARIANTARG));
			memset(&vaResult,0,sizeof(VARIANTARG));
			HRESULT hr = VariantChangeType(&vaResult,&vargDest,0,VT_BSTR);
			if(!FAILED(hr))
				pText = Unicode2EASCII(vaResult.bstrVal);
		}
		else
			pText = Unicode2EASCII(vaResult.bstrVal);
	/*	else{ȡصǶ͵
			VARIANTARG vargDest;
			memcpy(&vargDest,&vaResult,sizeof(VARIANTARG));
			memset(&vaResult,0,sizeof(VARIANTARG));
			pDest->hRet = VariantChangeType(&vaResult,&vargDest,0,VT_BSTR);
			VariantClear(&vargDest);

			if(pDest->hRet == S_OK){
				pText = Unicode2EASCII(vaResult.bstrVal);

			char ErrorString [1024];
  			wsprintf(ErrorString, "%s %d", pText,dwDispid);
			MessageBox(NULL,ErrorString,pArgInf[1].m_pText,MB_OK);
			}
		}*/
		
		VariantClear(&vaResult);


		return pText;
		
	}
	/*
    øʽ ˫С͡ 󣮶ֵ ı ƣͨ ݣݣ...  - ϵͳֿ֧->
    ӢƣGetNumProperty
    ȡرֵֵָʧֵܽ0ҽִСȡ󡱷طǿıΪԱһԱظӡ
    <1>ΪơΪıͣtext
    <2>ΪݡΪͨͣallԱʡԡչṩдҪݡдԲҪκβ뱣ֱΪա
	*/
	void _cdecl krnln_DispGetNumProperty (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp == NULL)
		{
			pDest->hRet = E_POINTER;
			return ;
		}
		LPDISPATCH lpDispatch = NULL;
		pDest->hRet = pDest->pDisp->QueryInterface(IID_IDispatch,(void **)&lpDispatch);
		if(pDest->hRet != S_OK)
			return ;
		DISPID dwDispid;
		pDest->hRet = Dispatch_GetIDsOfNames(lpDispatch,pArgInf[1].m_pText,&dwDispid);
		if(pDest->hRet != S_OK)
			return ;
		INT nCount = nArgCount - 2;
// 		if(pArgInf[nArgCount-1].m_dtDataType == _SDT_NULL)
// 			nCount --;
		for (int i = nArgCount - 1; i >= 2 && pArgInf[i].m_dtDataType == _SDT_NULL; i--)
			nCount --;

		VARIANT vaResult;
		memset(&vaResult, 0, sizeof vaResult);
		pDest->hRet = Dispatch_InvokeHelper(lpDispatch,
			dwDispid,DISPATCH_PROPERTYGET,&vaResult,nCount,&pArgInf[2]);



		lpDispatch->Release();
		MDATA_INF RetVal;

		switch (vaResult.vt)
		{
		case VT_UI1:
			RetVal.m_double = vaResult.bVal;
			break;
		case VT_I2:
			RetVal.m_double = vaResult.iVal;
			break;
		case VT_I4:
			RetVal.m_double = vaResult.lVal;
			break;
		case VT_R4:
			RetVal.m_double = vaResult.fltVal;
			break;
		case VT_R8:
			RetVal.m_double = vaResult.dblVal;
			break;
		case VT_DATE:
			RetVal.m_double = vaResult.date;
			break;
		case VT_CY:
			VarR8FromCy(vaResult.cyVal,&RetVal.m_double);
			break;
		case VT_I1:
			RetVal.m_double = vaResult.cVal;
			break;
		case VT_UI2:
			RetVal.m_double = vaResult.uiVal;
			break;
		case VT_UI4:
			RetVal.m_double = vaResult.ulVal;
			break;
		case VT_BOOL:
			VarR8FromBool(vaResult.boolVal,&RetVal.m_double);
			break;
		default:
			RetVal.m_double = 0;
			break;	
		}
		
		VariantClear(&vaResult);

		__asm
		{
			mov eax,RetVal.m_unit.m_dwFormID;
			mov edx,RetVal.m_unit.m_dwUnitID;
		}
		
	}
	/*
    øʽ ߼͡ 󣮶߼ ı ƣͨ ݣݣ...  - ϵͳֿ֧->
    ӢƣGetBoolProperty
    ȡرָ߼ֵʧܽؼ٣ҽִСȡ󡱷طǿıΪԱһԱظӡ
    <1>ΪơΪıͣtext
    <2>ΪݡΪͨͣallԱʡԡչṩдҪݡдԲҪκβ뱣ֱΪա
	*/
	BOOL _cdecl krnln_DispGetBoolProperty (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp == NULL)
		{
			pDest->hRet = E_POINTER;
			return NULL;
		}
		LPDISPATCH lpDispatch = NULL;
		pDest->hRet = pDest->pDisp->QueryInterface(IID_IDispatch,(void **)&lpDispatch);
		if(pDest->hRet != S_OK)
			return NULL;
		DISPID dwDispid;
		pDest->hRet = Dispatch_GetIDsOfNames(lpDispatch,pArgInf[1].m_pText,&dwDispid);
		if(pDest->hRet != S_OK)
			return NULL;
		INT nCount = nArgCount - 2;
// 		if(pArgInf[nArgCount-1].m_dtDataType == _SDT_NULL)
// 			nCount --;
		for (int i = nArgCount - 1; i >= 2 && pArgInf[i].m_dtDataType == _SDT_NULL; i--)
			nCount --;

		VARIANT vaResult;
		memset(&vaResult, 0, sizeof vaResult);
		pDest->hRet = Dispatch_InvokeHelper(lpDispatch,
			dwDispid,DISPATCH_PROPERTYGET,&vaResult,nCount,&pArgInf[2]);
		lpDispatch->Release();
		BOOL bRet = FALSE;
		if(vaResult.vt == VT_BOOL)
			bRet =(vaResult.boolVal != 0 ? 1:0);
		
		VariantClear(&vaResult);

		return bRet;
		
	}
	/*
    øʽ ʱ͡ 󣮶 ı ƣͨ ݣݣ...  - ϵͳֿ֧->
    ӢƣGetDateProperty
    ȡرָʱֵʧܽ10011գҽִСȡ󡱷طǿıΪԱһԱظӡ
    <1>ΪơΪıͣtext
    <2>ΪݡΪͨͣallԱʡԡչṩдҪݡдԲҪκβ뱣ֱΪա
	*/
	void _cdecl krnln_DispGetDateProperty (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp == NULL)
		{
			pDest->hRet = E_POINTER;
			return ;
		}
		LPDISPATCH lpDispatch = NULL;
		pDest->hRet = pDest->pDisp->QueryInterface(IID_IDispatch,(void **)&lpDispatch);
		if(pDest->hRet != S_OK)
			return ;
		DISPID dwDispid;
		pDest->hRet = Dispatch_GetIDsOfNames(lpDispatch,pArgInf[1].m_pText,&dwDispid);
		if(pDest->hRet != S_OK)
			return ;
		INT nCount = nArgCount - 2;
// 		if(pArgInf[nArgCount-1].m_dtDataType == _SDT_NULL)
// 			nCount --;
		for (int i = nArgCount - 1; i >= 2 && pArgInf[i].m_dtDataType == _SDT_NULL; i--)
			nCount --;

		VARIANT vaResult;
		memset(&vaResult, 0, sizeof vaResult);
		pDest->hRet = Dispatch_InvokeHelper(lpDispatch,
			dwDispid,DISPATCH_PROPERTYGET,&vaResult,nCount,&pArgInf[2]);
		lpDispatch->Release();

		MDATA_INF RetVal;

		if(vaResult.vt == VT_DATE)
			RetVal.m_date = vaResult.date;
		else
			RetVal.m_date = 0;
		
		VariantClear(&vaResult);

		__asm
		{
			mov eax,RetVal.m_unit.m_dwFormID;
			mov edx,RetVal.m_unit.m_dwUnitID;
		}
		
	}
	/*
    øʽ  󣮶 ı ƣͨ ݣݣ...  - ϵͳֿ֧->
    ӢƣGetObjectProperty
    ȡرֵָʧܽΪյĶҽִСȡ󡱷طǿıΪԱһԱظӡ
    <1>ΪơΪıͣtext
    <2>ΪݡΪͨͣallԱʡԡչṩдҪݡдԲҪκβ뱣ֱΪա
	*/
	void* _cdecl krnln_DispGetObjectProperty (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pdispRet = (PEYDISPATCH)E_MAlloc(sizeof(EYDISPATCH));
		//memset(pdispRet,0,sizeof(EYDISPATCH));
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp == NULL)
		{
			pDest->hRet = E_POINTER;
			return pdispRet;
		}
		LPDISPATCH lpDispatch = NULL;
		pDest->hRet = pDest->pDisp->QueryInterface(IID_IDispatch,(void **)&lpDispatch);
		if(pDest->hRet != S_OK)
			return pdispRet;
		DISPID dwDispid;
		pDest->hRet = Dispatch_GetIDsOfNames(lpDispatch,pArgInf[1].m_pText,&dwDispid);
		if(pDest->hRet != S_OK)
			return pdispRet;
		INT nCount = nArgCount - 2;
// 		if(pArgInf[nArgCount-1].m_dtDataType == _SDT_NULL)
// 			nCount --;
		for (int i = nArgCount - 1; i >= 2 && pArgInf[i].m_dtDataType == _SDT_NULL; i--)
			nCount --;

		VARIANT vaResult;
		memset(&vaResult, 0, sizeof vaResult);
		pDest->hRet = Dispatch_InvokeHelper(lpDispatch,
			dwDispid,DISPATCH_PROPERTYGET,&vaResult,nCount,&pArgInf[2]);
		lpDispatch->Release();
		

		switch (vaResult.vt)
		{
		case VT_DISPATCH:
			pdispRet->pDisp = vaResult.pdispVal;
			if(pdispRet->pDisp)
				pdispRet->pDisp->AddRef();
			break;
		case VT_UNKNOWN:
			pdispRet->pDisp = (LPDISPATCH)vaResult.punkVal;
			if(pdispRet->pDisp)
				pdispRet->pDisp->AddRef();
			break;
		case VT_DISPATCH|VT_BYREF:
			pdispRet->pDisp = *vaResult.ppdispVal;
			if(pdispRet->pDisp)
				pdispRet->pDisp->AddRef();
			break;
		case VT_UNKNOWN|VT_BYREF:
			pdispRet->pDisp = *(LPDISPATCH*)vaResult.ppunkVal;
			if(pdispRet->pDisp)
				pdispRet->pDisp->AddRef();
			break;
		}
		VariantClear(&vaResult);

		return pdispRet;
		
	}

	/*
    øʽ ͡ 󣮶 ı ƣͨ ݣݣ...  - ϵͳֿ֧->
    ӢƣGetProperty
    ȡرֵָȡ͵ԡʧֵܽΪյıͶҽִСȡ󡱷طǿı򽫷ذӦݵıͶ󡣱ΪԱһԱظӡ
    <1>ΪơΪıͣtext
    <2>ΪݡΪͨͣallԱʡԡչṩдҪݡдԲҪκβ뱣ֱΪա
	*/
	void* _cdecl krnln_DispGetProperty (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		VARIANT* pVarRet = (VARIANT*)E_MAlloc(sizeof(VARIANT));
		//memset(pVarRet,0,sizeof(VARIANT));
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp == NULL)
		{
			pDest->hRet = E_POINTER;
			return pVarRet;
		}
		LPDISPATCH lpDispatch = NULL;
		pDest->hRet = pDest->pDisp->QueryInterface(IID_IDispatch,(void **)&lpDispatch);
		if(pDest->hRet != S_OK)
			return pVarRet;
		DISPID dwDispid;
		pDest->hRet = Dispatch_GetIDsOfNames(lpDispatch,pArgInf[1].m_pText,&dwDispid);
		if(pDest->hRet != S_OK)
			return pVarRet;
		INT nCount = nArgCount - 2;
// 		if(pArgInf[nArgCount-1].m_dtDataType == _SDT_NULL)
// 			nCount --;
		for (int i = nArgCount - 1; i >= 2 && pArgInf[i].m_dtDataType == _SDT_NULL; i--)
			nCount --;
		/*char tt[2];
		itoa(nCount,tt,10);
		MessageBox(NULL,tt,"count",MB_OK);*/

		pDest->hRet = Dispatch_InvokeHelper(lpDispatch,
			dwDispid,DISPATCH_PROPERTYGET,pVarRet,nCount,&pArgInf[2]);
		lpDispatch->Release();
		
		return pVarRet;
		
	}

	/*
    øʽ ߼͡ д ı ƣͨ ݣݣ...  - ϵͳֿ֧->
    ӢƣSetProperty
    ñָԵֵʧܣؼ٣ҽִСȡ󡱷طǿıΪԱһԱظӡ
    <1>ΪơΪıͣtext
    <2>ΪݡΪͨͣallԱʡԡչṩдҪݡдԲҪκβ뱣ֱΪա
	*/
	BOOL _cdecl krnln_DispSetProperty (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp == NULL)
		{
			pDest->hRet = E_POINTER;
			return NULL;
		}
		LPDISPATCH lpDispatch = NULL;
		pDest->hRet = pDest->pDisp->QueryInterface(IID_IDispatch,(void **)&lpDispatch);
		if(pDest->hRet != S_OK)
			return NULL;
		DISPID dwDispid;
		pDest->hRet = Dispatch_GetIDsOfNames(lpDispatch,pArgInf[1].m_pText,&dwDispid);
		if(pDest->hRet != S_OK)
			return NULL;

		INT nCount = nArgCount - 2;
// 		if(pArgInf[nArgCount-1].m_dtDataType == _SDT_NULL)
// 			nCount --;
		for (int i = nArgCount - 1; i >= 2 && pArgInf[i].m_dtDataType == _SDT_NULL; i--)
			nCount --;

		DWORD dwFlags = DISPATCH_PROPERTYPUT;
/*		if(nCount>0 && (pArgInf[2].m_dtDataType & ~DT_IS_ARY) == DTP_COM_OBJECT)
			dwFlags = DISPATCH_PROPERTYPUTREF;
		else
			dwFlags = DISPATCH_PROPERTYPUT;*/

		pDest->hRet = Dispatch_InvokeHelper(lpDispatch,
			dwDispid,(WORD)dwFlags,NULL,nCount,&pArgInf[2]);
		lpDispatch->Release();
		BOOL bRet;
		if(pDest->hRet == S_OK)
			bRet = TRUE;
		else
			bRet = FALSE;
		return bRet;
		
	}
	/*
    øʽ ޷ֵ 󣮷 ı ƣͨ ݣݣ...  - ϵͳֿ֧->
    ӢƣRunMethod
    ִбָ䷵ֵʧܣִСȡ󡱷طǿıΪԱһԱظӡ
    <1>ΪơΪıͣtextṩ÷ơ
    <2>ΪݡΪͨͣallԱʡԡչṩ÷Ҫݡ÷Ҫκβ뱣ֱΪա
	*/
	void _cdecl krnln_DispRunMethod (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp == NULL)
		{
			pDest->hRet = E_POINTER;
			return ;
		}
		LPDISPATCH lpDispatch = NULL;
		pDest->hRet = pDest->pDisp->QueryInterface(IID_IDispatch,(void **)&lpDispatch);
		if(pDest->hRet != S_OK)
			return ;
		DISPID dwDispid;
		pDest->hRet = Dispatch_GetIDsOfNames(lpDispatch,pArgInf[1].m_pText,&dwDispid);
		if(pDest->hRet != S_OK)
			return ;
		INT nCount = nArgCount - 2;
// 		if(pArgInf[nArgCount-1].m_dtDataType == _SDT_NULL)
// 			nCount --;
		for (int i = nArgCount - 1; i >= 2 && pArgInf[i].m_dtDataType == _SDT_NULL; i--)
			nCount --;

		VARIANT vaResult;
		memset(&vaResult, 0, sizeof vaResult);
		pDest->hRet = Dispatch_InvokeHelper(lpDispatch,
			dwDispid,DISPATCH_METHOD,&vaResult,nCount,&pArgInf[2]);
		lpDispatch->Release();
		if(vaResult.vt != VT_EMPTY)
			VariantClear(&vaResult);
		
	}

	/*
    øʽ ͡ ͨ÷ ı ƣͨ ݣݣ...  - ϵͳֿ֧->
    ӢƣRunVariantMethod
    ִбָһͶֵöڼ¼÷ķݡִзκݵķ÷ûзݣرͶֵΪաʧܣһֵΪյıͶҽִСȡ󡱷طǿıΪԱһԱظӡ
    <1>ΪơΪıͣtextṩ÷ơ
    <2>ΪݡΪͨͣallԱʡԡչṩ÷Ҫݡ÷Ҫκβ뱣ֱΪա
	*/
	void* _cdecl krnln_DispRunVariantMethod (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		VARIANT* pVarRet = (VARIANT*)E_MAlloc(sizeof(VARIANT));
		//memset(pVarRet,0,sizeof(VARIANT));
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp == NULL)
		{
			pDest->hRet = E_POINTER;
			return pVarRet;
		}
		LPDISPATCH lpDispatch = NULL;
		pDest->hRet = pDest->pDisp->QueryInterface(IID_IDispatch,(void **)&lpDispatch);
		if(pDest->hRet != S_OK)
			return pVarRet;
		DISPID dwDispid;
		pDest->hRet = Dispatch_GetIDsOfNames(lpDispatch,pArgInf[1].m_pText,&dwDispid);
		if(pDest->hRet != S_OK)
			return pVarRet;
		INT nCount = nArgCount - 2;
// 		if(pArgInf[nArgCount-1].m_dtDataType == _SDT_NULL)
// 			nCount --;
		for (int i = nArgCount - 1; i >= 2 && pArgInf[i].m_dtDataType == _SDT_NULL; i--)
			nCount --;

		pDest->hRet = Dispatch_InvokeHelper(lpDispatch,
			dwDispid,DISPATCH_METHOD,pVarRet,nCount,&pArgInf[2]);
		lpDispatch->Release();
		
		return pVarRet;
		
	}

	/*
    øʽ ı͡ ı ı ƣͨ ݣݣ...  - ϵͳֿ֧->
    ӢƣRunTextMethod
    ִб󷵻ıݵķʧܽؿıҽִСȡ󡱷طǿıΪԱһԱظӡ
    <1>ΪơΪıͣtextṩ÷ơ
    <2>ΪݡΪͨͣallԱʡԡչṩ÷Ҫݡ÷Ҫκβ뱣ֱΪա
	*/
	char* _cdecl krnln_DispRunTextMethod (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp == NULL)
		{
			pDest->hRet = E_POINTER;
			return NULL;
		}
		LPDISPATCH lpDispatch = NULL;
		pDest->hRet = pDest->pDisp->QueryInterface(IID_IDispatch,(void **)&lpDispatch);
		if(pDest->hRet != S_OK)
			return NULL;
		DISPID dwDispid;
		pDest->hRet = Dispatch_GetIDsOfNames(lpDispatch,pArgInf[1].m_pText,&dwDispid);
		if(pDest->hRet != S_OK)
			return NULL;
		INT nCount = nArgCount - 2;
// 		if(pArgInf[nArgCount-1].m_dtDataType == _SDT_NULL)
// 			nCount --;
		for (int i = nArgCount - 1; i >= 2 && pArgInf[i].m_dtDataType == _SDT_NULL; i--)
			nCount --;

		VARIANT vaResult;
		memset(&vaResult, 0, sizeof vaResult);
		pDest->hRet = Dispatch_InvokeHelper(lpDispatch,
			dwDispid,DISPATCH_METHOD,&vaResult,nCount,&pArgInf[2]);
		lpDispatch->Release();

		LPSTR pText = NULL;
		if(vaResult.vt != VT_BSTR)
		{
			VARIANTARG vargDest;
			memcpy(&vargDest,&vaResult,sizeof(VARIANTARG));
			memset(&vaResult,0,sizeof(VARIANTARG));
			HRESULT hr = VariantChangeType(&vaResult,&vargDest,0,VT_BSTR);
 			if(!FAILED(hr))
 				pText = Unicode2EASCII(vaResult.bstrVal);
		}
		else
			pText = Unicode2EASCII(vaResult.bstrVal);

		VariantClear(&vaResult);

		return pText;
	}

	/*
    øʽ ˫С͡ ֵ ı ƣͨ ݣݣ...  - ϵͳֿ֧->
    ӢƣRunNumMethod
    ִб󷵻ֵݵķʧֵܽ0ҽִСȡ󡱷طǿıΪԱһԱظӡ
    <1>ΪơΪıͣtextṩ÷ơ
    <2>ΪݡΪͨͣallԱʡԡչṩ÷Ҫݡ÷Ҫκβ뱣ֱΪա
	*/
	void _cdecl krnln_DispRunNumMethod (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp == NULL)
		{
			pDest->hRet = E_POINTER;
			return ;
		}

		LPDISPATCH lpDispatch = NULL;
		pDest->hRet = pDest->pDisp->QueryInterface(IID_IDispatch,(void **)&lpDispatch);
		if(pDest->hRet != S_OK)
			return ;
		DISPID dwDispid;
		pDest->hRet = Dispatch_GetIDsOfNames(lpDispatch,pArgInf[1].m_pText,&dwDispid);

		if(pDest->hRet != S_OK)
			return ;
		INT nCount = nArgCount - 2;
// 		if(pArgInf[nArgCount-1].m_dtDataType == _SDT_NULL)
// 			nCount --;
		for (int i = nArgCount - 1; i >= 2 && pArgInf[i].m_dtDataType == _SDT_NULL; i--)
			nCount --;

		VARIANT vaResult;
		memset(&vaResult, 0, sizeof vaResult);
		pDest->hRet = Dispatch_InvokeHelper(lpDispatch,
			dwDispid,DISPATCH_METHOD,&vaResult,nCount,&pArgInf[2]);
		lpDispatch->Release();
		MDATA_INF RetVal;
		
		switch (vaResult.vt)
		{
		case VT_UI1:
			RetVal.m_double = vaResult.bVal;
			break;
		case VT_I2:
			RetVal.m_double = vaResult.iVal;
			break;
		case VT_I4:
			RetVal.m_double = vaResult.lVal;
			break;
		case VT_R4:
			RetVal.m_double = vaResult.fltVal;
			break;
		case VT_R8:
			RetVal.m_double = vaResult.dblVal;
			break;
		case VT_DATE:
			RetVal.m_double = vaResult.date;
			break;
		case VT_CY:
			VarR8FromCy(vaResult.cyVal,&RetVal.m_double);
			break;
		case VT_I1:
			RetVal.m_double = vaResult.cVal;
			break;
		case VT_UI2:
			RetVal.m_double = vaResult.uiVal;
			break;
		case VT_UI4:
			RetVal.m_double = vaResult.ulVal;
			break;
		case VT_BOOL:
			VarR8FromBool(vaResult.boolVal,&RetVal.m_double);
			break;
		default:
			RetVal.m_double = 0;
			break;	
		}
		
		VariantClear(&vaResult);

		__asm
		{
			mov eax,RetVal.m_unit.m_dwFormID;
			mov edx,RetVal.m_unit.m_dwUnitID;
		}
		
	}
	/*
    øʽ ߼͡ ߼ ı ƣͨ ݣݣ...  - ϵͳֿ֧->
    ӢƣRunBoolMethod
    ִб󷵻߼ݵķʧܽؼ٣ҽִСȡ󡱷طǿıΪԱһԱظӡ
    <1>ΪơΪıͣtextṩ÷ơ
    <2>ΪݡΪͨͣallԱʡԡչṩ÷Ҫݡ÷Ҫκβ뱣ֱΪա
	*/
	BOOL _cdecl krnln_DispRunBoolMethod (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp == NULL)
		{
			pDest->hRet = E_POINTER;
			return NULL;
		}
		LPDISPATCH lpDispatch = NULL;
		pDest->hRet = pDest->pDisp->QueryInterface(IID_IDispatch,(void **)&lpDispatch);
		if(pDest->hRet != S_OK)
			return NULL;
		DISPID dwDispid;
		pDest->hRet = Dispatch_GetIDsOfNames(lpDispatch,pArgInf[1].m_pText,&dwDispid);
		if(pDest->hRet != S_OK)
			return NULL;
		INT nCount = nArgCount - 2;
// 		if(pArgInf[nArgCount-1].m_dtDataType == _SDT_NULL)
// 			nCount --;
		for (int i = nArgCount - 1; i >= 2 && pArgInf[i].m_dtDataType == _SDT_NULL; i--)
			nCount --;

		VARIANT vaResult;
		memset(&vaResult, 0, sizeof vaResult);
		pDest->hRet = Dispatch_InvokeHelper(lpDispatch,
			dwDispid,DISPATCH_METHOD,&vaResult,nCount,&pArgInf[2]);
		lpDispatch->Release();
		BOOL bRet = FALSE;
		if(vaResult.vt == VT_BOOL)
			bRet =(vaResult.boolVal != 0 ? 1:0);
		
		VariantClear(&vaResult);

		return bRet;
		
	}
	/*
    øʽ ʱ͡ ڷ ı ƣͨ ݣݣ...  - ϵͳֿ֧->
    ӢƣRunDateMethod
    ִб󷵻ʱݵķʧܽ10011գҽִСȡ󡱷طǿıΪԱһԱظӡ
    <1>ΪơΪıͣtextṩ÷ơ
    <2>ΪݡΪͨͣallԱʡԡչṩ÷Ҫݡ÷Ҫκβ뱣ֱΪա
	*/
	void _cdecl krnln_DispRunDateMethod (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp == NULL)
		{
			pDest->hRet = E_POINTER;
			return ;
		}
		LPDISPATCH lpDispatch = NULL;
		pDest->hRet = pDest->pDisp->QueryInterface(IID_IDispatch,(void **)&lpDispatch);
		if(pDest->hRet != S_OK)
			return ;
		DISPID dwDispid;
		pDest->hRet = Dispatch_GetIDsOfNames(lpDispatch,pArgInf[1].m_pText,&dwDispid);
		if(pDest->hRet != S_OK)
			return ;
		INT nCount = nArgCount - 2;
// 		if(pArgInf[nArgCount-1].m_dtDataType == _SDT_NULL)
// 			nCount --;
		for (int i = nArgCount - 1; i >= 2 && pArgInf[i].m_dtDataType == _SDT_NULL; i--)
			nCount --;

		VARIANT vaResult;
		memset(&vaResult, 0, sizeof vaResult);
		pDest->hRet = Dispatch_InvokeHelper(lpDispatch,
			dwDispid,DISPATCH_METHOD,&vaResult,nCount,&pArgInf[2]);
		lpDispatch->Release();

		MDATA_INF RetVal;

		if(vaResult.vt == VT_DATE)
			RetVal.m_date = vaResult.date;
		else
			RetVal.m_date = 0;
		
		VariantClear(&vaResult);

		__asm
		{
			mov eax,RetVal.m_unit.m_dwFormID;
			mov edx,RetVal.m_unit.m_dwUnitID;
		}
		
	}
	/*
    øʽ  󣮶ͷ ı ƣͨ ݣݣ...  - ϵͳֿ֧->
    ӢƣRunObjectMethod
    ִб󷵻ضݵķʧܽΪյĶҽִСȡ󡱷طǿıΪԱһԱظӡ
    <1>ΪơΪıͣtextṩ÷ơ
    <2>ΪݡΪͨͣallԱʡԡչṩ÷Ҫݡ÷Ҫκβ뱣ֱΪա
	*/
	void* _cdecl krnln_DispRunObjectMethod (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pdispRet = (PEYDISPATCH)E_MAlloc(sizeof(EYDISPATCH));
		//memset(pdispRet,0,sizeof(EYDISPATCH));
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp == NULL)
		{
			pDest->hRet = E_POINTER;
			return pdispRet;
		}
		LPDISPATCH lpDispatch = NULL;
		pDest->hRet = pDest->pDisp->QueryInterface(IID_IDispatch,(void **)&lpDispatch);
		if(pDest->hRet != S_OK)
			return pdispRet;
		DISPID dwDispid;
		pDest->hRet = Dispatch_GetIDsOfNames(lpDispatch,pArgInf[1].m_pText,&dwDispid);
		if(pDest->hRet != S_OK)
			return pdispRet;
		INT nCount = nArgCount - 2;
// 		if(pArgInf[nArgCount-1].m_dtDataType == _SDT_NULL)
// 			nCount --;
		for (int i = nArgCount - 1; i >= 2 && pArgInf[i].m_dtDataType == _SDT_NULL; i--)
			nCount --;

		VARIANT vaResult;
		memset(&vaResult, 0, sizeof vaResult);
		pDest->hRet = Dispatch_InvokeHelper(lpDispatch,
			dwDispid,DISPATCH_METHOD,&vaResult,nCount,&pArgInf[2]);
		lpDispatch->Release();
		
		switch (vaResult.vt)
		{
		case VT_DISPATCH:
			pdispRet->pDisp = vaResult.pdispVal;
			if(pdispRet->pDisp)
				pdispRet->pDisp->AddRef();
			break;
		case VT_UNKNOWN:
			pdispRet->pDisp = (LPDISPATCH)vaResult.punkVal;
			if(pdispRet->pDisp)
				pdispRet->pDisp->AddRef();
			break;
		case VT_DISPATCH|VT_BYREF:
			pdispRet->pDisp = *vaResult.ppdispVal;
			if(pdispRet->pDisp)
				pdispRet->pDisp->AddRef();
			break;
		case VT_UNKNOWN|VT_BYREF:
			pdispRet->pDisp = *(LPDISPATCH*)vaResult.ppunkVal;
			if(pdispRet->pDisp)
				pdispRet->pDisp->AddRef();
			break;
		}
		VariantClear(&vaResult);

		return pdispRet;
		
	}

	/*
     øʽ ߼͡ 󣮴ͼƬ ֽڼ ͼƬݣ - ϵͳֿ֧->
    ӢƣCreatePicDispObj
    ΪָͼƬݴӦ COM ͼƬ󣬱еԭݽͷšɹ棬򷵻ؼ١ΪԱ
    <1>ΪͼƬݡΪֽڼbinṩͼƬͼƬݡ
	*/
	BOOL _cdecl krnln_DispCreatePicDispObj (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp)
		{
			pDest->pDisp->Release();
			pDest->pDisp=NULL;
		}
		if(pArgInf[1].m_pBin==NULL)
		{
			pDest->hRet = E_POINTER;
			return FALSE;
		}
		INT nLength=*(LPINT)(pArgInf[1].m_pBin + sizeof (INT));
		if(nLength <= 0)
		{
			pDest->hRet = E_POINTER;
			return FALSE;
		}
		BYTE* pbuf=pArgInf[1].m_pBin + sizeof (INT) * 2;
		LPVOID pvData = NULL;
		//ڴ棬׼ͼƬļ
		//GlobalAllocӶѷָֽڵڴ
		HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, nLength);
		//GlobalLockסһȫֵڴͬʱһָֽڵָ 
		pvData = GlobalLock(hGlobal);
		memcpy(pvData,pbuf,nLength);
		GlobalUnlock(hGlobal);

		//ˣѾļݶڴ浱
		LPSTREAM pstm = NULL;
		//ȫڴ洴IStreamӿָ
		pDest->hRet = CreateStreamOnHGlobal(hGlobal, TRUE, &pstm);
		if(FAILED(pDest->hRet))
		{
			GlobalFree(hGlobal); 
			return FALSE;
		}

		//ͼƬļIPictureӿָ
		pDest->hRet = ::OleLoadPicture(pstm, nLength, FALSE, IID_IPicture, (LPVOID *)&pDest->pDisp);
		pstm->Release();
		GlobalFree(hGlobal); 

		if(FAILED(pDest->hRet))
			return FALSE;
		return TRUE;
		
	}
	/*
    øʽ ֽڼ ȡͼƬ  - ϵͳֿ֧->
    ӢƣGetPic
    Ϊ COM ͼƬȡͼƬݡɹͼƬֽڼʧܷؿֽڼΪԱ
	*/
	void* _cdecl krnln_DispGetPic (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp == NULL)
		{
			pDest->hRet = E_POINTER;
			return NULL;
		}
		IPicture*   pPicture=NULL;   
		pDest->hRet = pDest->pDisp->QueryInterface(IID_IPicture,(void **)&pPicture);
		if(pDest->hRet != S_OK)
			return NULL;
		LPSTREAM   pStream;   
		CreateStreamOnHGlobal(NULL,TRUE,&pStream);   
		LONG   size;   
		pDest->hRet = pPicture->SaveAsFile(pStream,TRUE,&size);
		if(pDest->hRet != S_OK || size==0)
		{
			pPicture->Release ();
			return NULL;
		}
		LARGE_INTEGER   li;   
		li.HighPart   =0;   
		li.LowPart   =0;   
		ULARGE_INTEGER   ulnewpos;   
		pStream->Seek(   li,STREAM_SEEK_SET,&ulnewpos);  
		
		LPBYTE pd = (LPBYTE)E_MAlloc ((DWORD)(sizeof (INT) * 2 + size));
		*(LPINT)pd = 1;
		*(LPINT)(pd + sizeof (INT)) =	size;
		ULONG   uReadCount   =   1;   
		pDest->hRet =pStream->Read(pd + sizeof (INT) * 2,size,&uReadCount); 
		pStream->Release();   
		pPicture->Release ();
		return pd;
	}
	/*
    øʽ ı͡ ȡ  - ϵͳֿ֧->
    ӢƣGetErrorText
    дԡִж󷽷ȡʱִбԼǷִгɹɹؿıʧܣһϢķǿıΪԱ	
	*/
	char* _cdecl krnln_DispGetErrorText (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PEYDISPATCH pDest = (PEYDISPATCH)ArgInf.m_pCompoundData;
		if(pDest->hRet == NULL)
			return NULL;
		char strErr[MAX_PATH];
		LPSTR pText = NULL;
		DWORD dwLen = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,NULL,pDest->hRet,NULL,strErr,MAX_PATH,NULL);
		if(dwLen)
			pText = CloneTextData(strErr,mystrlen(strErr));
		return pText;
		
	}
	/*
    øʽ ߼͡ ȡӿ ͨ 򴰿ı ӿڱ־ݣ - ϵͳֿ֧->
    ӢƣQueryInterface
    ȡָOCXеָӿڣеԭݽͷšɹ棬ʧܷؼ١ΪԱ
    <1>Ϊ򴰿ΪͨͣallṩȡӿڶĶݣΪ֮һ1COMװװĶͣ 2ֿ֧еġ() 3COMװװOCX͡
    <2>Ϊӿڱ־ΪıͣtextԱʡԡڱָȡӿڵľƻȫΨһ־(GUID)硰IDataSourceControl{B62EE548-2B65-43BE-9F39-E2B71742578A}ȡʡԣĬȡĻӿڡ	
	*/
	BOOL _cdecl krnln_DispQueryInterface (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp)
		{
			pDest->pDisp->Release();
			pDest->pDisp=NULL;
		}
		if(pArgInf[1].m_dtDataType != DTP_COM_OBJECT)
		{
			pDest->hRet = E_POINTER;
			return FALSE;
		}
		PEYDISPATCH pSrc = (PEYDISPATCH)pArgInf[1].m_pCompoundData;
		if(pSrc->pDisp==NULL)
		{
			pDest->hRet = E_POINTER;
			return FALSE;
		}

		CLSID clsid;
		if(pArgInf[2].m_dtDataType != _SDT_NULL)
		{
			LPOLESTR lpzCom = ASCII2Unicode(pArgInf[2].m_pText);
			pDest->hRet = CLSIDFromProgID(lpzCom,&clsid);
			if(FAILED(pDest->hRet))
				pDest->hRet = CLSIDFromString(lpzCom,&clsid);
			delete [] lpzCom;
			if(FAILED(pDest->hRet))
				return FALSE;
		}
		else
			clsid = IID_IDispatch;

		pDest->hRet = pSrc->pDisp->QueryInterface(clsid,(void**)&pDest->pDisp);
		if(FAILED(pDest->hRet))
			return FALSE;
		return TRUE;

	}
	/*
    øʽ ߼͡ 󣮴  ݣ - ϵͳֿ֧->
    ӢƣCreateFontDispObj
    ΪָݴӦ COM 󣬱еԭݽͷšɹ棬򷵻ؼ١ΪԱ
    <1>ΪݡΪ壨fontṩݡ
	*/
	BOOL _cdecl krnln_DispCreateFontDispObj (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp)
		{
			pDest->pDisp->Release();
			pDest->pDisp=NULL;
		}
		if(pArgInf[1].m_pBin==NULL)
		{
			pDest->hRet = E_POINTER;
			return FALSE;
		}
		FONTDESC fd;
		fd.cbSizeofstruct = sizeof(FONTDESC);
		fd.lpstrName = ASCII2Unicode((LPSTR)pArgInf[1].m_pInt[6]);
		fd.sWeight = (short)pArgInf[1].m_pInt[1]?700:400;
		fd.sCharset = DEFAULT_CHARSET;
		fd.fItalic = pArgInf[1].m_pInt[2];
		fd.fUnderline = pArgInf[1].m_pInt[4];
		fd.fStrikethrough = pArgInf[1].m_pInt[3];

		fd.cySize.Lo = pArgInf[1].m_pInt[5]*10000;  
		fd.cySize.Hi = 0;
		
		pDest->hRet = OleCreateFontIndirect(&fd, IID_IFontDisp, (void**) &pDest->pDisp);
		delete [] fd.lpstrName;
		if(FAILED(pDest->hRet))
			return FALSE;
		return TRUE;
	}
	/*
    øʽ 塵 ȡ  - ϵͳֿ֧->
    ӢƣGetFont
    Ϊ COM ȡݡʧܣִСȡ󡱷طǿıΪԱ
	*/
	void* _cdecl krnln_DispGetFont (INT nArgCount,MDATA_INF ArgInf,...)
	{
		LPINT pFont = (LPINT)E_MAlloc ((DWORD)(sizeof (INT) * 7));
		PMDATA_INF pArgInf = &ArgInf;
		PEYDISPATCH pDest = (PEYDISPATCH)pArgInf[0].m_pCompoundData;
		if(pDest->pDisp == NULL)
		{
			pDest->hRet = E_POINTER;
			return pFont;
		}
		IFont*pDisp = NULL;
		pDest->hRet = pDest->pDisp->QueryInterface(IID_IFont, (void**) &pDisp);
		if(FAILED(pDest->hRet))
			return pFont;
		pDisp->get_Bold(&pFont[1]);
		pDisp->get_Italic(&pFont[2]);
		pDisp->get_Strikethrough(&pFont[3]);
		pDisp->get_Underline(&pFont[4]);

		CY cySize;
		pDisp->get_Size(&cySize);
		pFont[5]=cySize.Lo/10000;
		BSTR strName=NULL;
		pDisp->get_Name(&strName);
		pDisp->Release();
		if(strName)
		{
			pFont[6]=(INT)Unicode2EASCII(strName);
			SysFreeString(strName);
		}
		

		return pFont;
	}
}
/*
HRESULT hr = S_OK; 
FUNCDESC* pFuncDesc = NULL; 
TYPEATTR* pAttr; 
hr = pTypeInfo->GetTypeAttr(&pAttr); 
if (FAILED(hr)) 
  return hr; 
int i; 
for (i=0;i <pAttr->cFuncs;i++) 
{ 
  hr = pTypeInfo->GetFuncDesc(i, &pFuncDesc); 
  if (FAILED(hr)) 
    return hr; 
  if (pFuncDesc->memid == dispidMember) 
    break; 
  pTypeInfo->ReleaseFuncDesc(pFuncDesc); 
  pFuncDesc = NULL; 
} 
pTypeInfo->ReleaseTypeAttr(pAttr); 

if (pFuncDesc != NULL) 
{ 
#define E_POINTER                        _HRESULT_TYPEDEF_(0x80000005L)
#define E_POINTER                        _HRESULT_TYPEDEF_(0x80004003L)
  // do something 80004003
}
*/

================================================
FILE: krnln/krnln_DoEvents.cpp
================================================
#include "stdafx.h"

// - ¼
/*
    øʽ ޷ֵ ¼  - ϵͳֿ֧->
    ӢƣDoEvents
    ʱתÿȨԱ Windows ϵͳлᴦû̻¼ֱϵͳе¼Ż᷵ءΪм
*/
LIBAPI(void, krnln_DoEvents)
{
	MSG Msg;
	while(PeekMessage(&Msg,NULL,NULL,NULL,PM_NOREMOVE))
	{
		if(Msg.message == WM_QUIT)
			break;
		GetMessage (&Msg, NULL, 0, 0);
		TranslateMessage (&Msg);
		DispatchMessage (&Msg);
	}
}


================================================
FILE: krnln/krnln_FSeek.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
//ļд - ƶдλ
/*
    øʽ ߼͡ ƶдλ  вļţ ʼƶλãݣ ƶ룩 - ϵͳֿ֧->ļд
    ӢƣFSeek
    ڱ򿪵ļУһдλáɹ棬ʧܷؼ١Ϊ
    <1>ΪвļšΪͣintļɡļء
    <2>ΪʼƶλáΪͣintԱʡԡֵָļпʼƶλáΪ³֮һ
	1#ļף 2#ļβ 3#λáʡԣĬֵΪ#ļס
    <3>Ϊƶ롱Ϊͣintֵָʼƶλõƶȡ
*/
LIBAPI(BOOL, krnln_FSeek)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return FALSE;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return FALSE;
	PMDATA_INF pArgInf = &ArgInf;
	BOOL bRet = FALSE;

	if(pFile->nType == 1 || pFile->nType == 3)//ļ ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		DWORD dwMoveMethod;
		switch(pArgInf[1].m_int)
		{
		case 2://#ļβ
			dwMoveMethod = FILE_END;
			break;
		case 3://#λ
			dwMoveMethod = FILE_CURRENT;
			break;
		default://#ļ
			dwMoveMethod = FILE_BEGIN;
		}
		bRet = SetFilePointer(hFile,pArgInf[2].m_int,NULL,dwMoveMethod);

	}else if(pFile->nType ==2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*) pFile->FileHandle;
		DWORD dwMoveMethod;
		switch(pArgInf[1].m_int)
		{
		case 2://#ļβ
			dwMoveMethod = CMyMemFile::end;
			break;
		case 3://#λ
			dwMoveMethod = CMyMemFile::current;
			break;
		default://#ļ
			dwMoveMethod = CMyMemFile::begin;
		}
		
		bRet = (pMemFile->Seek(pArgInf[2].m_int,dwMoveMethod) != -1);

	}
	return bRet;

}


================================================
FILE: krnln/krnln_FileCopy.cpp
================================================
#include "stdafx.h"

//̲ - ļ
/*
    øʽ ߼͡ ļ ı Ƶļı Ƶļ - ϵͳֿ֧->̲
    ӢƣFileCopy
    ɹ棬ʧܷؼ١Ϊ
    <1>ΪƵļΪıͣtext
    <2>ΪƵļΪıͣtext

*/
LIBAPI(BOOL, krnln_FileCopy)
{
	PMDATA_INF pArgInf = &ArgInf;
	return CopyFile(pArgInf[0].m_pText,pArgInf[1].m_pText,FALSE);
}


================================================
FILE: krnln/krnln_FileDateTime.cpp
================================================
#include "stdafx.h"
#include <SHLWAPI.h>
#pragma comment(lib,"SHLWAPI.lib") 
//̲ - ȡļʱ
/*
    øʽ ʱ͡ ȡļʱ ı ļ - ϵͳֿ֧->̲
    ӢƣFileDateTime
    ָļ޸ĺںʱ䡣ļڣ10011աΪ
    <1>ΪļΪıͣtext
	FileTimeToLocalFileTime
	FileTimeToSystemTime 

*/
LIBAPI(void, krnln_FileDateTime) //ֱ޸eaxedxֵָ
{
	WIN32_FIND_DATA FindFileData;
	HANDLE hFind = FindFirstFile(ArgInf.m_pText, &FindFileData);
	ArgInf.m_date =  -657434;//10011
	if (hFind != INVALID_HANDLE_VALUE)
	{
		FindClose(hFind);
		if(FileTimeToLocalFileTime(&FindFileData.ftLastWriteTime,&FindFileData.ftCreationTime))
		{
			SYSTEMTIME now;
			if(FileTimeToSystemTime (&FindFileData.ftCreationTime,&now))
				ArgInf.m_double = GetSpecDateTime(now.wYear, now.wMonth, now.wDay, now.wHour, now.wMinute, now.wSecond);
		}
	}
	__asm{
		mov eax, ArgInf.m_unit.m_dwFormID;
		mov edx, ArgInf.m_unit.m_dwUnitID;
	}
}
// {//ԭ
// 	HANDLE hFile = CreateFile(ArgInf.m_pText,
// 		GENERIC_READ,
// 		FILE_SHARE_READ|FILE_SHARE_WRITE,
// 		NULL,
// 		OPEN_EXISTING,
// 		FILE_ATTRIBUTE_ARCHIVE,
// 		0);
// 
// 	ArgInf.m_date =  -657434;//10011
// 	if(hFile != INVALID_HANDLE_VALUE)
// 	{
// 		FILETIME CreationTime,LastWriteTime;
// 		BOOL bRet = GetFileTime(hFile,&CreationTime,NULL,&LastWriteTime);
// 		CloseHandle(hFile);
// 		if(bRet)
// 		{
// 			if(FileTimeToLocalFileTime(&LastWriteTime,&CreationTime))
// 			{
// 				SYSTEMTIME now;
// 				if(FileTimeToSystemTime (&CreationTime,&now))
// 					ArgInf.m_double = GetSpecDateTime(now.wYear, now.wMonth, now.wDay, now.wHour, now.wMinute, now.wSecond);
// 
// 			}
// 
// 
// 		}
// 
// 	}
// 		
// 
// 	__asm{
// 		mov eax, ArgInf.m_unit.m_dwFormID;
// 		mov edx, ArgInf.m_unit.m_dwUnitID;
// 	}
// }


================================================
FILE: krnln/krnln_FileLen.cpp
================================================
#include "stdafx.h"

//̲ - ȡļߴ
/*
    øʽ ͡ ȡļߴ ı ļ - ϵͳֿ֧->̲
    ӢƣFileLen
    һļijȣλֽڡļڣ -1Ϊ
    <1>ΪļΪıͣtext
*/
LIBAPI(int, krnln_FileLen)
{
	WIN32_FIND_DATA FindFileData;
	HANDLE hFind = FindFirstFile(ArgInf.m_pText, &FindFileData);
	if (hFind != INVALID_HANDLE_VALUE)
	{
		FindClose(hFind);
		if (FindFileData.nFileSizeHigh == 0xFFFFFFFF)
			return -1;
		return FindFileData.nFileSizeLow;
	}
	return -1;
}
// {//ԭ
// 	HANDLE hFile = CreateFile(ArgInf.m_pText,
// 		GENERIC_READ,
// 		FILE_SHARE_READ|FILE_SHARE_WRITE,
// 		NULL,
// 		OPEN_EXISTING,
// 		FILE_ATTRIBUTE_ARCHIVE,
// 		0);
// 
// 	if(hFile == INVALID_HANDLE_VALUE)
// 		return -1;
// 	DWORD FileSizeLow,FileSizeHigh;
// 	FileSizeLow = GetFileSize(hFile,&FileSizeHigh);
// 	CloseHandle(hFile);
// 	if(0xFFFFFFFF == FileSizeHigh)
// 		return -1;
// 	return FileSizeLow;
// }


================================================
FILE: krnln/krnln_FileMove.cpp
================================================
#include "stdafx.h"

//̲ - ƶļ
/*
    øʽ ߼͡ ƶļ ı ƶļı ƶλã - ϵͳֿ֧->̲
    ӢƣFileMove
    ļһλƶһλáɹ棬ʧܷؼ١Ϊ
    <1>ΪƶļΪıͣtext
    <2>ΪƶλáΪıͣtext
*/
LIBAPI(BOOL, krnln_FileMove)
{
	PMDATA_INF pArgInf = &ArgInf;
	BOOL result = MoveFile(pArgInf[0].m_pText,pArgInf[1].m_pText);
	if(!result){
		result = CopyFile(pArgInf[0].m_pText,pArgInf[1].m_pText, 0);
		if (result)
			result = DeleteFile(pArgInf[0].m_pText);

	}
	return result;
}


================================================
FILE: krnln/krnln_GetAllPY.cpp
================================================
#include "StdAfx.h"
#include "mem.h"
#include "Myfunctions.h"

extern char * FindPY(BYTE a1);
extern WORD s_wPYTab [];
extern WORD s_wManyPYTab [];
//ƴ - ȡз
/*
øʽ ı页 ȡз ı ȡƴĺ֣ - ϵͳֿ֧->ƴ
ӢƣGetAllPY
ذָƴı飨ֶ֧֣Ŀǰֹ֧꺺֡صá顱浽ͬΪ
<1>Ϊȡƴĺ֡Ϊıͣtextֻȡıײĵһ֣ıײΪ꺺֣һԱĿΪ 0 Ŀı顣
*/
LIBAPI(LPBYTE, krnln_GetAllPY)
{
	const char *v3; // edx@1
	char v4; // al@3
	WORD v5; // bx@7
	signed int v6; // ecx@10
	char *v7; // edi@10
	char v8; // zf@12
	signed int v9; // ecx@14
	signed int v10; // ecx@14
	unsigned int v11; // ebp@14
	char *v12; // edi@14
	const void *v13; // esi@14
	char v14; // zf@16
	__int16 v15; // bx@19
	signed int v16; // ecx@20
	char *v17; // edi@20
	char v18; // zf@22
	signed int v19; // ecx@24
	signed int v20; // ecx@24
	unsigned int v21; // ebx@24
	char *v22; // edi@24
	const void *v23; // esi@24
	char v24; // zf@26
	char *v25; // eax@29
	int v26; // eax@30
	int v27; // ebx@30
	signed int v28; // ebp@30
	unsigned __int16 v29; // bx@31
	signed int v30; // ecx@33
	char *v31; // edi@33
	char v32; // zf@35
	unsigned int v33; // edx@37
	signed int v34; // ecx@37
	signed int v35; // ecx@37
	char *v36; // edi@37
	const void *v37; // esi@37
	char v38; // zf@39
	__int16 v39; // bx@42
	signed int v40; // ecx@43
	char *v41; // edi@43
	char v42; // zf@45
	signed int v43; // ecx@47
	signed int v44; // ecx@47
	unsigned int v45; // ebx@47
	char *v46; // edi@47
	const void *v47; // esi@47
	char v48; // zf@49
	char *v49; // eax@52
	//unsigned int v51; // edi@53
	//int v52; // eax@53
	char *v53; // [sp+10h] [bp-80h]@30
	CMyDWordArray v54; // [sp+18h] [bp-78h]@1
    //unsigned int v56; // [sp+28h] [bp-68h]@53
	char v57; // [sp+2Ch] [bp-64h]@9
	
	
	
	v3 = ArgInf.m_pText;
	
	if ( v3 )
	{
		
		if ( mystrlen(v3) >= 2 )
		{
			v4 = v3[0];
			//LOBYTE(v3) = v3[1];
			INT ii = v3[1];
			//ii = (ii & 0xFF) | (0xFF & v3[1]);
			//v3 = (char *)ii;
			
			if ( (BYTE)v4 >= 0xB0u )
			{
				if ( (BYTE)v4 <= 0xF7u )
				{
					if ( (BYTE)ii >= 0xA1u )
					{
						if ( (BYTE)ii <= 0xFEu )
						{
							//v3 = (const char *)(unsigned __int8)v3;
							v5 = *((WORD *)&s_wPYTab + (BYTE)ii + 94 * (BYTE)v4 - 16705);
							if ( v5 )
							{
								ii = v5>>8;
								if ( ii & 0x80 )
								{
									v27 = v5 & 0x7FFF;
									v28 = 0;
									v26 = (int)((char *)&s_wManyPYTab + 6 * v27);
									v53 = (char *)&s_wManyPYTab + 6 * v27;
									
									do
									{
										v29 = *(WORD *)v26;
										if ( !*(WORD *)v26 )
											break;
										v57 = 0;
										if ( (BYTE)v29 )
										{
											v31 = FindPY((BYTE)v29);
											v30 = -1;
											do
											{
												if ( !v30 )
													break;
												v32 = *v31++ == 0;
												--v30;
											}
											while ( !v32 );
											v35 = ~v30;
											v37 = &v31[-v35];
											v36 = &v57;
											v33 = v35;
											v34 = -1;
											do
											{
												if ( !v34 )
													break;
												v38 = *v36++ == 0;
												--v34;
											}
											while ( !v38 );
											memcpy(v36 - 1, v37, v33);
										}
										v39 = v29 >> 8;
										if ( (BYTE)v39 )
										{
											v41 = FindPY((BYTE)v39);
											v40 = -1;
											do
											{
												if ( !v40 )
													break;
												v42 = *v41++ == 0;
												--v40;
											}
											while ( !v42 );
											v44 = ~v40;
											v47 = &v41[-v44];
											v45 = v44;
											v46 = &v57;
											v43 = -1;
											do
											{
												if ( !v43 )
													break;
												v48 = *v46++ == 0;
												--v43;
											}
											while ( !v48 );
											memcpy(v46 - 1, v47, v45);
										}
										v49 = CloneTextData(&v57);
										//CFreqMem__AddDWord(&v54, v49);
										v54.AddDWord((DWORD)v49);
										++v28;
										v26 = (int)(v53 + 2);
										v53 += 2;
									}
									while ( v28 < 3 );
								}
								else
								{
									v57 = 0;
									if ( (BYTE)v5 )
									{
										v7 = FindPY((BYTE)v5);
										v6 = -1;
										do
										{
											if ( !v6 )
												break;
											v8 = *v7++ == 0;
											--v6;
										}
										while ( !v8 );
										v10 = ~v6;
										v13 = &v7[-v10];
										v11 = v10;
										v12 = &v57;
										v9 = -1;
										do
										{
											if ( !v9 )
												break;
											v14 = *v12++ == 0;
											--v9;
										}
										while ( !v14 );
										memcpy(v12 - 1, v13, v11);
									}
									v15 = v5 >> 8;
									if ( (BYTE)v15 )
									{
										v17 = FindPY((BYTE)v15);
										v16 = -1;
										do
										{
											if ( !v16 )
												break;
											v18 = *v17++ == 0;
											--v16;
										}
										while ( !v18 );
										v20 = ~v16;
										v23 = &v17[-v20];
										v21 = v20;
										v22 = &v57;
										v19 = -1;
										do
										{
											if ( !v19 )
												break;
											v24 = *v22++ == 0;
											--v19;
										}
										while ( !v24 );
										memcpy(v22 - 1, v23, v21);
									}
									v25 = CloneTextData(&v57);
									//CFreqMem__AddDWord(&v54, v25);
									v54.AddDWord((DWORD)v25);
								}
              }
            }
          }
        }
      }
    }
  }
  /*
  v51 = 4 * (v56 >> 2);
  v52 = krnl_MMalloc(v51 + 8, v3);
  *(DWORD *)v52 = 1;
  *(DWORD *)(v52 + 4) = v56 >> 2;
  memcpy((void *)(v52 + 8), (const void *)(v56 != 0 ? v55 : 0), v51);*/
  //v54 = &CFreqMem___vftable_;
  // ±ݡ
  
  INT nSize = v54.GetDWordCount () * sizeof (DWORD);
  LPBYTE p = (LPBYTE)E_MAlloc_Nzero (sizeof (INT) * 2 + nSize);
  *(LPINT)p = 1;  // ά
  *(LPINT)(p + sizeof (INT)) = v54.GetDWordCount ();
  memcpy (p + sizeof (INT) * 2, v54.GetPtr (), nSize);
  
  //*(DWORD *)a1 = v52;
  return p;
  
}

//ƴ - ȡз
/*
øʽ ͡ ȡĿ ı ȡ䷢Ŀĺ֣ - ϵͳֿ֧->ƴ
ӢƣGetPYCount
ֵָķĿΪ
<1>Ϊȡ䷢Ŀĺ֡Ϊıͣtextֻȡıײĵһ֣ıײΪ꺺֣ 0
*/
LIBAPI(int, krnln_GetPYCount)
{
	int v3; // eax@1
	int v4; // edx@1
	int v5; // esi@1
	unsigned __int8 v6; // dl@3
	unsigned __int8 v8; // [sp+8h] [bp+4h]@3
	unsigned __int8 v9; // [sp+10h] [bp+Ch]@3
	
	PMDATA_INF a3 = &ArgInf;
	//  LOBYTE(v3) = a3;
	v5 = 0;
	v4 = (INT)a3->m_pText;
	if ( v4 )
	{
		//    LOBYTE(v3) = 0;
		if ( mystrlen((const char *)v4) >= 2 )
		{
			//LOBYTE(v3) = *(BYTE *)v4;
			v3 = *(BYTE *)v4;
			v6 = *(BYTE *)(v4 + 1);
			v8 = v3;
			v9 = v6;
			if ( (BYTE)v3 >= 0xB0u )
			{
				if ( (BYTE)v3 <= 0xF7u )
				{
					if ( v6 >= 0xA1u )
					{
						if ( v6 <= 0xFEu )
						{
							//LOWORD(v3) = *((WORD *)&s_wPYTab + v9 + 94 * v8 - 16705);
							v3 =  *((WORD *)&s_wPYTab + v9 + 94 * v8 - 16705);
							if (v3 )
							{
								INT ii = v3>>8;
								if ( ii & 0x80 )
								{
									v3 &= 0x7FFFu;
									v5 = (*((WORD *)&s_wManyPYTab + 3 * v3 + 2) != 0) + 2;
								}
								else
								{
									v5 = 1;
								}
							}
						}
					}
				}
			}
		}
	}
	return v5;
}

char *__cdecl GetPY(PMDATA_INF a1, int a2, const char **a3, int a4)
{
	const char *v4; // edx@1
	PMDATA_INF v5; // esi@1
	char v6; // al@3
	char v7; // dl@3
	int v8; // ecx@7
	unsigned __int16 v9; // bx@7
	signed int v10; // ecx@16
	char *v11; // edi@16
	char v12; // zf@18
	unsigned int v13; // edx@20
	signed int v14; // ecx@20
	signed int v15; // ecx@20
	char *v16; // edi@20
	const void *v17; // esi@20
	char v18; // zf@22
	__int16 v19; // bx@25
	signed int v20; // ecx@27
	char *v21; // edi@27
	char v22; // zf@29
	signed int v23; // ecx@31
	signed int v24; // ecx@31
	unsigned int v25; // ebx@31
	char *v26; // edi@31
	const void *v27; // esi@31
	char v28; // zf@33
	char *result; // eax@36
	char v30[128]; // [sp+14h] [bp-64h]@1//ջڴܴ
	char v31; // [sp+84h] [bp+Ch]@3
	
	v5 = (PMDATA_INF )a3;
	v30[0] = 0;//
	v4 = *a3;
	if ( *a3 )
	{
		if ( mystrlen(*a3) >= 2 )
		{
			v6 = *v4;
			v7 = v4[1];
			v31 = v6;
			if ( (unsigned __int8)v6 >= 0xB0u )
			{
				if ( (unsigned __int8)v6 <= 0xF7u )
				{
					if ( (unsigned __int8)v7 >= 0xA1u )
					{
						if ( (unsigned __int8)v7 <= 0xFEu )
						{
							v8 = (*((DWORD *)v5 + 3) - 1) & ((*((DWORD *)v5 + 3) - 1 < 0) - 1);
							v9 = *((WORD *)&s_wPYTab + (unsigned __int8)v7 + 94 * (unsigned __int8)v31 - 16705);
							if ( v9 )
							{
								INT ii = v9 >> 8;
								if ( ii & 0x80 )
								{
									if ( v8 >= 3 )
										goto LABEL_36;
									v9 = *((WORD *)&s_wManyPYTab + v8 + 2 * (v9 & 0x7FFF) + (v9 & 0x7FFF));
								}
								else
								{
									if ( v8 )
										goto LABEL_36;
								}
								if ( v9 )
								{
									if ( (BYTE)v9 )
									{
										if ( a4 != 2 )
										{
											v11 = FindPY((BYTE)v9);
											v10 = -1;
											do
											{
												if ( !v10 )
													break;
												v12 = *v11++ == 0;
												--v10;
											}
											while ( !v12 );
											v15 = ~v10;
											v17 = &v11[-v15];
											v16 = v30;//
											v13 = v15;
											v14 = -1;
											do
											{
												if ( !v14 )
													break;
												v18 = *v16++ == 0;
												--v14;
											}
											while ( !v18 );
											memcpy(v16 - 1, v17, v13);
										}
									}
									v19 = v9 >> 8;
									if ( (BYTE)v19 )
									{
										if ( a4 != 1 )
										{
											v21 = FindPY((BYTE)v19);
											v20 = -1;
											do
											{
												if ( !v20 )
													break;
												v22 = *v21++ == 0;
												--v20;
											}
											while ( !v22 );
											v24 = ~v20;
											v27 = &v21[-v24];
											v25 = v24;
											v26 = v30;//
											v23 = -1;
											do
											{
												if ( !v23 )
													break;
												v28 = *v26++ == 0;
												--v23;
											}
											while ( !v28 );
											memcpy(v26 - 1, v27, v25);
										}
									}
								}
							}
						}
					}
				}
			}
		}
	}
LABEL_36:
	result = CloneTextData(v30);//
	a1->m_pText = result;
	return result;
}
//ƴ - ȡƴ
/*
øʽ ı͡ ȡƴ ı ȡƴĺ֣ ȡƴ - ϵͳֿ֧->ƴ
ӢƣGetPY
ذֵָָƴıָƴ벻ڣؿıĿǰֹ֧꺺ֵ֡ĵһΪΪ
<1>Ϊȡƴĺ֡Ϊıͣtextֻȡıײĵһ֣ıײΪ꺺֣һı
<2>ΪȡƴΪͣintʼֵΪ1Ӧ 1 úֵķĿ֮䡣ֵķĿʹáȡĿȡá
*/
LIBAPI(char*, krnln_GetPY)
{
	MDATA_INF ret;
	return GetPY(&ret, nArgCount, (const char **)&ArgInf, 0);
	
}
//ƴ - ȡĸ
/*
øʽ ı͡ ȡĸ ı ȡƴĺ֣ ȡƴ - ϵͳֿ֧->ƴ
ӢƣGetSM
ذָָƴĸıָƴ벻ڻúִ˷ĸؿıĿǰֹ֧꺺֡Ϊ
<1>Ϊȡƴĺ֡Ϊıͣtextֻȡıײĵһ֣ıײΪ꺺֣һı
<2>ΪȡƴΪͣintʼֵΪ1Ӧ 1 úֵķĿ֮䡣ֵķĿʹáȡĿȡá
*/
LIBAPI(char*, krnln_GetSM)
{
	MDATA_INF ret;
	return GetPY(&ret, nArgCount, (const char **)&ArgInf, 1);
	
}
//ƴ - ȡĸ
/*
øʽ ı͡ ȡĸ ı ȡƴĺ֣ ȡƴ - ϵͳֿ֧->ƴ
ӢƣGetYM
ذָָƴĸıָƴ벻ڣؿıĿǰֹ֧꺺֡Ϊ
<1>Ϊȡƴĺ֡Ϊıͣtextֻȡıײĵһ֣ıײΪ꺺֣һı
<2>ΪȡƴΪͣintʼֵΪ1Ӧ 1 úֵķĿ֮䡣ֵķĿʹáȡĿȡá
*/
LIBAPI(char*, krnln_GetYM)
{
	MDATA_INF ret;
	return GetPY(&ret, nArgCount, (const char **)&ArgInf, 2);
	
}

unsigned char __cdecl ConvertNanFangPY(unsigned char a1, unsigned char a2, int a);
//ƴ - Ƚ
/*
øʽ ߼͡ Ƚ ı Ƚıһı Ƚı߼ Ƿ֧Ϸ߼ ǷΪģȽϣݣ - ϵͳֿ֧->ƴ
ӢƣCompPY
Ƚıķͬ棬򷵻ؼ١ıеķǹ꺺ֲ֣м򵥵ֵȽϡΪ
<1>ΪȽıһΪıͣtext
<2>ΪȽıΪıͣtext
<3>ΪǷ֧ϷΪ߼ͣboolʼֵΪ桱Ϊ֧Ϸ֧ϷȽʱΪķͬ磺 n  l z  zh ie  ue ȵȡ
<4>ΪǷΪģȽϡΪ߼ͣboolԱʡԡΪʱȽıһķڴȽıײʱΪȽͨʡԣĬֵΪ١
*/
LIBAPI(BOOL, krnln_CompPY)
{
	int v3; // ebx@1
	int v4; // ebp@1
	int v5; // esi@2
	int v6; // eax@4
	unsigned int v7; // edx@4
	unsigned int v8; // ecx@4
	char v9; // cl@10
	unsigned __int8 v10; // dl@14
	unsigned __int8 v11; // cl@15
	signed int v12; // ebp@26
	signed int v13; // edi@27
	unsigned __int8 v14; // al@28
	int v15; // edx@28
	__int16 v16; // bx@30
	unsigned __int16 v17; // cx@32
	unsigned __int16 v18; // si@32
	unsigned __int8 v19; // al@32
	int v20; // edx@34
	int *v21; // ecx@35
	char *v22; // eax@40
	int v23; // ebx@40
	unsigned int v24; // ebp@41
	int *v25; // esi@41
	__int16 v26; // bx@42
	__int16 v27; // dx@43
	signed int v28; // ebx@45
	char *v29; // edi@45
	__int16 v30; // si@46
	int v31; // edx@47
	__int16 v32; // ax@48
	int *v33; // ecx@48
	int v35; // [sp+10h] [bp-2Ch]@8
	int v36; // [sp+14h] [bp-28h]@9
	int v37; // [sp+18h] [bp-24h]@1
	char v38; // [sp+1Ch] [bp-20h]@10
	signed int v39; // [sp+20h] [bp-1Ch]@26
	signed int v40; // [sp+24h] [bp-18h]@26
	char v41; // [sp+28h] [bp-14h]@10
	unsigned __int8 v42; // [sp+2Ch] [bp-10h]@18
	unsigned __int8 v43; // [sp+30h] [bp-Ch]@18
	int v44[20]; // [sp+34h] [bp-8h]@33
	unsigned __int8 v45; // [sp+48h] [bp+Ch]@32 ջܴ
	unsigned __int8 v46; // [sp+48h] [bp+Ch]@43
	
	INT a2 = nArgCount;
	PMDATA_INF a3 = &ArgInf;
	v4 = a3->m_int;
	v3 = a3[1].m_int;
	v37 = a3[2].m_int;
	if ( a3[3].m_dtDataType )
		v5 = a3[3].m_bool;
	else
		v5 = 0;
	v6 = 0;
	v7 = mystrlen((const char *)v4)-1;
	v8 = mystrlen((const char *)v3)-1;
	if ( v5 == 1 )
		//LOBYTE(v6) = (signed int)v7 <= (signed int)v8;
		v6 =(BYTE)(signed int)v7 <= (signed int)v8;
	else
		v6 = v7 == v8;
	if ( v6 )
	{
		v35 =  a3->m_int;
		
		while ( 1 )
		{
			v6 =(BYTE) *(BYTE *)v4;
			v36 = v3;
			if ( !*(BYTE *)v4 )
				break;
			v9 = *(BYTE *)v3;
			v41 = *(BYTE *)v4;
			v38 = *(BYTE *)v3;
			if ( v6 & 0x80 )
			{
				if ( !(v9 & 0x80) || (v10 = *(BYTE *)(v4 + 1), !v10) || (v11 = *(BYTE *)(v3 + 1), !v11) )
					return v6;
				
				if ( *(WORD *)v4 == *(WORD *)v3 )
				{
					v4 += 2;
					v3 += 2;
					v35 = v4;
				}
				else
				{
					v42 = *(BYTE *)(v4 + 1);
					v43 = *(BYTE *)(v3 + 1);
					if ( (BYTE)v6 < 0xB0u
						|| (BYTE)v6 > 0xF7u
						|| v10 < 0xA1u
						|| v10 > 0xFEu
						|| (v6 = *(BYTE *)v3, (unsigned __int8)v38 < 0xB0u)
						|| (unsigned __int8)v38 > 0xF7u
						|| v11 < 0xA1u
						|| v11 > 0xFEu )
						return v6;
					
					v12 = 0;
					v40 = 0;
					v39 = 0;
					do
					{
						v13 = 0;
						if ( v12 )
						{
							v15 = 47 * (unsigned __int8)v38;
							v14 = v43;
						}
						else
						{
							v15 = 47 * (unsigned __int8)v41;
							v14 = v42;
						}
						v16 = *((WORD *)&s_wPYTab + v14 + 2 * v15 - 16705);
						if ( !v16 )
							break;
						INT ii = v16>>8;
						if ( ii & 0x80 )
						{
							v23 = v16 & 0x7FFF;
							v22 = (char *)&s_wManyPYTab + 6 * v23;
							if ( v12 )
							{
								v28 = 0;
								v29 = v22;
								while ( 1 )
								{
									v30 = *(WORD *)v29;
									if ( !*(WORD *)v29 )
										break;
									v31 = 0;
									if ( (WORD)v44[0] )
									{
										v32 = v44[0];//
										v33 = v44;//
										do
										{
											if ( v32 == v30 )
												break;
											v32 = *((WORD *)v33 + 1);
											v33 = (int *)((char *)v33 + 2);
											++v31;
										}
										while ( v32 );
									}
									if ( *((WORD *)v44 + v31) != v30 )//&V44
									{
										++v28;
										v29 += 2;
										if ( v28 < 3 )
											continue;
									}
									goto LABEL_55;
								}
								v40 = 1;
							}
							else
							{
								v25 = v44;//
								v24 = (UINT)((char *)&s_wManyPYTab + 6 * v23) - (UINT)v44;//&V44
								do
								{
									v26 = *(WORD *)((char *)v25 + v24);
									if ( !v26 )
										break;
									v46 = ConvertNanFangPY((unsigned char)v26, 0, v37);
									//HIBYTE(v27) = ConvertNanFangPY(HIBYTE(v26), v46, v37);
									//++v13;
									//LOBYTE(v27) = v46; //˴
									
									ii = v26 >>8;
									ii = ConvertNanFangPY(ii, v46, v37);
									++v13;
									v27 = MAKEWORD(v46,ii);
									
									*(WORD *)v25 = v27;
									v25 = (int *)((char *)v25 + 2);
								}
								while ( v13 < 3 );
								v12 = v39;
								*((WORD *)v44 + v13) = 0;//&V44
							}
						}
						else
						{
							v19 = ConvertNanFangPY((unsigned char)v16, 0, v37);
							v45 = v19;
							//LOBYTE(v6) = ConvertNanFangPY(HIBYTE(v16), v19, v37);
							//HIBYTE(v17) = v6;
							// LOBYTE(v17) = v45;//˴
							ii = v16 >>8;
							v6 = (BYTE)ConvertNanFangPY(ii, v19, v37);
							v17 = MAKEWORD(v45,v6);
							v18 = v17;
							if ( v12 )
							{
								v20 = 0;
								if ( (WORD)v44[0] )//&V44
								{
									v6 = (WORD)v44[0];//&V44
									v21 = v44;//
									do
									{
										if ( v6 == v18 )
											break;
										v6 = *((WORD *)v21 + 1);
										v21 = (int *)((char *)v21 + 2);
										++v20;
									}
									while ( v6 );
								}
								if ( *((WORD *)v44 + v20) != v18 )//&V44
									return v6;
							}
							else
							{
								v44[0] = v17;//
							}
						}
LABEL_55:
						++v12;
						v39 = v12;
          }
          while ( v12 <= 1 );
          v6 = (BYTE)v40;
          if ( v40 )
			  return v6;
          v4 = v35 + 2;
          v3 = v36 + 2;
          v35 += 2;
        }
      }
      else
      {
		  if ( v6 != v9 )
			  return v6;
		  ++v4;
		  ++v3;
		  v35 = v4;
      }
    }
    //v6 = (BYTE)a1;
    //*(DWORD *)a1 = 1;
	
	v6=1;
  }
  return v6;
  
}
//int ComparePYQuickStr(char *,CMyDWordArray &,int,int);
extern "C" {
	int __stdcall ComparePYQuickStr(char *a1, CMyDWordArray* a2, int a3);

	int __stdcall PrepareComparePYQuickStr(char *a1, CMyDWordArray* a2, int a3, int a4);
}
//int PrepareComparePYQuickStr(char *,CMyDWordArray &,CFreqMem *,int,unsigned char,int);
//ƴ - ֱȽ 
/*
øʽ ߼͡ ֱȽ ı Ƚƴ֣ı Ƚͨı߼ Ƿ֧Ϸ ƴݣ - ϵͳֿ֧->ƴ
ӢƣCompPYCode
һƴıһͨıȽϣ棬򷵻ؼ١Ϊ
<1>ΪȽƴ֡Ϊıͣtextƴࣺ
һƴȫƴࣺ 磺jsjƥ䡰ͬʱjisuanjiҲƥ䡰ϵͳԶб־ƴʽȫƴʽ
˫ƴࣺ 磺jisrjiƥ䡰˫ƴķ Windows ϵͳµ˫ƴ뷨һ£
Զбࣺ ʹôƴֵײһַб𣺷ֺ (;) ƴȫƴ࣬ð (:) ˫ƴ࣬ȲΪֺҲΪðţĬΪƴȫƴࡣ硰jsj;jsj;jisuanji:jisrjiƥ䡰
дƴʱһЩ
һΪƥĿıеĴСдӢĸӦλôʹöӦĴдӢĸ磺jsjAƥ䡰aA
ΪƥĿıеİ֣Ӧλôʹø֡磺jsj1ƥ䡰1
ΪƥĿıеĺַŻ֪ĺ֣Ӧλôʹøú֡磺jj1ƥ䡰1
ġƴڲܰˡ_Ƿš
<2>ΪȽͨıΪıͣtext
<3>ΪǷ֧ϷΪ߼ͣboolʼֵΪ桱Ϊ֧Ϸ֧ϷȽʱΪķͬ磺 n  l z  zh ie  ue ȵȡ
<4>Ϊƴ𡱣ΪͣintԱʡԡֵΪ³֮һ 1#ƴȫƴ 2#˫ƴ 3#Զб ʡԱĬΪ#Զб𡱡
*/
LIBAPI(BOOL, krnln_CompPYCode)
{
	int v3; // eax@1
	int v4; // ecx@1
	int v5; // ebx@1
	int v6; // edi@1
	int v7; // edx@1
	signed int v8; // esi@2
	signed int v9; // eax@3
	char result; // al@9
	unsigned int v11; // esi@16
	int v12; // eax@16
	signed int i; // edi@19
	int v14; // ecx@20
	CMyDWordArray* v15; // [sp+10h] [bp-14h]@16
	int v16; // [sp+18h] [bp-Ch]@20
	unsigned int v17; // [sp+20h] [bp-4h]@16
	int v18; // [sp+30h] [bp+Ch]@1
	int a1 = 0;
	int a3 =(int)&ArgInf;
	
	v3 = a3;
	v7 = *(DWORD *)(a3 + 44);
	v4 = *(DWORD *)(a3 + 12);
	v5 = *(DWORD *)(a3 + 24);
	v6 = *(DWORD *)a3;
	v18 = *(DWORD *)(a3 + 12);
	
	if ( !v7 )
	{
		v8 = 3;
		goto LABEL_9;
	}
	v9 = *(DWORD *)(v3 + 36);
	if ( v9 > 3 )
		goto LABEL_29;
	if ( v9 < 1 )
	{
		v8 = 1;
		goto LABEL_9;
	}
	if ( v9 <= 3 )
		v8 = v9;
	else
LABEL_29:
	v8 = 3;
LABEL_9:
	a1 = 0;
	result = *(BYTE *)v6;
	if ( *(BYTE *)v6 )
	{
		if ( *(BYTE *)v4 )
		{
			if ( v8 == 3 )
			{
				v8 = 1;
				if ( result == 59 )
				{
					++v6;
				}
				else
				{
					if ( result == 58 )
					{
						++v6;
						v8 = 2;
					}
				}
			}
			//v12 = CFreqMem__CFreqMem(&v15);
			v15 = new CMyDWordArray();
			
			//LOBYTE(v12) = v8 == 1;
			//v15 = &CMyDWordArray___vftable_;
			
			v12 = v8 == 1;
			PrepareComparePYQuickStr((char*)v6, v15, v12 + 58, v5);
			DWORD* pv15 =(DWORD*)v15;
			v16 =(INT)pv15[2];
			v17 =pv15[4];
			v11 = (v17 >> 2) - 1;
			if ( (signed int)((v17 >> 2) - 1) >= 0 )
			{
				if ( ComparePYQuickStr((char*)v18, v15, v5) == 1 )
					a1 = 1;
			}
			//char txt [50];


			for ( i = 0; i <= (int)v11; ++i )
			{
				
				v14 = *(DWORD *)(v16 + 4 * i);
	
				//DWORD dwAddrr = *(DWORD*)v15->GetAt(i);
				//itoa(dwAddrr,txt,16);
				//if(::IsBadCodePtr ((int (__stdcall *)(void))dwAddrr))
					//MessageBox(NULL,txt,"Arr",MB_OK);

				if ( v14 ){
					_asm {
						push ecx;
						push edx;
						mov ecx,v14;
						mov edx, [ecx]
						push 1;
						call [edx];
						pop edx;
						pop ecx;
					}
					/*_asm mov ecx,eax;//һҪECXֵ
					(**(void (__stdcall ***)(DWORD))v14)(1);*/
				}

			}
			v15->Free();
			delete v15;
			return a1;
		}
		if ( result )
			return result;
	}
	if ( !*(BYTE *)v4 )
		a1 = 1;
	return a1;
	
	
}

================================================
FILE: krnln/krnln_GetAttr.cpp
================================================
#include "stdafx.h"

//̲ - ȡļ
/*
    øʽ ͡ ȡļ ı ļ - ϵͳֿ֧->̲
    ӢƣGetAttr
    һļĿ¼ԡֵ³͹ɣ 1#ֻļ 2#ļ  4#ϵͳļ 16#Ŀ¼32#浵ļ ҪжǷijԣڷֵҪֵ֪֮ʹáλ롱бȽϡõĽΪ㣬ʾֵȡļʧܣ -1Ϊ
    <1>ΪļΪıͣtext
*/
LIBAPI(int, krnln_GetAttr)
{
	return GetFileAttributes(ArgInf.m_pText);
}


================================================
FILE: krnln/krnln_GetBackColor.cpp
================================================
#include "stdafx.h"

//ϵͳ - ȡĬϵɫ
/*
    øʽ ͡ ȡĬϵɫ  - ϵͳֿ֧->ϵͳ
    ӢƣGetBackColor
    ȡWindowsϵͳĬϴڱɫΪ
*/
LIBAPI(int, krnln_GetBackColor)
{
	return GetSysColor(0xF);
}


================================================
FILE: krnln/krnln_GetBinElement.cpp
================================================
#include "stdafx.h"
#include "mem.h"
#include "Myfunctions.h"

//ֽڼ - ȡֽڼ
/*
    øʽ ͨ͡ ȡֽڼ ֽڼ ȡݵֽڼ ȡݵͣ ʼλãݣ - ϵͳֿ֧->ֽڼ
    ӢƣGetBinElement
    ȡֽڼָλָ͵ݡΪ
    <1>ΪȡݵֽڼΪֽڼbin
    <2>Ϊȡݵ͡ΪͣintֵΪ³ 1#ֽͣ 2#ͣ 3#ͣ 4#ͣ 5#Сͣ 6#˫Сͣ 7#߼ͣ 8#ʱͣ 9#ӳָͣ 10#ı͡תݽԶЧУ鼰ת
    <3>ΪʼλáΪͣintԱʡԡָֽڼʲôطʼȡݣֵ1ʼʡԣĬΪֵ1ΪṩһͱִкԶ޸ĸñݣֵƶһλáƶ󵽴ֽڼĩβ޸ĸñΪ-1
*/
// 
void SetMDataValue (PMDATA_INF pRetData, LPBYTE pData, INT nDataSize)
{
	switch (pRetData->m_dtDataType)
	{
	case SDT_BYTE:
		pRetData->m_byte = *pData;
		break;
	case SDT_SHORT:
		pRetData->m_short = *(SHORT*)pData;
		break;
	case SDT_INT:
		pRetData->m_int = *(INT*)pData;
		break;
	case SDT_INT64:
		pRetData->m_int64 = *(INT64*)pData;
		break;
	case SDT_FLOAT:
		pRetData->m_float = *(FLOAT*)pData;
		break;
	case SDT_DOUBLE:
		pRetData->m_double = *(DOUBLE*)pData;
		break;
	case SDT_BOOL:
		pRetData->m_bool = (*(BOOL*)pData != FALSE);
		break;
	case SDT_DATE_TIME:
		pRetData->m_date = *(DATE*)pData;//max (MIN_DATE, min (MAX_DATE, *(DATE*)pData));
		break;
	case SDT_SUB_PTR:
		pRetData->m_dwSubCodeAdr = *(LPDWORD)pData;
		break;
	case SDT_TEXT: {
		INT nEndPos = FindByte (pData, nDataSize, 0);
		pRetData->m_pText = CloneTextData ((char*)pData,
			(nEndPos != -1 ? nEndPos : nDataSize));
		
		break; }
	case SDT_BIN:
		pRetData->m_pBin = CloneBinData (pData, nDataSize);
		break;
//		DEFAULT_FAILD;
	}
}

LIBAPI(void, krnln_GetBinElement) // ֱ޸eax,edx,ecxԲҪֵָ
{
	PMDATA_INF pArgInf = &ArgInf;

	INT nType = pArgInf [1].m_int;
	if (nType < 1 || nType > 10)
		E_ReportError(100,0,0);

	//!!! Ϊ _SDT_ALL ݣ
	// pRetData->m_dtDataType Ϊݵ DATA_TYPE 
	MDATA_INF RetData;
	memset(&RetData,0,sizeof(MDATA_INF));
	RetData.m_dtDataType =
		nType == 1 ? SDT_BYTE :
	nType == 2 ? SDT_SHORT :
	nType == 3 ? SDT_INT :
	nType == 4 ? SDT_INT64 :
	nType == 5 ? SDT_FLOAT :
	nType == 6 ? SDT_DOUBLE :
	nType == 7 ? SDT_BOOL :
	nType == 8 ? SDT_DATE_TIME :
	nType == 9 ? SDT_SUB_PTR :
	SDT_TEXT;

	if(pArgInf [0].m_pBin==NULL) 
	{
		__asm{
			mov eax, RetData.m_unit.m_dwFormID;
			mov edx, RetData.m_unit.m_dwUnitID;
			mov ecx, RetData.m_dtDataType;
		}
		return;
	}


	LPBYTE pData = pArgInf [0].m_pBin + sizeof (INT) * 2;
	INT nDataSize = *(LPINT)(pData - sizeof (INT)); //ֽڼ
	

	INT nOffset;
	LPINT pOffset = NULL;
	if(pArgInf[2].m_dtDataType == _SDT_NULL)
		nOffset = 0;
	else
	{
		if(pArgInf[2].m_dtDataType == VAR_INT)//DZ
		{
			nOffset = *pArgInf[2].m_pInt - 1;
			pOffset = pArgInf[2].m_pInt;

		}
		else
			nOffset = pArgInf[2].m_int - 1;

	}



	INT nNeedSize = GetSysDataTypeDataSize (RetData.m_dtDataType);
	pData += nOffset;
	nDataSize -= nOffset;
	if(nOffset < 0 || nDataSize <=0)
	{
		if(pOffset)*pOffset = -1;
		goto end;
	}
	
	DWORD dwbuf [2];
	
	if (nType != 10 && nDataSize < nNeedSize)
	{
		ASSERT (nDataSize < sizeof (dwbuf));
		dwbuf [0] = dwbuf [1] = 0;
		memcpy (dwbuf, pData, nDataSize);
		pData = (LPBYTE)dwbuf;
		nDataSize = nNeedSize;
	}
	SetMDataValue (&RetData, pData, nDataSize);
	if(pOffset)
	{
		if(nType == 10){
			if(RetData.m_pText)
				*pOffset+=(mystrlen(RetData.m_pText)+1);
			else
				*pOffset+=1;//strlenȡıָNULLʱ
		}else
			*pOffset+=nNeedSize;
		if(*pOffset > pArgInf [0].m_pInt[1])
			*pOffset = -1;//ݳ
	}

end:
	__asm{
		mov eax, RetData.m_unit.m_dwFormID;
		mov edx, RetData.m_unit.m_dwUnitID;
		mov ecx, RetData.m_dtDataType;
	}
}


================================================
FILE: krnln/krnln_GetBinRegItem.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

#pragma comment(lib,"advapi32.lib") 
//ϵͳ - ȡֽڼע
/*
    øʽ ֽڼ ȡֽڼע  Ŀ¼ı ȫ·עֽڼ Ĭֽڼݣ - ϵͳֿ֧->ϵͳ
    ӢƣGetBinRegItem
     Windows עзָֽڼעֵȡעĬֵĿӡ\ţ硰test\롰ȡֽڼעͬDZȡλôעΪм
    <1>ΪĿ¼ΪͣintΪ³ֵ֮һ 1#ࣻ 2#ã 3#û 4#ػ 5#û
    <2>Ϊȫ·עΪıͣtext
    <3>ΪĬֽڼΪֽڼbinԱʡԡָעڣشĬֽڼָעұʡԣؿֽڼ
*/
LIBAPI(void*, krnln_GetBinRegItem)
{
	PMDATA_INF pArgInf = &ArgInf;
	HKEY hRootkey = GetRegRootVal(pArgInf[0].m_int);
	LPBYTE pBin = NULL;
	INT nLen = mystrlen(pArgInf[1].m_pText);
	if(hRootkey && nLen)
	{
		HKEY hkey;
		LPSTR pSubkey = new char [nLen +1];
		strcpy(pSubkey,pArgInf[1].m_pText);
		LPSTR pKeyname = strrchr(pSubkey,'\\');
		if(pKeyname)
		{
			*pKeyname = 0;
			pKeyname++;
		}
		if(RegOpenKey(hRootkey,pSubkey,&hkey)==ERROR_SUCCESS)
		{
		
			DWORD nLen = 1024;
			DWORD dwType = REG_BINARY;
			INT nRet;
			LPBYTE pData;
			do
			{
				pData = new BYTE[nLen];

				nRet = RegQueryValueEx(hkey,pKeyname,NULL,&dwType,pData,&nLen);
				if(nRet == ERROR_SUCCESS)
				{
					if(dwType == REG_BINARY)
						pBin = CloneBinData(pData,nLen);
					break;

				}else if (nRet == ERROR_MORE_DATA)
				{
					delete [] pData;

				}else
					break;

			}while(1);

			delete [] pData;

			RegCloseKey(hkey);


		}
		delete [] pSubkey;
	}

	if(pBin == NULL && pArgInf[2].m_dtDataType != _SDT_NULL && pArgInf[2].m_pBin)
	{
		pBin = CloneBinData(pArgInf[2].m_pBin+2*sizeof(INT),pArgInf[2].m_pInt[1]);
	}
	return pBin;
}


================================================
FILE: krnln/krnln_GetClipBoardText.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
//ϵͳ - ȡı
/*
    øʽ ı͡ ȡı  - ϵͳֿ֧->ϵͳ
    ӢƣGetClipBoardText
    شڵǰ Windows ϵͳеıǰıݣؿıΪ
*/
LIBAPI(char*, krnln_GetClipBoardText)
{

	char* pText = NULL;
	if(OpenClipboard(NULL))
	{
		HANDLE hClip =  GetClipboardData(CF_TEXT);
		if(hClip)
		{
			LPSTR pStr = (LPSTR)GlobalLock(hClip);
			pText = CloneTextData(pStr,mystrlen(pStr));
			GlobalUnlock(hClip);
		}
		CloseClipboard();
	}
	return pText;
}


================================================
FILE: krnln/krnln_GetCmdLine.cpp
================================================
#include "stdafx.h"
#include "mem.h"

#pragma comment(lib,"shell32.lib") 

//ȡ - ȡ
/*
    øʽ ޷ֵ ȡ ıͱ űȡı - ϵͳֿ֧->ȡ
    ӢƣGetCmdLine
    ȡ׳ʱִļԿոָıΡΪ
    <1>ΪűȡıΪıͣtextṩʱֻṩ顣ִϺ󣬱ڱ˳׳ʱִļԿոָıΡԭݱȫ٣άԶΪı
*/
/*
char* BMUnicodeToAnsi(LPWSTR lpWstr)
{
	INT nLen = WideCharToMultiByte(0, 0, lpWstr, -1, NULL, NULL, 0, 0);
	if(nLen==0)return NULL;
	char* pText = (char*)E_MAlloc(nLen +1);
	WideCharToMultiByte (0, 0, lpWstr, -1,pText, nLen, 0, 0);
	return pText;

}
*/
#define IS_CC(p) p<0

LIBAPI(void, krnln_GetCmdLine)
{
	LPWSTR *szArglist;
	int nArgs, i;
	int al;
	char *pSrc;
	LPSTR p;
	CMyDWordArray aryText;

	szArglist = CommandLineToArgvW(GetCommandLineW(), &nArgs);
	if (szArglist)
	{
		for (i=1; i<nArgs; i++)
		{
			//UNICDOEתANSI
			al = WideCharToMultiByte(936, NULL, szArglist[i], -1, NULL, NULL, NULL, NULL);
			pSrc = NULL;
			if (al > 0)
			{
				pSrc = (char*)E_MAlloc_Nzero(al + 1);
				if (pSrc)
				{
					al = WideCharToMultiByte(936, NULL, szArglist[i], -1, pSrc, al, NULL, NULL);
					pSrc[al] = 0;
				}
				aryText.Add ((DWORD)pSrc);
			}
		}
	}

	// ! must release memory
	if(szArglist)
		LocalFree(szArglist);

	//!!! ͷԭݡ
	void * pArry = *ArgInf.m_ppAryData;
	if(pArry)
		FreeAryElement(pArry);
	
	// ±ݡ
	INT nSize = aryText.GetDWordCount () * sizeof (DWORD);
	p = (LPSTR)E_MAlloc_Nzero (sizeof (INT) * 2 + nSize);
	*(LPINT)p = 1;  // ά
	*(LPINT)(p + sizeof (INT)) = aryText.GetDWordCount ();
	memcpy (p + sizeof (INT) * 2, aryText.GetPtr (), nSize);
	*ArgInf.m_ppAryData =  p;  // дظ
}

/*
extern "C" void _cdecl krnln_GetCmdLine (INT nArgCount,MDATA_INF ArgInf,...)
{
/*
	void * pArry = *ArgInf.m_ppAryData;
	if(pArry)
		FreeAryElement(pArry);

	int argCount = 0;
	LPWSTR* lpArgv = ::CommandLineToArgvW(::GetCommandLineW(), &argCount);
	LPINT pArryData;
	if(argCount < 2 )
	{
		pArryData = (LPINT)E_MAlloc(2 * sizeof(INT));
		pArryData[0]=1;
		pArryData[1]=0;
		*ArgInf.m_ppAryData = pArryData;
	}
	else
	{
		argCount --;
		pArryData = (LPINT)E_MAlloc((2+argCount) * sizeof(INT));
		pArryData[0]=1;
		pArryData[1]=argCount;
		LPSTR* pArryText = (LPSTR*)(pArryData+2);

		for(INT i=0;i < argCount;i++)
		{
			pArryText[i] = BMUnicodeToAnsi(lpArgv[i+1]);
			//MessageBox(NULL,pArryText[i],NULL,MB_OK);
		}
		

	}
	*ArgInf.m_ppAryData = pArryData;

	GlobalFree(lpArgv);
*/

/*
	LPSTR p = GetCommandLine (), pb;
	// ó
	char ch = ' ';
	if (*p++ == '\"')
		ch = '\"';
	while (*p++ != ch);
	if (ch != ' ' && *p == ' ')  p++;    // һո
	
	CMyDWordArray aryText;
	
	while (*p != '\0')
	{
		if (*p == '\"')
		{
			p++;
			pb = p;
			while (*pb != '\0' && *pb != '\"')
			{
				if (IS_CC (*pb) == TRUE)
				{
					if (pb [1] == 0)  break;
					pb++;
				}
				pb++;
			}
			
			aryText.Add ((DWORD)CloneTextData ((char*)p, pb - p));
			
			p = pb;
			if (*p != '\0')  p++;
		}
		else if (*p > ' ' || *pb<0)
		{
			pb = p;
			while (*pb != '\0' && *pb != '\"' && (*pb > ' ' || *pb<0))
			{
				if (IS_CC (*pb) == TRUE)
				{
					if (pb [1] == 0)  break;
					pb++;
				}
				pb++;
			}
			
			aryText.Add ((DWORD)CloneTextData ((char*)p, pb - p));
			
			p = pb;
		}
		else
			p++;
	}
	
	//!!! ͷԭݡ
	void * pArry = *ArgInf.m_ppAryData;
	if(pArry)
		FreeAryElement(pArry);
	
	// ±ݡ
	INT nSize = aryText.GetDWordCount () * sizeof (DWORD);
	p = (LPSTR)E_MAlloc_Nzero (sizeof (INT) * 2 + nSize);
	*(LPINT)p = 1;  // ά
	*(LPINT)(p + sizeof (INT)) = aryText.GetDWordCount ();
	A_memcpy (p + sizeof (INT) * 2, aryText.GetPtr (), nSize);
	*ArgInf.m_ppAryData =  p;  // дظ
}
*/

================================================
FILE: krnln/krnln_GetColorCount.cpp
================================================
#include "stdafx.h"
#pragma comment(lib,"gdi32.lib") 
//ϵͳ - ȡɫ
/*
    øʽ ͡ ȡɫ  - ϵͳֿ֧->ϵͳ
    ӢƣGetColorCount
    صǰʾʽṩɫʾĿΪ
*/
LIBAPI(int, krnln_GetColorCount)
{
	HDC hdc = ::GetDC(NULL);
	INT nRet = GetDeviceCaps(hdc,COLORRES);
	::ReleaseDC (NULL,hdc);
	return (1 << nRet);
}


================================================
FILE: krnln/krnln_GetCursorHorzPos.cpp
================================================
#include "stdafx.h"

//ϵͳ - ȡˮƽλ
/*
    øʽ ͡ ȡˮƽλ  - ϵͳֿ֧->ϵͳ
    ӢƣGetCursorHorzPos
    ָĵǰˮƽλãλΪص㣬ĻߡΪ
*/
LIBAPI(int, krnln_GetCursorHorzPos)
{
	POINT point;
	if(GetCursorPos(&point))
		return point.x;
	return 0;
}


================================================
FILE: krnln/krnln_GetCursorVertPos.cpp
================================================
#include "stdafx.h"

//ϵͳ - ȡ괹ֱλ
/*
    øʽ ͡ ȡ괹ֱλ  - ϵͳֿ֧->ϵͳ
    ӢƣGetCursorVertPos
    ָĵǰֱλãλΪص㣬ĻߡΪ
*/
LIBAPI(int, krnln_GetCursorVertPos)
{
	POINT point;
	if(GetCursorPos(&point))
		return point.y;
	return 0;
}


================================================
FILE: krnln/krnln_GetDataTypeSize.cpp
================================================
#include "stdafx.h"

// - ȡͳߴ
/*
    øʽ ͡ ȡͳߴ  ȡߴͣ - ϵͳֿ֧->
    ӢƣGetDataTypeSize
    ȡָ͵ݳߴ磬ͲΪıֽڼûԶ͡Ϊ
    <1>Ϊȡߴ͡ΪͣintֵΪ³
	1#ֽͣ 2#ͣ 3#ͣ 4#ͣ 5#Сͣ 6#˫Сͣ 7#߼ͣ 8#ʱͣ 9#ӳָ͡
*/
LIBAPI(int, krnln_GetDataTypeSize)
{
	switch (ArgInf.m_int)
	{
	case 1://SDT_BYTE:
		return sizeof (BYTE);
	case 2://SDT_SHORT:
		ASSERT (sizeof (SHORT) == 2);
		return sizeof (SHORT);
	case 7://SDT_BOOL:
		ASSERT (sizeof (BOOL) == 4);
		return sizeof (BOOL);
	case 3://SDT_INT:
		ASSERT (sizeof (INT) == 4);
		return sizeof (INT);
	case 5://SDT_FLOAT:
		ASSERT (sizeof (FLOAT) == 4);
		return sizeof (FLOAT);
	case 9://SDT_SUB_PTR:    // ¼ӳĵַָ
		return sizeof (DWORD);
	//case SDT_TEXT:    // ıͺֽڼΪһָ,Ϊĸֽ.
	//case SDT_BIN:
		//return sizeof (DWORD);
	case 4://SDT_INT64:
		ASSERT (sizeof (INT64) == 8);
		return sizeof (INT64);
	case 6://SDT_DOUBLE:
		ASSERT (sizeof (DOUBLE) == 8);
		return sizeof (DOUBLE);
	case 8://SDT_DATE_TIME:
		ASSERT (sizeof (DATE) == 8);
		return sizeof (DATE);
	default:
		ASSERT (FALSE);
		return 0;
	}
	
	return 0;



}


================================================
FILE: krnln/krnln_GetDatePart.cpp
================================================
#include "stdafx.h"
#include <math.h>
//ʱ - ȡ
/*
    øʽ ʱ͡ ȡ ʱ ʱ䣩 - ϵͳֿ֧->ʱ
    ӢƣGetDatePart
    һʱݵڲ֣Сʱӡ뱻̶Ϊ0ʱ00롣Ϊ
    <1>Ϊʱ䡱Ϊʱͣdate
*/
LIBAPI(void, krnln_GetDatePart) // ֱ޸eaxedx,ԲҪֵָ
{
	DATE objDate;
	DATE dt = modf(ArgInf.m_date,&objDate);
	ArgInf.m_date = objDate;
	__asm{
		mov eax, ArgInf.m_unit.m_dwFormID;
		mov edx, ArgInf.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_GetDaysOfSpecMonth.cpp
================================================
#include "stdafx.h"

//ʱ - ȡij
/*
    øʽ ͡ ȡij  ݣ ·ݣ - ϵͳֿ֧->ʱ
    ӢƣGetDaysOfSpecMonth
    ָ··Ч0Ϊ
    <1>ΪݡΪͣintֵ 100  9999
    <2>Ϊ·ݡΪͣintֵ 1  12
*/
LIBAPI(int, krnln_GetDaysOfSpecMonth)
{
	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[1].m_int <=0 || pArgInf[1].m_int >12 || pArgInf[0].m_int <100 || pArgInf[1].m_int>9999)
		return 0;
	return GetDaysOfSpecMonth(pArgInf[0].m_int,pArgInf[1].m_int);

}


================================================
FILE: krnln/krnln_GetDiskFreeSpace.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

//̲ - ȡʣռ
/*
    øʽ ͡ ȡʣռ ı ַݣ - ϵͳֿ֧->̲
    ӢƣGetDiskFreeSpace
     1024 ֽڣKBΪλָʣռ䡣ʧܣ-1Ϊ
    <1>ΪַΪıͣtextԱʡԡơABCȣֻȡøıĵһַʡԣĬʹõǰ

*/
LIBAPI(int, krnln_GetDiskFreeSpace)
{
	char DirName [MAX_PATH];
	if(ArgInf.m_dtDataType == _SDT_NULL)
	{
		if(GetCurrentDirectory(MAX_PATH,DirName)==0)
			return -1;
		DirName[2]=0;

	}
	else
	{
		if(mystrlen(ArgInf.m_pText)==0)
			return -1;

		DirName[0]=*ArgInf.m_pText;
		DirName[1]=':';
		DirName[2]=0;

	}
	ULARGE_INTEGER FreeBytesAvailableToCaller, TotalNumberOfBytes, TotalNumberOfFreeBytes;

	if(GetDiskFreeSpaceEx(DirName,&FreeBytesAvailableToCaller,&TotalNumberOfBytes,&TotalNumberOfFreeBytes))
	{
		INT nRet = INT(FreeBytesAvailableToCaller.QuadPart/1024);
		return nRet;
	}
	return -1;
}


================================================
FILE: krnln/krnln_GetDiskLabel.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

//̲ - ȡ̾
/*
    øʽ ı͡ ȡ̾ ı ַݣ - ϵͳֿ֧->̲
    ӢƣGetDiskLabel
    ̵ָľıΪ
    <1>ΪַΪıͣtextԱʡԡơABCȣֻȡøıĵһַʡԣĬʹõǰ

*/
LIBAPI(char*, krnln_GetDiskLabel)
{
	char DirName [MAX_PATH];
	if(ArgInf.m_dtDataType == _SDT_NULL)
	{
		if(GetCurrentDirectory(MAX_PATH,DirName)==0)
			return NULL;
		DirName[3]=0;

	}
	else
	{
		if(mystrlen(ArgInf.m_pText)==0)
			return NULL;

		DirName[0]=*ArgInf.m_pText;
		DirName[1]=':';
		DirName[2]='\\';
		DirName[3]=0;

	}

	char* pText = NULL;
	char strVolume [MAX_PATH];
	char FileSystemNameBuffer [64];
	DWORD VolumeSerialNumber;

	if(GetVolumeInformation(DirName,strVolume,MAX_PATH,
		&VolumeSerialNumber,
		NULL,
		NULL,
		FileSystemNameBuffer,
		64))
	{
		INT nLen = mystrlen(strVolume);
		pText = CloneTextData(strVolume,nLen);

	}
	return pText;
}


================================================
FILE: krnln/krnln_GetDiskTotalSpace.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

//̲ - ȡܿռ
/*
    øʽ ͡ ȡܿռ ı ַݣ - ϵͳֿ֧->̲
    ӢƣGetDiskTotalSpace
     1024 ֽڣKBΪλָȫռ䡣ʧܣ-1Ϊ
    <1>ΪַΪıͣtextԱʡԡơABCȣֻȡøıĵһַʡԣĬʹõǰ
*/
LIBAPI(int, krnln_GetDiskTotalSpace)
{
	char DirName [MAX_PATH];
	if(ArgInf.m_dtDataType == _SDT_NULL)
	{
		if(GetCurrentDirectory(MAX_PATH,DirName)==0)
			return -1;
		DirName[2]=0;

	}
	else
	{
		if(mystrlen(ArgInf.m_pText)==0)
			return -1;

		DirName[0]=*ArgInf.m_pText;
		DirName[1]=':';
		DirName[2]=0;

	}
	//ULARGE_INTEGER FreeBytesAvailableToCaller, TotalNumberOfBytes, TotalNumberOfFreeBytes;
	DWORD SectorsPerCluster, BytesPerSector, NumberOfFreeClusters, nNumerator;

	if (GetDiskFreeSpace(DirName, &SectorsPerCluster, &BytesPerSector, &NumberOfFreeClusters, &nNumerator))
	{
		int nRet = int(MulDiv(BytesPerSector * SectorsPerCluster, nNumerator, 1024));
		return nRet;
	}
// 	if(GetDiskFreeSpaceEx(DirName,&FreeBytesAvailableToCaller,&TotalNumberOfBytes,&TotalNumberOfFreeBytes))
// 	{
// 		INT nRet = INT(TotalNumberOfBytes.QuadPart/1024);
// 		return nRet;
// 	}
	return -1;
}


================================================
FILE: krnln/krnln_GetEnv.cpp
================================================
#include "stdafx.h"

//ȡ - 
/*
    øʽ ı͡  ı ƣ - ϵͳֿ֧->ȡ
    ӢƣGetEnv
    ıһϵͳɹʱȡõֵʧ򷵻ؿıΪ
    <1>ΪơΪıͣtext
*/
LIBAPI(char*, krnln_GetEnv)
{
	char* pBuf ;
	UINT nLen = MAX_PATH;
	UINT nRet;
redo:
	pBuf = (char*)E_MAlloc(nLen);
	nRet = GetEnvironmentVariable(ArgInf.m_pText,pBuf,nLen);
	if(nRet > nLen)
	{
		E_MFree(pBuf);
		nLen = nRet;
		goto redo;
	}
	return pBuf;
}


================================================
FILE: krnln/krnln_GetHDiskCode.cpp
================================================
#include "stdafx.h"
/*
    øʽ ͡ ȡӲ  - ϵͳֿ֧->
    ӢƣGetHDiskCode
    صеһӲ̵֣ǽӲصģҲ˵κϵͳ޹أϵͳûʹôԼijijһ̨УԱԼİȨκ Windows ϵͳ汾Сִк 0 ʾ˴ȡӲʧܡпΪʱ I/O ͻɣʧܺԵȴһʱԣԲο̣ظκȻʧܣӲ޷ȡ֡Ϊ
*/
extern DWORD __cdecl krnln_GetHD___Code(int *a1);

LIBAPI(DWORD, krnln_GetHDiskCode)
{
  return krnln_GetHD___Code(NULL);
}

================================================
FILE: krnln/krnln_GetHostName.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

#pragma comment(lib,"WS2_32.LIB")
//ͨ - ȡ
/*
    øʽ ı͡ ȡ  - ϵͳֿ֧->ͨ
    ӢƣGetHostName
    رͨѶб־ַΪ
*/
LIBAPI(void*, krnln_GetHostName)
{
	WSAData wsaData;
	LPSTR pText=NULL;
	if(WSAStartup(MAKEWORD(2,2),&wsaData)==0)
	{
		char hst[MAX_PATH];
		if(gethostname(hst,MAX_PATH)==0)
		{
			pText=CloneTextData(hst,mystrlen(hst));
		}
		WSACleanup ();
	}
	return pText;
}


================================================
FILE: krnln/krnln_GetIntInsideBin.cpp
================================================
#include "stdafx.h"

// øʽ ͡ ȡֽڼ ֽڼ ֽڼ ȡƫƣ߼ Ƿתֽݣ - ϵͳֿ֧->ֽڼ
// ӢƣGetIntInsideBin
// ֽڼָλôΪ
// <1>ΪֽڼΪֽڼbinṩֽڼ
// <2>ΪȡƫơΪͣintṩȡֵֽڼеƫλá
// <3>ΪǷתֽ򡱣Ϊ߼ͣboolԱʡԡָǷȡֵֽзת,Ʃʮ0x12345678,תΪ0x78563412. JavaԽݽʱô. ʡԣĬֵΪ.
// 
// ϵͳ WindowsLinux

LIBAPI(int, krnln_GetIntInsideBin)
{
	PMDATA_INF pArgInf = &ArgInf;
	
	LPBYTE pSrc = pArgInf[0].m_pBin;
	if (!pSrc) return 0;
	
	int nLen = pArgInf[0].m_pInt[1];
	int off = pArgInf[1].m_int;
	if (nLen - off < 4) return 0;
	
	int nValue = *(LPINT)(pSrc + off + 2*sizeof(int));
	if (pArgInf[2].m_dtDataType != _SDT_NULL && pArgInf[2].m_bool)
	{
		unsigned int nTmp = (unsigned int)nValue;
		nValue = nTmp >> 24;
		nValue |= ((nTmp & 0x00FF0000) >> 8);
		nValue |= ((nTmp & 0x0000FF00) << 8);
		nValue |= ((nTmp & 0x000000FF) << 24);
	}
	return nValue;
}

================================================
FILE: krnln/krnln_GetKeyText.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

//ϵͳ - 
/*
    øʽ ı͡  ı ļı ƣı ƣı Ĭıݣ - ϵͳֿ֧->ϵͳ
    ӢƣGetKeyText
    ȡָļָĿıݡΪ
    <1>ΪļΪıͣtextָļƣͨ.iniΪļ׺
    <2>ΪơΪıͣtextڵơ
    <3>ΪơΪıͣtextֵָеơ
    <4>ΪĬıΪıͣtextԱʡԡָڣشĬıָұʡԣؿı
*/
LIBAPI(char*, krnln_GetKeyText)
{
	PMDATA_INF pArgInf = &ArgInf;
	LPSTR pBuff = NULL;
	INT nLen = 1024;
	do
	{

		pBuff = new char[nLen];
		INT nRet = GetPrivateProfileString (pArgInf[1].m_pText, pArgInf[2].m_pText, pArgInf[3].m_pText, pBuff, nLen, pArgInf[0].m_pText);

		if(nRet < nLen-1)
			break;
		nLen = nRet+1024;
		delete[] pBuff;
	}while(1);

	LPSTR pText = NULL;
	nLen = mystrlen(pBuff);
	if(nLen)
	{
		pText = CloneTextData(pBuff,nLen);
	}
	delete[] pBuff;
	return pText;
}


================================================
FILE: krnln/krnln_GetLastError.cpp
================================================
#include "stdafx.h"

//ϵͳ - ȡ
/*
    øʽ ͡ ȡ  - ϵͳֿ֧->ϵͳ
    ӢƣGetLastError
    òϵͳGetLastError,ظAPIúķֵ.Ϊ
	
	ϵͳ Windows
*/
LIBAPI(INT, krnln_GetLastError)
{
	return GetLastError();
}

================================================
FILE: krnln/krnln_GetNumRegItem.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

#pragma comment(lib,"advapi32.lib") 
//ϵͳ - ȡֵע
/*
    øʽ ͡ ȡֵע  Ŀ¼ı ȫ·ע Ĭֵݣ - ϵͳֿ֧->ϵͳ
    ӢƣGetNumRegItem
     Windows עзֵָעֵȡעĬֵĿӡ\ţ硰test\롰ȡֵעͬDZȡλôעΪм
    <1>ΪĿ¼ΪͣintΪ³ֵ֮һ 1#ࣻ 2#ã 3#û 4#ػ 5#û
    <2>Ϊȫ·עΪıͣtext
    <3>ΪĬֵΪͣintԱʡԡָעڣشĬֵָעұʡԣֵ 0
*/
LIBAPI(int, krnln_GetNumRegItem)
{
	PMDATA_INF pArgInf = &ArgInf;
	HKEY hRootkey = GetRegRootVal(pArgInf[0].m_int);
	BOOL bOk = FALSE;
	INT nRetVal = 0;
	INT nLen = mystrlen(pArgInf[1].m_pText);
	if(hRootkey && nLen)
	{
		HKEY hkey;
		LPSTR pSubkey = new char [nLen +1];
		strcpy(pSubkey,pArgInf[1].m_pText);
		LPSTR pKeyname = strrchr(pSubkey,'\\');
		if(pKeyname)
		{
			*pKeyname = 0;
			pKeyname++;
		}
		if(RegOpenKey(hRootkey,pSubkey,&hkey)==ERROR_SUCCESS)
		{
		
			DWORD nLen = 4;
			DWORD dwType = REG_DWORD;

			if(ERROR_SUCCESS == RegQueryValueEx(hkey,pKeyname,NULL,&dwType,(LPBYTE)&nRetVal,&nLen))
			{
				if(dwType == REG_DWORD)
					bOk = TRUE;
			}

			RegCloseKey(hkey);

		}
		delete [] pSubkey;
	}

	if(bOk == FALSE && pArgInf[2].m_dtDataType != _SDT_NULL)
	{
		nRetVal = pArgInf[2].m_int;
	}
	return nRetVal;
}


================================================
FILE: krnln/krnln_GetRunFileName.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

//ȡ - ȡִļ
/*
    øʽ ı͡ ȡִļ  - ϵͳֿ֧->ȡ
    ӢƣGetRunFileName
    ȡǰִе׳ļơΪ
*/
LIBAPI(char*, krnln_GetRunFileName)
{
	char strFile[MAX_PATH];
	int nLen;
	char* pSrc = strFile;

	if(::GetModuleFileName(NULL,strFile,MAX_PATH))
	{
		nLen = mystrlen(strFile);
		char* pFind = strFile+nLen;
		do{
			pFind --;
			if(*pFind == '\\')
			{
				pSrc = pFind +1;
				break;
			}

		}while(pFind > strFile);
	}

	nLen = mystrlen(pSrc);
	char *pText = (char*)E_MAlloc_Nzero(nLen+1);
	strcpy(pText,pSrc);
	return pText;
}


================================================
FILE: krnln/krnln_GetRunPath.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

//ȡ - ȡĿ¼
/*
    øʽ ı͡ ȡĿ¼  - ϵͳֿ֧->ȡ
    ӢƣGetRunPath
    ȡǰִе׳ļĿ¼Ϊ
*/
LIBAPI(char*, krnln_GetRunPath)
{
	char strFile[MAX_PATH];
	int nLen;

	if(::GetModuleFileName(NULL,strFile,MAX_PATH))
	{
		nLen = mystrlen(strFile);
		char* pFind = strFile+nLen;
		do{
			pFind --;
			if(*pFind == '\\')
			{
				*pFind = 0;
				break;
			}

		}while(pFind > strFile);
	}

	nLen = mystrlen(strFile);
	char *pText = (char*)E_MAlloc_Nzero(nLen+1);
	strcpy(pText,strFile);
	return pText;

}


================================================
FILE: krnln/krnln_GetRuntimeDataType.cpp
================================================
#include "stdafx.h"

/*
	øʽ ͡ȡʱ (ͨ ȡ͵)
	ӢƣGetRuntimeDataType
	ṩʱֵ. ע: 
	ڳϵͳֿֿ֧֧ж,ôÿһγֵܻᷢ仯(Ϊʱضλԭ),
	ڳйиֵDz仯.,ݵκʱʼһ㶨ֵ.
	<1>Ϊȡ͵ݡΪͨ͡ȡʱ͵
*/	
LIBAPI(int, krnln_GetRuntimeDataType)
{
	PMDATA_INF pArgInf = &ArgInf;
	return (int)pArgInf [0].m_dtDataType;
}


================================================
FILE: krnln/krnln_GetScreenHeight.cpp
================================================
#include "stdafx.h"

//ϵͳ - ȡĻ߶
/*
    øʽ ͡ ȡĻ߶  - ϵͳֿ֧->ϵͳ
    ӢƣGetScreenHeight
    Ļǰʾĸ߶ȣλΪص㡣Ϊ
*/

LIBAPI(int, krnln_GetScreenHeight)
{
	return GetSystemMetrics(SM_CYSCREEN);
}


================================================
FILE: krnln/krnln_GetScreenWidth.cpp
================================================
#include "stdafx.h"

//ϵͳ - ȡĻ
/*
    øʽ ͡ ȡĻ  - ϵͳֿ֧->ϵͳ
    ӢƣGetScreenWidth
    ĻǰʾĿȣλΪص㡣Ϊ
*/
LIBAPI(int, krnln_GetScreenWidth)
{
	return GetSystemMetrics(SM_CXSCREEN);
}


================================================
FILE: krnln/krnln_GetSectionNames.cpp
================================================
#include "stdafx.h"
#include "mem.h"
#include "Myfunctions.h"
//ϵͳ - ȡý
/*
    øʽ ı页 ȡý ı ļ - ϵͳֿ֧->ϵͳ
    ӢƣGetSectionNames
    ָļнı顣Ϊ
    <1>ΪļΪıͣtextָļƣͨ.iniΪļ׺

*/
LIBAPI(void*, krnln_GetSectionNames)
{
	CMyDWordArray aryText;
#define   MAX_ALLSECTIONS   0x32000 
//	LPSTR pBuff = NULL;
	INT nLen = MAX_ALLSECTIONS;
//	do
//	{
//		pBuff = new char[nLen+1];
		char pBuff [MAX_ALLSECTIONS];
		INT nRet = GetPrivateProfileSectionNames(pBuff, MAX_ALLSECTIONS, ArgInf.m_pText);
				
//		if(nRet < nLen)
//		{
			if(nRet >0)
			{
				LPSTR pText = pBuff;
				LPSTR pEnd = pText + nRet;
				while(*pText !=0 && pText < pEnd)
				{
					nLen = mystrlen(pText);
					aryText.Add ((DWORD)CloneTextData (pText, nLen));
					pText+=(nLen+1);
				}

			}
			//delete[] pBuff;
			//break;
//		}
		//nLen = nRet;
//		delete[] pBuff;
//	}while(1);

	

	
	// ±ݡ
	INT nSize = aryText.GetDWordCount () * sizeof (DWORD);
	LPSTR p = (LPSTR)E_MAlloc_Nzero (sizeof (INT) * 2 + nSize);
	*(LPINT)p = 1;  // ά
	*(LPINT)(p + sizeof (INT)) = aryText.GetDWordCount ();
	memcpy (p + sizeof (INT) * 2, aryText.GetPtr (), nSize);
	return  p;  // дظ
}


================================================
FILE: krnln/krnln_GetSpecTime.cpp
================================================
#include "stdafx.h"

//ʱ - ָʱ
/*
    øʽ ʱ͡ ָʱ  ꣬ £ݣ գݣ Сʱݣ ӣݣ ݣ - ϵͳֿ֧->ʱ
    ӢƣGetSpecTime
    ذָꡢ¡աСʱ֡ʱ䡣ָЧʱ䣬ԶʹЧʱ档Ϊ
    <1>ΪꡱΪͣint
    <2>Ϊ¡ΪͣintԱʡԡʡԣĬΪ 1 ¡
    <3>ΪաΪͣintԱʡԡʡԣĬΪ 1 ա
    <4>ΪСʱΪͣintԱʡԡʡԣĬΪ 0 ʱ
    <5>ΪӡΪͣintԱʡԡʡԣĬΪ 0 ӡ
    <6>Ϊ롱ΪͣintԱʡԡʡԣĬΪ 0 롣
*/
LIBAPI(void, krnln_GetSpecTime) // ֱ޸eaxeax,ԲҪֵָ
{
	PMDATA_INF pArgInf = &ArgInf;	
	INT nYear, nMonth, nDay;
	INT nHour, nMinute, nSecond;
	nYear = pArgInf[0].m_int;
	if(nYear < 100) nYear =100;

	if(pArgInf[1].m_dtDataType ==_SDT_NULL)
		nMonth = 1;
	else
	{
		nMonth = pArgInf[1].m_int;
		if(nMonth < 1)
			nMonth =1;
		else if (nMonth > 12)
			nMonth =12;
	}

	if(pArgInf[2].m_dtDataType ==_SDT_NULL)
		nDay = 1;
	else
	{
		nDay = pArgInf[2].m_int;
		if(nDay < 1)
			nDay = 1;
		else
		{
			INT nMaxDay = GetDaysOfSpecMonth(nYear,nMonth);
			if(nDay > nMaxDay)
				nDay = nMaxDay;
		}
	}

	nHour = pArgInf[3].m_int;
	if(nHour < 0)
		nHour = 0;
	else if (nHour > 23)
		nHour = 23;

	nMinute = pArgInf[4].m_int;
	if(nMinute < 0)
		nMinute = 0;
	else if (nMinute > 59)
		nMinute = 59;

	nSecond = pArgInf[5].m_int;
	if(nSecond < 0)
		nSecond = 0;
	else if (nSecond > 59)
		nSecond = 59;

	ArgInf.m_double = GetSpecDateTime(nYear, nMonth, nDay, nHour, nMinute, nSecond);
	__asm{
		mov eax, ArgInf.m_unit.m_dwFormID;
		mov edx, ArgInf.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_GetSysVer.cpp
================================================
#include "stdafx.h"

#define VER_NT_WORKSTATION              0x0000001
#define VER_NT_DOMAIN_CONTROLLER        0x0000002
#define VER_NT_SERVER                   0x0000003
typedef   struct   OSVERSIONINFOEX1
{ 
	DWORD   dwOSVersionInfoSize; 
	DWORD   dwMajorVersion; 
	DWORD   dwMinorVersion; 
	DWORD   dwBuildNumber; 
	DWORD   dwPlatformId; 
	WCHAR     szCSDVersion[128];           //   Maintenance   string   for   PSS   usage
	WORD       wServicePackMajor; 
	WORD       wServicePackMinor; 
	WORD       wSuiteMask; 
	BYTE     wProductType; 
	BYTE     wReserved; 
}   OSVERSIONINFOEXW1; 

#if _MSC_VER >= 1916 //VS2017 VS2019
typedef BOOL (WINAPI *MyGetVersionExA)(_Inout_ LPOSVERSIONINFOA lpVersionInformation);
#endif

//ϵͳ - ȡϵͳ
/*
    øʽ ͡ ȡϵͳ  - ϵͳֿ֧->ϵͳ
    ӢƣGetSysVer
    صǰϵͳİ汾𡣷ֵΪֵ֮һ0δ֪ 1Windows 32S 2Windows 9X (Win95Win98WinME) 3Windows NT (WinNTWin2000WinXP) 4LinuxΪ
*/
LIBAPI(int, krnln_GetSysVer)
{
	OSVERSIONINFO VersionInformation;
	INT nRet = 0;
	memset(&VersionInformation,0,sizeof(OSVERSIONINFO));
	VersionInformation.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

#if _MSC_VER >= 1916 //VS2017 VS2019
	HMODULE hKernel32 = GetModuleHandle("Kernel32.dll");
	if (!hKernel32)
		return 0;
	MyGetVersionExA MyGetVersion = (MyGetVersionExA)GetProcAddress(hKernel32, "GetVersionExA");
	if (!MyGetVersion)
		return 0;
	if (MyGetVersion(&VersionInformation))
#else
	if(GetVersionEx(&VersionInformation))
#endif
	{
		switch(VersionInformation.dwPlatformId)
		{
		case VER_PLATFORM_WIN32s:
			nRet = 1;
			break;
		case VER_PLATFORM_WIN32_WINDOWS:
			nRet = 2;
			break;
		case VER_PLATFORM_WIN32_NT:
			nRet = 3;
			break;
		}

	}
	return nRet;

}


//ϵͳ - ȡϵͳ2
/*
    øʽ ͡ ȡϵͳ2  - ϵͳֿ֧->ϵͳ
    ӢƣGetSysVer2
    صǰϵͳİ汾𡣷ֵΪֵ֮һ0δ֪ 1Windows 32S 2Windows 9X (Win95Win98WinME) 3Windows NTϵͳ(г) 
	4Linux 5Windows 10 6Windows Server 2016 Technical Preview 7Windows 8.1 8Windows Server 2012 R2 9Windows 8 10Windows Server 2012 
	11Windows 7 12Windows Server 2008 R2 13Windows Server 2008 14Windows VistaΪ
*/

LIBAPI(int, krnln_GetSysVer2)
{
	OSVERSIONINFOEX1 VerInfoEx;
	INT nRet = 0;
	memset(&VerInfoEx,0,sizeof(OSVERSIONINFOEX1));
	VerInfoEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX1);

#if _MSC_VER >= 1916 //VS2017 VS2019
	HMODULE hKernel32 = GetModuleHandle("Kernel32.dll");
	if (!hKernel32)
		return 0;
	MyGetVersionExA MyGetVersion = (MyGetVersionExA)GetProcAddress(hKernel32, "GetVersionExA");
	if (!MyGetVersion)
		return 0;
	if (MyGetVersion((OSVERSIONINFO*)&VerInfoEx))
#else
	if(GetVersionEx((OSVERSIONINFO*)&VerInfoEx))
#endif
	{
		switch(VerInfoEx.dwPlatformId)
		{
		case VER_PLATFORM_WIN32s:
			nRet = 1; //Windows 32S
			break;
		case VER_PLATFORM_WIN32_WINDOWS:
			nRet = 2; //Windows 9X (Win95Win98WinME)
			break;
		case VER_PLATFORM_WIN32_NT:
			switch (VerInfoEx.dwMajorVersion)
			{
			case 10:
				if (VerInfoEx.wProductType==VER_NT_WORKSTATION)
					nRet = 5; //Windows 10
				else
					nRet = 6; //Windows Server 2016 Technical Preview
			
				break;
			case 6:
				switch (VerInfoEx.dwMinorVersion)
				{
				case 3:
					if (VerInfoEx.wProductType==VER_NT_WORKSTATION)
						nRet = 7; //Windows 8.1
					else
						nRet = 8; //Windows Server 2012 R2
				
					break;
				case 2:
					if (VerInfoEx.wProductType==VER_NT_WORKSTATION)
						nRet = 9; //Windows 8
					else
						nRet = 10; //Windows Server 2012

					break;
				case 1:
					if (VerInfoEx.wProductType==VER_NT_WORKSTATION)
						nRet = 11; //Windows 7
					else
						nRet = 12; //Windows Server 2008 R2

					break;
				default:
					if (VerInfoEx.wProductType==VER_NT_WORKSTATION)
						nRet = 14; //Windows Vista
					else
						nRet = 13; //Windows Server 2008

					break;
				}
				break;
			default:
				nRet = 3; //Windows NTϵͳ(г)
				break;
			}
		}
	}
	return nRet;
}

================================================
FILE: krnln/krnln_GetTempFileName.cpp
================================================
#include "stdafx.h"
#include <SHLWAPI.h>
#include "Myfunctions.h"
#pragma comment(lib,"SHLWAPI.lib") 
//̲ - ȡʱļ
/*
    øʽ ı͡ ȡʱļ ı Ŀ¼ݣ - ϵͳֿ֧->̲
    ӢƣGetTempFileName
    һָĿ¼ȷڵ .TMP ȫ·ļơΪ
    <1>ΪĿ¼ΪıͣtextԱʡԡʡԱĬϽʹϵͳı׼ʱĿ¼
*/
LIBAPI(char*, krnln_GetTempFileName)
{
	char DirName [MAX_PATH];
	if(ArgInf.m_dtDataType == _SDT_NULL)
	{
		if(GetTempPath(MAX_PATH,DirName)==FALSE)
			DirName[0]=0;
	}
	else
		strcpy(DirName,ArgInf.m_pText);

	char* pText = NULL;
	char TempFileName [MAX_PATH];
	INT nLen = mystrlen(DirName);
	if(DirName[nLen-1]!='\\')
		DirName[nLen]='\\';
	do{
		wsprintf(TempFileName, "%s%x.tmp", DirName,GetTickCount());
	}while(PathFileExists(TempFileName));


//	if(GetTempFileName(DirName,"14f",0,TempFileName))
//	{
		nLen = mystrlen(TempFileName);
		pText = (char*)E_MAlloc_Nzero(nLen+1);
		strcpy(pText,TempFileName);
//	}
	return pText;
}


================================================
FILE: krnln/krnln_GetTextRegItem.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
#pragma comment(lib,"advapi32.lib") 

//ϵͳ - ȡıע
/*
    øʽ ı͡ ȡıע  Ŀ¼ı ȫ·עı Ĭıݣ - ϵͳֿ֧->ϵͳ
    ӢƣGetTextRegItem
     Windows עзָıעֵȡעĬֵĿӡ\ţ硰test\롰ȡıעͬDZȡλôעΪм
    <1>ΪĿ¼ΪͣintΪ³ֵ֮һ 1#ࣻ 2#ã 3#û 4#ػ 5#û
    <2>Ϊȫ·עΪıͣtext
    <3>ΪĬıΪıͣtextԱʡԡָעڣشĬıָעұʡԣһΪ 0 Ŀı
*/
LIBAPI(char*, krnln_GetTextRegItem)
{
	PMDATA_INF pArgInf = &ArgInf;
	HKEY hRootkey = GetRegRootVal(pArgInf[0].m_int);
	LPSTR pText = NULL;
	INT nLen = mystrlen(pArgInf[1].m_pText);
	if(hRootkey && nLen)
	{
		HKEY hkey;
		LPSTR pSubkey = new char [nLen +1];
		strcpy(pSubkey,pArgInf[1].m_pText);
		LPSTR pKeyname = strrchr(pSubkey,'\\');
		if(pKeyname)
		{
			*pKeyname = 0;
			pKeyname++;
		}
		if(RegOpenKey(hRootkey,pSubkey,&hkey)==ERROR_SUCCESS)
		{
		
			DWORD nLen = 1024;
			DWORD dwType = REG_SZ;
			INT nRet;
			LPSTR pData;
			do
			{
				pData = new char[nLen];

				nRet = RegQueryValueEx(hkey,pKeyname,NULL,&dwType,(LPBYTE)pData,&nLen);
				if(nRet == ERROR_SUCCESS)
				{
					if(dwType == REG_SZ || dwType == REG_EXPAND_SZ)
						pText = CloneTextData(pData,mystrlen(pData));
					break;

				}else if (nRet == ERROR_MORE_DATA)
				{
					delete [] pData;

				}else 	
					break;


			}while(1);

			delete [] pData;

			RegCloseKey(hkey);


		}
		delete [] pSubkey;
	}

	if(pText ==NULL && pArgInf[2].m_dtDataType != _SDT_NULL && pArgInf[2].m_pText)
	{
		pText = CloneTextData(pArgInf[2].m_pText,mystrlen(pArgInf[2].m_pText));
	}
	return pText;

}


================================================
FILE: krnln/krnln_GetTickCount.cpp
================================================
#include "stdafx.h"

//ϵͳ - ȡʱ
/*
    øʽ ͡ ȡʱ  - ϵͳֿ֧->ϵͳ
    ӢƣGetTickCount
     Windows ϵͳΪֹĺΪ
*/
LIBAPI(int, krnln_GetTickCount)
{
	return GetTickCount();
}


================================================
FILE: krnln/krnln_GetTimePart.cpp
================================================
#include "stdafx.h"
#include <math.h>
//ʱ - ȡʱ
/*
    øʽ ʱ͡ ȡʱ ʱ ʱ䣩 - ϵͳֿ֧->ʱ
    ӢƣGetTimePart
    һʱݵʱ䲿֣ꡢ¡ձ̶Ϊ200011աΪ
    <1>Ϊʱ䡱Ϊʱͣdate
*/
LIBAPI(void, krnln_GetTimePart) // ֱ޸EaxedxԲҪֵָ
{
	INT nHour, nMinute, nSecond;
	GetTimePart(ArgInf.m_date, nHour, nMinute, nSecond);
	ArgInf.m_date = GetSpecDateTime(2000,1,1,nHour, nMinute, nSecond);
	__asm{
		mov eax, ArgInf.m_unit.m_dwFormID;
		mov edx, ArgInf.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_GetWinPic.cpp
================================================
#include "stdafx.h"
#pragma comment(lib,"gdi32.lib")
#include <stdio.h>
//ϵͳ - 
/*
    øʽ ֽڼ   ھݣ ȣݣ ߶ȣݣ - ϵͳֿ֧->ϵͳ
    ӢƣGetWinPic
    ָڻĻʾݣӦͼƬݡʧܣؿֽڼΪ߼
    <1>ΪھΪͣintԱʡԡָʾݵĴڡʡԣĬΪĻʾݡ
    <2>ΪȡΪͣintԱʡԡָͼƬȡС0ֵָͼƬȡͼƬȵİٷֱȣСΪ10%0ͼƬԭ0ָͼƬľԿȡʡԣĬֵΪ0
    <3>Ϊ߶ȡΪͣintԱʡԡָͼƬ߶ȡС0ֵָͼƬ߶ȡͼƬ߶ȵİٷֱȣСΪ10%0ͼƬԭ߶0ָͼƬľԸ߶ȡʡԣĬֵΪ0
*/
LIBAPI(void*, krnln_GetWinPic)
{
	PMDATA_INF pArgInf = &ArgInf;
	HWND hWnd = (HWND)pArgInf[0].m_pCompoundData;
	HDC hdc = GetDC(hWnd);
	if(hdc==NULL)
		return NULL;
	RECT rect;

	HWND HObjWnd = hWnd;
	if(HObjWnd==NULL)
		HObjWnd = GetDesktopWindow();
	if(GetWindowRect(HObjWnd,&rect)==FALSE)
	{
		ReleaseDC(hWnd,hdc);
		return NULL;
	}

	SIZE sz; 
	sz.cx=rect.right-rect.left; 
	sz.cy=rect.bottom-rect.top; 
	int nWidth, nHeight;
	nWidth = sz.cx;
	nHeight = sz.cy;
	if(pArgInf[1].m_dtDataType != _SDT_NULL)
	{
		if(pArgInf[1].m_int > 0)
			nWidth = pArgInf[1].m_int;
		else if(pArgInf[1].m_int < 0)
		{
			if(pArgInf[1].m_int<-10)
				pArgInf[1].m_int=-10;
			nWidth = (sz.cx * -1* pArgInf[1].m_int)/100;
		}
	}
	if(pArgInf[2].m_dtDataType != _SDT_NULL)
	{
		if(pArgInf[2].m_int > 0)
			nHeight = pArgInf[2].m_int;
		else if(pArgInf[2].m_int < 0)
		{
			if(pArgInf[2].m_int<-10)
				pArgInf[2].m_int=-10;
			nHeight = (sz.cy * -1* pArgInf[2].m_int)/100;
		}
	}
	HDC hMemDC = CreateCompatibleDC(hdc);
	HBITMAP   hBitmap,hOldBitmap;   
	hBitmap = CreateCompatibleBitmap(hdc, nWidth, nHeight);
	hOldBitmap = (HBITMAP)SelectObject(hMemDC, hBitmap);
	//StretchBlt(hMemDC, 0, 0, nWidth, nHeight,hdc, rect.left, rect.top,rect.right,rect.bottom, SRCCOPY);
	SetStretchBltMode(hMemDC, HALFTONE);//ֹʱʧ
	StretchBlt(hMemDC, 0, 0, nWidth, nHeight,hdc, -8, 0, sz.cx, sz.cy, SRCCOPY);

	BITMAP bmp; 
	::GetObject(hBitmap, sizeof(BITMAP), &bmp);
	//ڴ汣λͼ 

	DWORD dwSize = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER) + bmp.bmWidthBytes * bmp.bmHeight;
	LPBYTE pData = (LPBYTE)E_MAlloc(dwSize+2* sizeof(INT));
	LPBYTE pArry =pData;
	*(LPINT)pArry=1;
	pArry+=sizeof(INT);
	*(LPINT)pArry=dwSize;
	pArry+=sizeof(INT);

	LPBITMAPFILEHEADER pBfh = (LPBITMAPFILEHEADER)pArry;//λͼļͷ 
	memset(pBfh,0,sizeof(BITMAPFILEHEADER));
	pBfh->bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);//λͼݵƫ 
	pBfh->bfSize = pBfh->bfOffBits + bmp.bmWidthBytes * bmp.bmHeight;//ļܵĴС 
	pBfh->bfType = (WORD)0x4d42; 

	pArry+=sizeof(BITMAPFILEHEADER);

	LPBITMAPINFOHEADER pBih = (LPBITMAPINFOHEADER)pArry;//λͼϢͷ 
	memset(pBih,0,sizeof(BITMAPINFOHEADER));
	pBih->biSize = sizeof(BITMAPINFOHEADER); 
	pBih->biWidth = bmp.bmWidth;// 
	pBih->biHeight = bmp.bmHeight;//߶ 
	pBih->biPlanes = 1;
	pBih->biBitCount = bmp.bmBitsPixel;//ÿֽڴС 
	pBih->biCompression = BI_RGB; 
	pBih->biSizeImage = bmp.bmWidthBytes * bmp.bmHeight;//ͼݴС 
	pBih->biXPelsPerMeter = 0;
	pBih->biYPelsPerMeter = 0;
	pBih->biClrUsed = 0;
	pBih->biClrImportant = 0;
	pArry+=sizeof(BITMAPINFOHEADER);

	GetDIBits(hMemDC, hBitmap, 0, nHeight, pArry, 
	(LPBITMAPINFO)pBih, DIB_RGB_COLORS);//ȡλͼ 
	

	SelectObject(hMemDC, hOldBitmap);
	DeleteDC(hMemDC);
	ReleaseDC(hWnd,hdc);
	DeleteObject(hBitmap);
	return pData;

}


================================================
FILE: krnln/krnln_HostNameToIP.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

#pragma comment(lib,"WS2_32.LIB")
//ͨ - תΪIPַ
/*
    øʽ ı͡ תΪIPַ ı ת - ϵͳֿ֧->ͨ
    ӢƣHostNameToIP
    ָתΪ IP ַʧܷؿıΪ
    <1>ΪתΪıͣtext
*/

DWORD MYGetIPbyname(char *HostName)
{
	DWORD retIP;
	hostent* heDestHost = gethostbyname (HostName);

	if(heDestHost)
		retIP=*(DWORD *)*heDestHost->h_addr_list;
	else
		retIP=0xFFFFFFFF;
	return retIP;
}

LIBAPI(char*, krnln_HostNameToIP)
{
	WSAData wsaData;
	LPSTR pText=NULL;
	if(WSAStartup(MAKEWORD(2,2),&wsaData)==0)
	{
		DWORD retIP = MYGetIPbyname(ArgInf.m_pText);
		if(retIP !=0xFFFFFFFF)
		{
			sockaddr_in localaddr;
			localaddr.sin_addr.S_un.S_addr=retIP;
			LPSTR pIp = inet_ntoa(localaddr.sin_addr);
			pText=CloneTextData(pIp,mystrlen(pIp));

		}
		WSACleanup ();
	}
	return pText;
}


================================================
FILE: krnln/krnln_IDiv.cpp
================================================
#include "stdafx.h"
#include <math.h>
// - 
/*
    øʽ ˫С͡  ˫С ˫С ...  - ϵͳֿ֧->
    ӢƣIDiv
    ֵ̣֣Ϊ\ΪһԱظӡ
    <1>ΪΪ˫Сͣdouble
    <2>ΪΪ˫Сͣdouble
*/
LIBAPI(void, krnln_IDiv) // ֱ޸eaxedxԲҪֵָ
{
	PMDATA_INF pArg = &ArgInf;

	for(int i=1;i< nArgCount;i++)
	{
		ArgInf.m_double = floor(ArgInf.m_double /pArg[i].m_double);
	}

	__asm
	{
		mov eax,ArgInf.m_unit.m_dwFormID;
		mov edx,ArgInf.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_IPToHostName.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

#pragma comment(lib,"WS2_32.LIB")
//ͨ - תΪ
/*
    øʽ ı͡ תΪ ı תIPַ - ϵͳֿ֧->ͨ
    ӢƣIPToHostName
    ָ IP ַתΪʧܷؿıΪ
    <1>ΪתIPַΪıͣtext
*/

LIBAPI(char*, krnln_IPToHostName)
{
	WSAData wsaData;
	LPSTR pText=NULL;
	if(WSAStartup(MAKEWORD(2,2),&wsaData)==0)
	{
		DWORD retIP = inet_addr(ArgInf.m_pText);
		if(retIP !=0xFFFFFFFF)
		{
			hostent* hostinfo=gethostbyaddr((char*)&retIP,sizeof(retIP),AF_INET);
			pText=CloneTextData(hostinfo->h_name,mystrlen(hostinfo->h_name));
		
		}
		WSACleanup ();
	}
	return pText;

}


================================================
FILE: krnln/krnln_InBin.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

//ֽڼ - Ѱֽڼ
/*
    øʽ ͡ Ѱֽڼ ֽڼ Ѱֽڼֽڼ Ѱҵֽڼ ʼѰλãݣ - ϵͳֿ֧->ֽڼ
    ӢƣInBin
    һֽڼһֽڼȳֵλãλֵ 1 ʼδҵ -1Ϊ
    <1>ΪѰֽڼΪֽڼbin
    <2>ΪѰҵֽڼΪֽڼbin
    <3>ΪʼѰλáΪͣintԱʡԡ1Ϊλã2Ϊ2λãƣʡԣѰֽڼĬϴײʼֽڼĬϴβʼ

*/
LIBAPI(int, krnln_InBin)
{ // ߺ 
 	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[0].m_pBin==NULL || pArgInf[1].m_pBin==NULL)
 		return -1;

	INT nLen = pArgInf[0].m_pInt[1];
	INT nSubLen = pArgInf[1].m_pInt[1];

	register unsigned char* pSrc;
	int off;
	if(pArgInf[2].m_dtDataType == _SDT_NULL || pArgInf[2].m_int <= 1)
	{
		off = 1;
		pSrc = pArgInf[0].m_pBin + 2*sizeof(INT);
	}
	else
	{
		off = pArgInf[2].m_int;
		pSrc = pArgInf[0].m_pBin + 2*sizeof(INT) + off - 1;
		nLen -= off - 1;
	}

 	if(nLen<=0 || nSubLen<=0 || nSubLen > nLen)
		return -1;

	register unsigned char* pDes = pArgInf[1].m_pBin + 2*sizeof(INT);
	int i;

	// Ӵֱӱ
	switch (nSubLen)
	{
	case 1:
		i = mymemchr(pSrc, nLen, pDes[0]);
		if (i >= 0)
			return i + off;
		else
			return -1;
	case 2:
		for (i=0; i < nLen - 1; i++)
			if (((short*)(pSrc+i))[0] == ((short*)pDes)[0])
				return i + off;
		return -1;
	case 3:
		for (i=0; i < nLen - 2; i++)
			if (((short*)(pSrc+i))[0] == ((short*)pDes)[0])
				if (pSrc[i+2] == pDes[2])
					return i + off;	
		return -1;
	case 4:
		for (i=0; i < nLen - 3; i++)
			if (((int*)(pSrc+i))[0] == ((int*)pDes)[0])
				return i + off;
		return -1;
	case 5:
		for (i=0; i < nLen - 4; i++)
			if (((int*)(pSrc+i))[0] == ((int*)pDes)[0])
				if (pSrc[i+4] == pDes[4])
					return i + off;		
		return -1;
	case 6:
		for (i=0; i < nLen - 5; i++)
			if (((int*)(pSrc+i))[0] == ((int*)pDes)[0])
				if (((short*)(pSrc+i+4))[0] == ((short*)(pDes+4))[0])
					return i + off;
		return -1;
	default:  // ӴʹBM㷨,
		int naddr = boyer_moore(pSrc, nLen, pDes, nSubLen);
		if (naddr >= 0)
			return naddr + off;
	}

// Ӵʹ Sunday㷨,
// 	unsigned int next[256];
// 	for (i=0; i < 256; i++)
// 		next[i] = nSubLen;
// 	for (i = 0; i < nSubLen; i++)
// 		next[pDes[i]] = nSubLen - i;
// 
// 	register unsigned char* naddr;
// 	for (naddr = pSrc; naddr <= pSrc + nLen - nSubLen; naddr += next[naddr[nSubLen]])
// 		if (MyMemCmp(naddr, pDes, nSubLen)==0)
// 			return naddr - pSrc + off;
		
	return -1;
}
// { // ԭ
// 	PMDATA_INF pArgInf = &ArgInf;
// 	if(pArgInf[0].m_pBin==NULL || pArgInf[1].m_pBin==NULL)
// 		return -1;
// 
// 	INT nLen = pArgInf[0].m_pInt[1];
// 	INT nSubLen = pArgInf[1].m_pInt[1];
// 	if(nLen==0 || nSubLen==0 || nSubLen > nLen)return -1;
// 	
// 	INT nStart;
// 	if(pArgInf[2].m_dtDataType ==_SDT_NULL || pArgInf[2].m_int <=0)
// 		nStart = 1;
// 	else
// 		nStart = pArgInf[2].m_int;
// 
// 	INT nEnd = nLen - nSubLen;
// 	if(nStart > (nEnd+1))return -1;
// 	LPBYTE pSrc = pArgInf[0].m_pBin + 2*sizeof(INT);
// 	LPBYTE pStart = pSrc + nStart -1;
// 	LPBYTE pEnd = pSrc + nEnd;
// 	LPBYTE pObj = pArgInf[1].m_pBin + 2*sizeof(INT);
// 
// 	while(pStart <= pEnd)
// 	{
// 		if(memcmp(pStart,pObj,nSubLen)==0)
// 		{
// 			nStart = pStart - pSrc +1;
// 			return nStart;
// 		}
// 		pStart++;
// 	}
// 
// 
// 	return -1;	
// }


================================================
FILE: krnln/krnln_InBinRev.cpp
================================================
#include "stdafx.h"

extern "C" int inline MyMemCmp2(unsigned char* a, unsigned char* b, int len)
{
	for (int i=0; i < (len>>2); i++)
	{
		if (((int*)a)[0]!=((int*)b)[0])
			return 1;
		a+=4;b+=4;
	}
	if ((len&2) != 0)
	{
		if (((short*)a)[0]!=((short*)b)[0])
			return 1;
		a+=2;b+=2;
	}
	if ((len&1) != 0 && a[0]!=b[0])
		return 1;
	return 0;
}
//ֽڼ - ֽڼ
/*
    øʽ ͡ ֽڼ ֽڼ Ѱֽڼֽڼ Ѱҵֽڼ ʼѰλãݣ - ϵͳֿ֧->ֽڼ
    ӢƣInBinRev
    һֽڼһֽڼֵλãλֵ 1 ʼδҵ -1Ϊ
    <1>ΪѰֽڼΪֽڼbin
    <2>ΪѰҵֽڼΪֽڼbin
    <3>ΪʼѰλáΪͣintԱʡԡ1Ϊλã2Ϊ2λãƣʡԣѰֽڼĬϴײʼֽڼĬϴβʼ
*/
LIBAPI(int, krnln_InBinRev)
{ // ߺ 
 	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[0].m_pBin==NULL || pArgInf[1].m_pBin==NULL)
 		return -1;

	INT nLen = pArgInf[0].m_pInt[1];
	INT nSubLen = pArgInf[1].m_pInt[1];
	if (nLen <= 0 || nSubLen <= 0 || nSubLen > nLen) return -1;

	register unsigned char* pSrc = pArgInf[0].m_pBin + 2*sizeof(INT);
	int off;
	if (pArgInf[2].m_dtDataType == _SDT_NULL)
		off = nLen - nSubLen;
	else
	{
		off = pArgInf[2].m_int;
		if (off < 1) 
			return -1;
		if (off <= nLen)
			nLen = off;
		off = nLen - nSubLen;
	}

 	if (off < 0) return -1;

	register unsigned char* pDes = pArgInf[1].m_pBin + 2*sizeof(INT);
	int i;
	//int j;
	// Ӵֱӱ
	if (nSubLen == 1)
	{
		for (i = off; i >= 0; i--)
			if (pSrc[i] == pDes[0])
				return i + 1;
			
		return -1;
	}
	else if (nSubLen == 2)
	{
		for (i = off; i >= 0; i--)
			if (((short*)(pSrc+i))[0] == ((short*)pDes)[0])
				return i + 1;
			
		return -1;
	}
	else if (nSubLen == 3)
	{
		for (i = off; i >= 0; i--)
			if (((short*)(pSrc+i))[0] == ((short*)pDes)[0])
				if (pSrc[i+2] == pDes[2])
					return i + 1;
			
		return -1;
	}
	else if (nSubLen == 4)
	{
		for (i = off; i >= 0; i--)
			if (((int*)(pSrc+i))[0] == ((int*)pDes)[0])
				return i + 1;
			
		return -1;
	}
	else if (nSubLen == 5)
	{
		for (i = off; i >= 0; i--)
			if (((int*)(pSrc+i))[0] == ((int*)pDes)[0])
				if (pSrc[i+4] == pDes[4])
					return i + 1;
			
		return -1;
	}
	else if (nSubLen == 6)
	{
		for (i = off; i >= 0; i--)
			if (((int*)(pSrc+i))[0] == ((int*)pDes)[0])
				if (((short*)(pSrc+i+4))[0] == ((short*)(pDes+4))[0])
					return i + 1;
				
		return -1;
	}
 
// 	for (i = off; i >= 0; i--)
// 		if (MyMemCmp2(pSrc+i, pDes, nSubLen)==0)
//  			return i + 1;
// 
// 	return -1;
	// Ӵʹ Sunday㷨,
	register unsigned int next[256];
	for (i = 0; i < 256; i++)
		next[i] = nSubLen;
	for (i = nSubLen; i > 0; i--)
		next[pDes[i-1]] = i;

	register unsigned char* naddr = pSrc + off;
	for (; naddr >= pSrc; naddr -= next[naddr[-1]])
		if (MyMemCmp2(naddr, pDes, nSubLen)==0)
			return naddr - pSrc + 1;
		
	return -1;
}
// {// ԭ
// 	PMDATA_INF pArgInf = &ArgInf;
// 	if(pArgInf[0].m_pBin==NULL || pArgInf[1].m_pBin==NULL)
// 		return -1;
// 
// 	INT nLen = pArgInf[0].m_pInt[1];
// 	INT nSubLen = pArgInf[1].m_pInt[1];
// 	if(nLen==0 || nSubLen==0 || nSubLen > nLen)return -1;
// 	
// 	INT nStart;
// 	INT nEnd = nLen - nSubLen;
// 	if(pArgInf[2].m_dtDataType ==_SDT_NULL || pArgInf[2].m_int <=0)
// 		nStart = nEnd;
// 	else{
// 		nStart = pArgInf[2].m_int - nSubLen;
// 		if(nStart <0)
// 			nStart = 0;
// 	}
// 	
// 	if(nStart > nEnd)
// 		nStart = nEnd;
// 
// 	LPBYTE pSrc = pArgInf[0].m_pBin + 2*sizeof(INT);
// 	LPBYTE pStart = pSrc + nStart;
// 	LPBYTE pObj = pArgInf[1].m_pBin + 2*sizeof(INT);
// 
// 
// 	
// 	while(pStart >= pSrc)
// 	{
// 		if(memcmp(pStart,pObj,nSubLen)==0)
// 		{
// 			nStart = pStart - pSrc +1;
// 			return nStart;
// 		}
// 		pStart--;
// 	}
// 
// 
// 	return -1;	
// }


================================================
FILE: krnln/krnln_InStr.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

//ı - Ѱı
/*
    øʽ ͡ Ѱı ı Ѱıı Ѱҵı ʼѰλãݣ߼ ǷִСд - ϵͳֿ֧->ı
    ӢƣInStr
    һֵָһıһıȳֵλãλֵ 1 ʼδҵ-1Ϊ
    <1>ΪѰıΪıͣtext
    <2>ΪѰҵıΪıͣtext
    <3>ΪʼѰλáΪͣintԱʡԡλֵ 1 ʼʡԣĬΪ 1 
    <4>ΪǷִСдΪ߼ͣboolʼֵΪ١Ϊ治ִСдΪ֡
*/
LIBAPI(int, krnln_InStr)
{ // ߺ 
	PMDATA_INF pArgInf = &ArgInf;
	INT nStart;
	char *str1 = pArgInf[0].m_pText;
	char *str2 = pArgInf[1].m_pText;
	if (!str1 || !str2 || !*str1) return -1; //ıֱӷ
	if (!*str2) return 1;
	if (pArgInf[2].m_dtDataType == _SDT_NULL || pArgInf[2].m_int <= 1)
		nStart = 0;
	else
		nStart = pArgInf[2].m_int - 1;

	char* pStart = str1 + nStart;

	char *cp = str1;
	char *s1, *s2;
	
	for (; *cp && cp < pStart; cp++)
			if (*cp < 0) cp++;

	if (pArgInf[3].m_bool) //ִСд
	{
		register unsigned char* lt = lowtable;
		while (*cp)
		{
			s1 = cp;
			s2 = str2;
			while ( *s1 && *s2 && (*s1==*s2 || lt[(unsigned char)(*s1)]==lt[(unsigned char)(*s2)]) )
				s1++, s2++;
			if (!*s2)
				return cp - str1 + 1;
				
			if (*cp < 0)
			{
				cp++;
				if (!*cp)
					return -1;
			}
			cp++;
		}
	}
	else  // ִСд
	{	
		while (*cp)
		{
			s1 = cp;
			s2 = str2;
			while ( *s1 && *s2 && !(*s1-*s2) )
				s1++, s2++;
			if (!*s2)
				return cp - str1 + 1;
			
			if (*cp < 0)
			{
				cp++;
				if (!*cp)
					return -1;
			}
			cp++;
		}
	}
	return -1;
}
// 
// { // ԭ
// 	PMDATA_INF pArgInf = &ArgInf;
// 	INT nLen = strlen(ArgInf.m_pText);
// 	INT nSubLen = strlen(pArgInf[1].m_pText);
// 	if(nLen==0 || nSubLen==0 || nSubLen > nLen)return -1;
// 	
// 	INT nStart;
// 	if(pArgInf[2].m_dtDataType ==_SDT_NULL || pArgInf[2].m_int <=0)
// 		nStart = 1;
// 	else
// 		nStart = pArgInf[2].m_int;
// 	INT nEnd = nLen - nSubLen;
// 	if(nStart > (nEnd+1))return -1;
// 	char* pStart = ArgInf.m_pText + nStart -1;
// 	char* pEnd = ArgInf.m_pText + nEnd;
// 	if(pArgInf[3].m_bool) //ִСд
// 	{
// 		while(pStart <= pEnd)
// 		{
// 			if(strnicmp(pStart,pArgInf[1].m_pText,nSubLen)==0)
// 			{
// 				nStart = pStart - ArgInf.m_pText +1;
// 				return nStart;
// 			}
// 			if(*pStart<0)
// 				pStart+=2;
// 			else
// 				pStart++;
// 		}
// 
// 	}
// 	else
// 	{
// 		while(pStart <= pEnd)
// 		{
// 			if(strncmp(pStart,pArgInf[1].m_pText,nSubLen)==0)
// 			{
// 				nStart = pStart - ArgInf.m_pText +1;
// 				return nStart;
// 			}
// 			if(*pStart<0)
// 				pStart+=2;
// 			else
// 				pStart++;
// 		}
// 	}
// 
// 
// 	return -1;	
// }


================================================
FILE: krnln/krnln_InStrRev.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
//ı - ı
/*
    øʽ ͡ ı ı Ѱıı Ѱҵı ʼѰλãݣ߼ ǷִСд - ϵͳֿ֧->ı
    ӢƣInStrRev
    һֵָһıһıֵλãλֵ 1 ʼδҵ-1Ϊ
    <1>ΪѰıΪıͣtext
    <2>ΪѰҵıΪıͣtext
    <3>ΪʼѰλáΪͣintԱʡԡλֵ 1 ʼʡԣĬΪӱѰıβʼ
    <4>ΪǷִСдΪ߼ͣboolʼֵΪ١Ϊ治ִСдΪ֡
*/
LIBAPI(int, krnln_InStrRev)
{ // ߺ 
	PMDATA_INF pArgInf = &ArgInf;
	INT nStart;
	char *str1 = pArgInf[0].m_pText;
	char *str2 = pArgInf[1].m_pText;
	if (!str1 || !str2 || !*str1) return -1; //ıֱӷ
	if (!*str2) return 1;
	if (pArgInf[2].m_dtDataType == _SDT_NULL)
		nStart = 0x7FFFFFFF;
	else
	{
		if (pArgInf[2].m_int <= 0)
			return -1;
		nStart = pArgInf[2].m_int - 1;
	}
	
	INT nDesLen = mystrlen(str2);
	char* pStart = str1 + nStart - nDesLen;
	
	char *cp, *s1, *s2;
	
	// str1Ȼ޶ʼλ
	for (cp = str1; cp < pStart && *cp; cp++);
	//	if (*cp < 0) cp++; // ֲ2⣡
	
	if (cp < str1) return -1;

	if (pArgInf[3].m_bool) //ִСд
	{
		register unsigned char* lt = lowtable;
		while (cp >= str1)
		{
			s1 = cp;
			s2 = str2;
			while ( *s1 && *s2 && (*s1==*s2 || lt[(unsigned char)(*s1)]==lt[(unsigned char)(*s2)]) )
				s1++, s2++;
			if (!*s2)
				return cp - str1 + 1;
			cp--;
		}
	}
	else  // ִСд
	{	
		while (cp >= str1)
		{
			s1 = cp;
			s2 = str2;
			while ( *s1 && *s2 && !(*s1-*s2) )
				s1++, s2++;
			if (!*s2)
				return cp - str1 + 1;
			cp--;
		}
	}
	return -1;
}
// {
// 	PMDATA_INF pArgInf = &ArgInf;
// 	INT nLen = strlen(ArgInf.m_pText);
// 	INT nSubLen = strlen(pArgInf[1].m_pText);
// 	if(nLen==0 || nSubLen==0 || nSubLen > nLen)return -1;
// 	
// 	INT nStart;
// 	INT nEnd = nLen - nSubLen;
// 	if(pArgInf[2].m_dtDataType ==_SDT_NULL || pArgInf[2].m_int <=0)
// 		nStart = nEnd;
// 	else{
// 		nStart = pArgInf[2].m_int - nSubLen;
// 		if(nStart <0)
// 			nStart = 0;
// 	}
// 	
// 	if(nStart > nEnd)
// 		nStart = nEnd;
// 	char* pStart = ArgInf.m_pText + nStart;
// //MessageBox(NULL,pStart,NULL,MB_OK);
// 	if(pArgInf[3].m_bool) //ִСд
// 	{
// 		while(pStart >= ArgInf.m_pText)
// 		{
// 			if(strnicmp(pStart,pArgInf[1].m_pText,nSubLen)==0)
// 			{
// 				nStart = pStart - ArgInf.m_pText +1;
// 				return nStart;
// 			}
// 			pStart--;
// 		}
// 
// 	}
// 	else
// 	{
// 		while(pStart >= ArgInf.m_pText)
// 		{
// 			if(strncmp(pStart,pArgInf[1].m_pText,nSubLen)==0)
// 			{
// 				nStart = pStart - ArgInf.m_pText +1;
// 				return nStart;
// 			}
// 			pStart--;
// 		}
// 	}
// 
// 
// 	return -1;	
// }


================================================
FILE: krnln/krnln_InputBox.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

BYTE BMInputBoxDialogTemplateData []={
0xC0,0x08,0xC8,0x80,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0xFC,0x00,
0x5C,0x00,0x00,0x00,0x00,0x00,0xF7,0x8B,0x93,0x8F,0x65,0x51,0x1A,0xFF,0x00,0x00,
0x09,0x00,0x8B,0x5B,0x53,0x4F,0x00,0x00,0x00,0x10,0x02,0x50,0x00,0x00,0x00,0x00,
0x07,0x00,0x07,0x00,0xEE,0x00,0x23,0x00,0xFF,0xFF,0xFF,0xFF,0x82,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x50,0x00,0x00,0x00,0x00,0x0C,0x00,0x0B,0x00,
0xE5,0x00,0x1B,0x00,0x68,0x04,0xFF,0xFF,0x82,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x80,0x00,0x81,0x50,0x00,0x00,0x00,0x00,0x07,0x00,0x2D,0x00,0xEE,0x00,0x0C,0x00,
0xE9,0x03,0xFF,0xFF,0x81,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xA0,0x00,0x81,0x50,
0x00,0x00,0x00,0x00,0x07,0x00,0x2D,0x00,0xEE,0x00,0x0C,0x00,0xEA,0x03,0xFF,0xFF,
0x81,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x50,0x00,0x00,0x00,0x00,
0x3F,0x00,0x42,0x00,0x37,0x00,0x13,0x00,0x01,0x00,0xFF,0xFF,0x80,0x00,0x6E,0x78,
0xA4,0x8B,0x93,0x8F,0x65,0x51,0x28,0x00,0x26,0x00,0x4F,0x00,0x29,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x50,0x00,0x00,0x00,0x00,0x86,0x00,0x42,0x00,
0x37,0x00,0x13,0x00,0x02,0x00,0xFF,0xFF,0x80,0x00,0xD6,0x53,0x88,0x6D,0x28,0x00,
0x26,0x00,0x43,0x00,0x29,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};

/*
øʽ ߼͡  ı ʾϢݣı ڱݣı ʼıݣͨͱ ݵı 뷽ʽݣͨ ڣݣ - ϵͳֿ֧->ϵͳ
ӢƣInputBox
һԻʾʾȴûIJ°ťûȷ󣨰¡ȷ롱ťس˳棬򷵻ؼ١Ϊ
<1>ΪʾϢΪıͣtextԱʡԡʾϢУڸ֮ûس (ַ (13))з (ַ (10)) سз (ַ (13) + ַ (10)) ָʾϢֽ̫࣬ᱻʾ
<2>Ϊڱ⡱ΪıͣtextԱʡԡֵָʾڶԻеıʡԣĬΪı룺
<3>ΪʼıΪıͣtextԱʡԡֵָʼõԻıеݡ
<4>ΪݵıΪͨͣallṩʱֻṩֵָıΪֵıͣԲͬȡݡ
<5>Ϊ뷽ʽΪͣintԱʡԡֵΪ³ֵ 1#ı 2# 3#С 4#롣ʡԱĬΪ#ı
<6>ΪڡΪͨͣallԱʡԡָĸ,һ""ݻһʹھ.ʡ,ĬΪ.
*/
/////////////////////////////////////////////////////////////////////////////
typedef struct
{
	LPSTR lpText;
	LPSTR lpTitle;
	LPSTR lpIntiTxt;
	INT nType;
	BOOL bResult;
	HWND hEdit;
	LPSTR lpUserInput;
} BMInputBoxDATA;



BOOL CALLBACK BMInputBoxDlgProc( HWND hwndDlg,  // handle to dialog box 
							   UINT uMsg,     // message 
							   WPARAM wParam, // first message parameter 
							   LPARAM lParam  // second message parameter 
							   ) 
{ 
	switch (uMsg) 
	{ 
	case WM_INITDIALOG: 
		{
			BMInputBoxDATA* lpData = (BMInputBoxDATA*)lParam;
			::SetWindowText (hwndDlg,lpData->lpTitle);
			HWND hwndEDIT;
			if(lpData->nType ==4)//
			{
				hwndEDIT = GetDlgItem(hwndDlg,1001);
				ShowWindow(hwndEDIT, SW_HIDE); 
				lpData->hEdit = GetDlgItem(hwndDlg,1002);

			}else{
				hwndEDIT = GetDlgItem(hwndDlg,1002);
				ShowWindow(hwndEDIT, SW_HIDE); 
				lpData->hEdit = GetDlgItem(hwndDlg,1001);
			}
			if(lpData->lpIntiTxt)//ʼı
				::SetWindowText (lpData->hEdit,lpData->lpIntiTxt);

			hwndEDIT = GetDlgItem(hwndDlg,1128);
			ShowWindow(hwndEDIT, SW_HIDE); 
			hwndEDIT = GetDlgItem(hwndDlg,65535);

			if(lpData->lpText)//ʾı
				::SetWindowText (hwndEDIT,lpData->lpText);
			else{
				
				ShowWindow(hwndEDIT, SW_HIDE); 
				RECT rect;
				INT x,y;
				INT offect = 57;

				hwndEDIT = GetDlgItem(hwndDlg,1);
				::GetWindowRect(hwndEDIT,&rect);
				::ScreenToClient (hwndDlg,(LPPOINT)&rect);
				x=rect.left;
				y=rect.top-offect;
				::SetWindowPos (hwndEDIT,NULL,x,y,0,0,SWP_NOSIZE|SWP_NOACTIVATE);

				hwndEDIT = GetDlgItem(hwndDlg,2);
				::GetWindowRect(hwndEDIT,&rect);
				::ScreenToClient (hwndDlg,(LPPOINT)&rect);
				x=rect.left;
				::SetWindowPos (hwndEDIT,NULL,x,y,0,0,SWP_NOSIZE|SWP_NOACTIVATE);

				::GetWindowRect(lpData->hEdit,&rect);
				::ScreenToClient (hwndDlg,(LPPOINT)&rect);
				x=rect.left;
				::SetWindowPos (lpData->hEdit,NULL,x,11,0,0,SWP_NOSIZE|SWP_NOACTIVATE);

				::GetWindowRect(hwndDlg,&rect);
				x=rect.right - rect.left;
				y=rect.bottom - rect.top-offect;
				::SetWindowPos (hwndDlg,NULL,0,0,x,y,SWP_NOMOVE|SWP_NOACTIVATE);




			}

			::SetWindowLong (hwndDlg,GWL_USERDATA,(LONG)lpData);

		}

		break;
	case WM_COMMAND: 
		{
			BMInputBoxDATA* lpData = (BMInputBoxDATA*)GetWindowLong (hwndDlg,GWL_USERDATA);
			INT nID = wParam & 0xffff;
			if(nID == IDCANCEL)
				DestroyWindow(hwndDlg);
			else if(nID == IDOK){
				
				INT nLen = ::GetWindowTextLength (lpData->hEdit);
				if(nLen>0)
				{
					lpData->lpUserInput = new char[nLen+1];
					GetWindowText(lpData->hEdit,lpData->lpUserInput,nLen+1);
				}
				lpData->bResult = TRUE;
				DestroyWindow(hwndDlg);
			}

		}

		break;
	case WM_CLOSE: 
		DestroyWindow(hwndDlg);
		break;
	case WM_DESTROY: 
 		// Perform cleanup tasks. 
 		PostQuitMessage(0); 
		//PostMessage (hwndDlg,WM_QUIT,0,0);
		break;
	default:
		return FALSE; 
		
	} 
	return TRUE; 
} 

LIBAPI(int, krnln_InputBox)
{
	BMInputBoxDATA data;
	HWND hParent = NULL;
	memset(&data,0,sizeof(BMInputBoxDATA));
	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[0].m_dtDataType !=_SDT_NULL && mystrlen(pArgInf[0].m_pText)>0)
		data.lpText = pArgInf[0].m_pText;
	if(pArgInf[1].m_dtDataType !=_SDT_NULL)
		data.lpTitle = pArgInf[1].m_pText;
	if(pArgInf[2].m_dtDataType !=_SDT_NULL)
		data.lpIntiTxt = pArgInf[2].m_pText;

	if(pArgInf[4].m_dtDataType ==_SDT_NULL)
		data.nType = 1;
	else{
		data.nType = pArgInf[4].m_int;
		if(data.nType<1 || data.nType>4)
			data.nType = 1;
	}

	if (6 <= nArgCount)
	{
		if(pArgInf[5].m_dtDataType !=_SDT_NULL)
			hParent = (HWND)pArgInf[5].m_int;
	}
	 
	LPBYTE lpDialogTemplate = BMInputBoxDialogTemplateData;
	HWND hDlg  = CreateDialogIndirectParam(::GetModuleHandle (NULL),(LPCDLGTEMPLATE)lpDialogTemplate, hParent, (DLGPROC)BMInputBoxDlgProc, (LPARAM)&data); 
	if(hDlg){
		ShowWindow(hDlg , SW_SHOW); 
		UpdateWindow(hDlg); 
		MSG msg; 
		while(GetMessage( &msg ,NULL,0,0))  { 
			//if(msg.message == WM_CLOSE)MessageBox(NULL,"exit",NULL,MB_OK);
			if(msg.hwnd==data.hEdit && msg.message == WM_CHAR){
				if(msg.wParam == 13)
					::SendMessage (hDlg,WM_COMMAND,IDOK,0);
				else if(data.nType==2 || data.nType==3){
					if( !(msg.wParam =='-' ||(msg.wParam >='0' && msg.wParam <='9') || (data.nType==3 && msg.wParam =='.')))
						continue;
				}

			}
				
			TranslateMessage(&msg); 
			DispatchMessage(&msg); 
		} 
	}
	BOOL bResult = data.bResult ;
	if(bResult){
		INT nLen = 0;
		
		if(data.lpUserInput)
			nLen = mystrlen(data.lpUserInput);
		else
			data.lpUserInput = (LPSTR)"0";

		switch (pArgInf[3].m_dtDataType) 
		{ 
		case SDT_TEXT: 
			E_MFree(*pArgInf[3].m_ppText);
			*pArgInf[3].m_ppText = CloneTextData(data.lpUserInput,nLen);
			break;
		case SDT_BYTE: 
			*pArgInf[3].m_pByte = (BYTE)atoi(data.lpUserInput);
			break;
		case SDT_SHORT: 
			*pArgInf[3].m_pShort = (SHORT)atoi(data.lpUserInput);
			break;
		case SDT_INT: 
			*pArgInf[3].m_pInt = atoi(data.lpUserInput);
			break;
		case SDT_INT64: 
			*pArgInf[3].m_pInt64 = _atoi64(data.lpUserInput);
			break;
		case SDT_FLOAT: 
			*pArgInf[3].m_pFloat = (FLOAT)atof(data.lpUserInput);
			break;
		case SDT_DOUBLE: 
			*pArgInf[3].m_pDouble = atof(data.lpUserInput);
			break;
		default:
			bResult = FALSE; 	
		} 

		if(nLen>0)
			delete [] data.lpUserInput;
	}
	return bResult; 

}
/*
int __cdecl krnln_fnInputBox(int a1, int a2, int a3)
{
  char *v3; // edi@2
  int v4; // eax@4
  signed int v5; // eax@12
  int v6; // edx@18
  unsigned int v7; // eax@19
  __int16 v8; // ax@24
  char v9; // al@25
  int v10; // eax@27
  double v11; // st7@31
  int v13; // edx@36
  char v14; // [sp+14h] [bp-F4h]@4
  char v15; // [sp+70h] [bp-98h]@7
  char v16; // [sp+74h] [bp-94h]@5
  char v17; // [sp+78h] [bp-90h]@9
  char *String; // [sp+7Ch] [bp-8Ch]@24
  int v19; // [sp+80h] [bp-88h]@11
  char v20; // [sp+84h] [bp-84h]@36
  char v21; // [sp+C4h] [bp-44h]@36

  if ( *(_DWORD *)(a3 + 8) )
    v3 = *(char **)a3;
  else
    v3 = 0;
  v4 = IsEmptyStr(v3);
  CInputDlg__CInputDlg(&v14, 0, v4 != 0 ? 1150 : 1037);
  if ( *(_DWORD *)(a3 + 8) )
    CString__operator_(&v16, v3);
  if ( *(_DWORD *)(a3 + 20) )
    CString__operator_(&v15, *(_DWORD *)(a3 + 12));
  if ( *(_DWORD *)(a3 + 32) )
    CString__operator_(&v17, *(_DWORD *)(a3 + 24));
  if ( !*(_DWORD *)(a3 + 56) )
  {
    v19 = 1;
    goto LABEL_18;
  }
  v5 = *(_DWORD *)(a3 + 48);
  if ( v5 > 4 )
    goto LABEL_39;
  if ( v5 < 1 )
  {
    v19 = 1;
    goto LABEL_18;
  }
  if ( v5 <= 4 )
    v19 = *(_DWORD *)(a3 + 48);
  else
LABEL_39:
    v19 = 4;
LABEL_18:
  if ( CDialog__DoModal(&v14) != 1 )
  {
    *(_DWORD *)a1 = 0;
    goto LABEL_36;
  }
  v7 = *(_DWORD *)(a3 + 44);
  if ( v7 > 0x80000301 )
  {
    if ( v7 == -2147482623 )
    {
      *(_QWORD *)*(_DWORD *)(a3 + 36) = _atoi64(String);
    }
    else
    {
      if ( v7 == -2147482367 )
      {
        **(float **)(a3 + 36) = atof(String);
        v6 = a1;
        *(_DWORD *)a1 = 1;
        goto LABEL_36;
      }
      if ( v7 == -2147482111 )
      {
        v11 = atof(String);
        v6 = a1;
        *(_QWORD *)*(_DWORD *)(a3 + 36) = *(_QWORD *)&v11;
        *(_DWORD *)a1 = 1;
        goto LABEL_36;
      }
    }
    goto LABEL_34;
  }
  if ( v7 == -2147482879 )
  {
    v10 = atoi(String);
    v6 = a1;
    **(_DWORD **)(a3 + 36) = v10;
    *(_DWORD *)a1 = 1;
    goto LABEL_36;
  }
  if ( v7 == -2147483644 )
  {
    krnl_MFree(**(_DWORD **)(a3 + 36));
    **(_DWORD **)(a3 + 36) = CloneTextData(String);
    v6 = a1;
    *(_DWORD *)a1 = 1;
    goto LABEL_36;
  }
  if ( v7 == -2147483391 )
  {
    v9 = atoi(String);
    v6 = a1;
    **(_BYTE **)(a3 + 36) = v9;
    *(_DWORD *)a1 = 1;
    goto LABEL_36;
  }
  if ( v7 != -2147483135 )
  {
LABEL_34:
    v6 = a1;
    *(_DWORD *)a1 = 1;
    goto LABEL_36;
  }
  v8 = atoi(String);
  v6 = a1;
  **(_WORD **)(a3 + 36) = v8;
  *(_DWORD *)a1 = 1;
LABEL_36:
  CInputEdit___CInputEdit(&v21, v6);
  CInputEdit___CInputEdit(&v20, v13);
  CString___CString(&String);
  CString___CString(&v17);
  CString___CString(&v16);
  CString___CString(&v15);
  return CDialog___CDialog(&v14);
}

  */
	/*
	HGLOBAL hDialogTemplate = NULL;
	HINSTANCE hInst = LoadLibrary("I:\\Program Files\\e5\\lib\\krnln.fne");
	HRSRC hResource = ::FindResource(hInst, (LPCSTR)1037, RT_DIALOG);
	hDialogTemplate = LoadResource(hInst, hResource);
	if (hDialogTemplate != NULL){
		INT nSize = ::SizeofResource (hInst,hResource);
		lpDialogTemplate = new BYTE[nSize];
		memcpy(lpDialogTemplate,LockResource(hDialogTemplate),nSize);

	HANDLE hFile = CreateFile("E:\\ҵֿ֧\\ֲ\\InputBox.dat",
		GENERIC_WRITE,
		0,
		NULL,
		CREATE_ALWAYS,
		FILE_ATTRIBUTE_ARCHIVE,
		0);
	
	BOOL bRet = FALSE;
	if(hFile != INVALID_HANDLE_VALUE)
	{

		DWORD dwNumOfByteRead;
		bRet = TRUE;


			if(WriteFile(hFile,lpDialogTemplate,nSize,&dwNumOfByteRead,NULL))
			{
				MessageBox(NULL,"OK1",NULL,MB_OK);

			}

		CloseHandle(hFile);
	}

	}

		
	UnlockResource(hDialogTemplate);
	FreeResource(hDialogTemplate);
	FreeLibrary(hInst);
*/


================================================
FILE: krnln/krnln_InsBin.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
#include "Myfunctions.h"
//ļд - ֽڼ
/*
    øʽ ߼͡ ֽڼ  дݵļţֽڼ дֽڼݣ...  - ϵͳֿ֧->ļд
    ӢƣInsBin
    һλֽڼݵļеǰдλôļʱ"#д""#Ķ"Ȩޡɹ棬ʧܷؼ١ΪһԱظӡ
    <1>ΪдݵļšΪͣintļɡļء
    <2>ΪдֽڼݡΪֽڼbin
*/
LIBAPI(BOOL, krnln_InsBin)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return NULL;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return NULL;
	PMDATA_INF pArgInf = &ArgInf;

	BOOL bRet = FALSE;

	if(pFile->nType ==1)//ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		INT orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
		if(orgLoc == HFILE_ERROR)
			return FALSE;

		DWORD dwNumOfByteRead;
		INT nBkLen = GetFileSize(hFile,NULL) - orgLoc;
		LPBYTE pBkData = NULL;
		if(nBkLen >0)
		{
			pBkData = new BYTE[nBkLen];
			if(!ReadFile(hFile, pBkData, nBkLen, &dwNumOfByteRead, 0))
			{
				delete[] pBkData;
				return FALSE;
			}
			SetFilePointer(hFile,orgLoc,NULL,FILE_BEGIN);//ָԭλ
		}

		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPBYTE pData = pArgInf[i].m_pBin + 2*sizeof(INT);
			INT nLen = pArgInf[i].m_pInt[1];

			if(WriteFile(hFile,pData,nLen,&dwNumOfByteRead,NULL)==FALSE)
			{
				bRet = FALSE;
				break;
			}
/*			if(FlushFileBuffers(hFile)==FALSE)
			{
				bRet = FALSE;
				break;
			}*/
		}
		if(bRet && pBkData)
		{
			orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);//µǰλ,Աָ
			if(WriteFile(hFile,pBkData, nBkLen,&dwNumOfByteRead,NULL))
			{
				SetFilePointer(hFile,orgLoc,NULL,FILE_BEGIN);//ָԭλ
//				if(FlushFileBuffers(hFile)==FALSE)
//					bRet = FALSE;
			}
			else
				bRet = FALSE;
		}
		if(pBkData)
			delete[] pBkData;

	}else if(pFile->nType ==2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*) pFile->FileHandle;
		LPBYTE pBufStart, pBufMax;

		INT orgLoc = pMemFile->GetPosition();

		INT nBkLen = pMemFile->GetBufferPtr (CMyMemFile::bufferRead,-1,(void **)&pBufStart,(void **)&pBufMax);
		LPBYTE pBkData = NULL;
		if(nBkLen >0)
		{
			pBkData = new BYTE[nBkLen];
			memcpy(pBkData,pBufStart,nBkLen);
		}

		pMemFile->Seek (orgLoc,CMyMemFile::begin);

		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPBYTE pData = pArgInf[i].m_pBin + 2*sizeof(INT);
			INT nLen = pArgInf[i].m_pInt[1];
			pMemFile->Write(pData,nLen);
		}
		if(pBkData)
		{
			orgLoc = pMemFile->GetPosition();
			pMemFile->Write(pBkData, nBkLen);
			delete[] pBkData;
			pMemFile->Seek (orgLoc,CMyMemFile::begin);
		}

	}else if(pFile->nType == 3)//ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		INT orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
		if(orgLoc == HFILE_ERROR)
			return FALSE;

		DWORD dwNumOfByteRead;
		INT nBkLen = GetFileSize(hFile,NULL) - orgLoc;
		LPBYTE pBkData = NULL;
		if(nBkLen >0)
		{
			pBkData = new BYTE[nBkLen];
			if(!ReadFile(hFile, pBkData, nBkLen, &dwNumOfByteRead, 0))
			{
				delete[] pBkData;
				return FALSE;
			}
			nBkLen = dwNumOfByteRead;
			E_RC4_Calc(orgLoc, (unsigned char*)pBkData, nBkLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
			SetFilePointer(hFile,orgLoc,NULL,FILE_BEGIN);//ָԭλ
		}

		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPBYTE pData = pArgInf[i].m_pBin + 2*sizeof(INT);
			INT nLen = pArgInf[i].m_pInt[1];
			INT nPos = SetFilePointer(hFile,0,NULL,FILE_CURRENT);

			LPBYTE pTMP = (LPBYTE)malloc(nLen);
			memcpy(pTMP, pData, nLen);
			pData = pTMP;

			E_RC4_Calc(orgLoc, (unsigned char*)pData, nLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
			if(WriteFile(hFile,pData,nLen,&dwNumOfByteRead,NULL)==FALSE)
			{
				free(pData);
				bRet = FALSE;
				break;
			}
			free(pData);
		}
		if(bRet && pBkData)
		{
			orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);//µǰλ,Աָ
			E_RC4_Calc(orgLoc, (unsigned char*)pBkData, nBkLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
			if(WriteFile(hFile,pBkData, nBkLen,&dwNumOfByteRead,NULL))
			{
				SetFilePointer(hFile,orgLoc,NULL,FILE_BEGIN);//ָԭλ
			}
			else
				bRet = FALSE;
		}
		if(pBkData)
			delete[] pBkData;
	}
	return bRet;
}


================================================
FILE: krnln/krnln_InsLine.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
#include "Myfunctions.h"

//ļд - ı
/*
    øʽ ߼͡ ı  дıļţͨ дı...  - ϵͳֿ֧->ļд
    ӢƣInsLine
    һλıеļеǰдλôļʱ"#д""#Ķ"Ȩޡɹ棬ʧܷؼ١ΪһԱظӡ
    <1>ΪдıļšΪͣintļɡļء
    <2>ΪдıΪͨͣallֵΪıݣԶת޷תΪֽڼӳָ롢ûԶͣдݡ
*/
LIBAPI(BOOL, krnln_InsLine)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return NULL;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return NULL;
	PMDATA_INF pArgInf = &ArgInf;

	BOOL bRet = FALSE;

	if(pFile->nType ==1)//ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		INT orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
		if(orgLoc == HFILE_ERROR)
			return FALSE;

		DWORD dwNumOfByteRead;
		INT nBkLen = GetFileSize(hFile,NULL) - orgLoc;
		LPBYTE pBkData = NULL;
		if(nBkLen >0)
		{
			pBkData = new BYTE[nBkLen];
			if(!ReadFile(hFile, pBkData, nBkLen, &dwNumOfByteRead, 0))
			{
				delete[] pBkData;
				return FALSE;
			}
			SetFilePointer(hFile,orgLoc,NULL,FILE_BEGIN);//ָԭλ
		}

		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPSTR pData;
			BOOL bNeedFree = FALSE;
			if(pArgInf[i].m_dtDataType == SDT_TEXT)
				pData = pArgInf[i].m_pText;
			else
			{
				pData = SDataToStr(&pArgInf[i]);
				if(pData == NULL)
				{
					WriteFile(hFile,"\r\n",2,&dwNumOfByteRead,NULL);
//					FlushFileBuffers(hFile);
					continue;
				}
				bNeedFree = TRUE;
			}

			INT nLen = mystrlen(pData);
			if(nLen>0)
			{
				if(WriteFile(hFile,pData,nLen,&dwNumOfByteRead,NULL))
				{
					WriteFile(hFile,"\r\n",2,&dwNumOfByteRead,NULL);
//					if(FlushFileBuffers(hFile)==FALSE)
//						bRet = FALSE;
				}
				else
					bRet = FALSE;
			}

			if(bNeedFree)
				free(pData);

			if(bRet == FALSE)
				break;

		}
		if(bRet && pBkData)//Ϻ
		{
			orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);//µǰλ,Աָ
			if(WriteFile(hFile,pBkData, nBkLen,&dwNumOfByteRead,NULL))
			{
				SetFilePointer(hFile,orgLoc,NULL,FILE_BEGIN);//ָԭλ
//				if(FlushFileBuffers(hFile)==FALSE)
//					bRet = FALSE;
			}
			else
				bRet = FALSE;
			
		}
		if(pBkData)
			delete[] pBkData;

	}else if(pFile->nType ==2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*) pFile->FileHandle;

		INT orgLoc = pMemFile->GetPosition();

		LPBYTE pBufStart, pBufMax;

		INT nBkLen = pMemFile->GetBufferPtr (CMyMemFile::bufferRead,-1,(void **)&pBufStart,(void **)&pBufMax);
		LPBYTE pBkData = NULL;
		if(nBkLen >0)
		{
			pBkData = new BYTE[nBkLen];
			memcpy(pBkData,pBufStart,nBkLen);
		}

		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPSTR pData;
			BOOL bNeedFree = FALSE;
			if(pArgInf[i].m_dtDataType == SDT_TEXT)
				pData = pArgInf[i].m_pText;
			else
			{
				pData = SDataToStr(&pArgInf[i]);
				if(pData == NULL)
					continue;
				bNeedFree = TRUE;
			}

			INT nLen = mystrlen(pData);
			if(nLen>0)
				pMemFile->Write(pData,nLen);
			pMemFile->Write("\r\n",2);

			if(bNeedFree)
				free(pData);
		}
		if(pBkData)
		{
			orgLoc = pMemFile->GetPosition();
			pMemFile->Write(pBkData, nBkLen);
			delete[] pBkData;
			pMemFile->Seek (orgLoc,CMyMemFile::begin);
		}

	}else if(pFile->nType ==3)//ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		INT orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
		if(orgLoc == HFILE_ERROR)
			return FALSE;
		
		DWORD dwNumOfByteRead;
		INT nPos;
		INT nBkLen = GetFileSize(hFile,NULL) - orgLoc;
		LPBYTE pBkData = NULL;
		if(nBkLen >0)
		{
			pBkData = new BYTE[nBkLen];
			if(!ReadFile(hFile, pBkData, nBkLen, &dwNumOfByteRead, 0))
			{
				delete[] pBkData;
				return FALSE;
			}
			nBkLen = dwNumOfByteRead;
			E_RC4_Calc(orgLoc, (unsigned char*)pBkData, nBkLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
			SetFilePointer(hFile,orgLoc,NULL,FILE_BEGIN);//ָԭλ
		}

		unsigned char pszRN[2] = {0};
		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPSTR pData;
			BOOL bNeedFree = FALSE;
			if(pArgInf[i].m_dtDataType == SDT_TEXT)
				pData = pArgInf[i].m_pText;
			else
			{
				pData = SDataToStr(&pArgInf[i]);
				if(pData == NULL)
				{
					nPos = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
					pszRN[0] = '\r';
					pszRN[1] = '\n';
					E_RC4_Calc(nPos, pszRN, 2, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
					WriteFile(hFile, pszRN, 2, &dwNumOfByteRead,NULL);
					continue;
				}
				bNeedFree = TRUE;
			}
			
			INT nLen = mystrlen(pData);
			if(nLen>0)
			{
				if (!bNeedFree)
				{
					LPSTR pTMP = (LPSTR)malloc(nLen);
					memcpy(pTMP, pData, nLen);
					pData = pTMP;
					bNeedFree = TRUE;
				}
				nPos = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
				E_RC4_Calc(nPos, (unsigned char*)pData, nLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
				if(WriteFile(hFile,pData,nLen,&dwNumOfByteRead,NULL))
				{
					nPos = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
					pszRN[0] = '\r';
					pszRN[1] = '\n';
					E_RC4_Calc(nPos, pszRN, 2, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
					WriteFile(hFile, pszRN, 2, &dwNumOfByteRead,NULL);
				}
				else
					bRet = FALSE;
			}
			
			if(bNeedFree)
				free(pData);
			
			if(bRet == FALSE)
				break;
		}

		if(bRet && pBkData)//Ϻ
		{
			orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);//µǰλ,Աָ
			E_RC4_Calc(orgLoc, (unsigned char*)pBkData, nBkLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
			if(WriteFile(hFile,pBkData, nBkLen,&dwNumOfByteRead,NULL))
				SetFilePointer(hFile,orgLoc,NULL,FILE_BEGIN);//ָԭλ
			else
				bRet = FALSE;
		}
		if(pBkData)
			delete[] pBkData;
	}
	return bRet;
}


================================================
FILE: krnln/krnln_InsText.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
#include "Myfunctions.h"

//ļд - ı
/*
    øʽ ߼͡ ı  дıļţͨ дı...  - ϵͳֿ֧->ļд
    ӢƣInsText
    һλıݵļеǰдλôļʱ"#д""#Ķ"Ȩޡɹ棬ʧܷؼ١ΪһԱظӡ
    <1>ΪдıļšΪͣintļɡļء
    <2>ΪдıΪͨͣallֵΪıݣԶת޷תΪֽڼӳָ롢ûԶͣдݡ
*/
LIBAPI(BOOL, krnln_InsText)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return NULL;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return NULL;
	PMDATA_INF pArgInf = &ArgInf;

	BOOL bRet = FALSE;

	if(pFile->nType ==1)//ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		INT orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
		if(orgLoc == HFILE_ERROR)
			return FALSE;


		DWORD dwNumOfByteRead;
		INT nBkLen = GetFileSize(hFile,NULL) - orgLoc;
		LPBYTE pBkData = NULL;
		if(nBkLen >0)
		{
			pBkData = new BYTE[nBkLen];
			if(!ReadFile(hFile, pBkData, nBkLen, &dwNumOfByteRead, 0))
			{
				delete[] pBkData;
				return FALSE;
			}
			SetFilePointer(hFile,orgLoc,NULL,FILE_BEGIN);//ָԭλ
		}

		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPSTR pData;
			BOOL bNeedFree = FALSE;
			if(pArgInf[i].m_dtDataType == SDT_TEXT)
				pData = pArgInf[i].m_pText;
			else
			{
				pData = SDataToStr(&pArgInf[i]);
				if(pData == NULL)
					continue;
				bNeedFree = TRUE;
			}

			INT nLen = mystrlen(pData);
			if(nLen>0)
			{
				if(WriteFile(hFile,pData,nLen,&dwNumOfByteRead,NULL))
				{
//					if(FlushFileBuffers(hFile)==FALSE)
//						bRet = FALSE;
				}
				else
					bRet = FALSE;
			}

			if(bNeedFree)
				free(pData);

			if(bRet == FALSE)
				break;

		}
		if(bRet && pBkData)
		{
			orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);//µǰλ,Աָ
			if(WriteFile(hFile,pBkData, nBkLen,&dwNumOfByteRead,NULL))
			{
				SetFilePointer(hFile,orgLoc,NULL,FILE_BEGIN);//ָԭλ
//				if(FlushFileBuffers(hFile)==FALSE)
//					bRet = FALSE;
			}
			else
				bRet = FALSE;
			
		}
		if(pBkData)
			delete[] pBkData;
		
		

	}else if(pFile->nType ==2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*) pFile->FileHandle;

		INT orgLoc = pMemFile->GetPosition();

		LPBYTE pBufStart, pBufMax;

		INT nBkLen = pMemFile->GetBufferPtr (CMyMemFile::bufferRead,-1,(void **)&pBufStart,(void **)&pBufMax);
		LPBYTE pBkData = NULL;
		if(nBkLen >0)
		{
			pBkData = new BYTE[nBkLen];
			memcpy(pBkData,pBufStart,nBkLen);
		}

		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPSTR pData;
			BOOL bNeedFree = FALSE;
			if(pArgInf[i].m_dtDataType == SDT_TEXT)
				pData = pArgInf[i].m_pText;
			else
			{
				pData = SDataToStr(&pArgInf[i]);
				if(pData == NULL)
					continue;
				bNeedFree = TRUE;
			}

			INT nLen = mystrlen(pData);
			if(nLen>0)
				pMemFile->Write(pData,nLen);

			if(bNeedFree)
				free(pData);
		}
		if(pBkData)
		{
			orgLoc = pMemFile->GetPosition();
			pMemFile->Write(pBkData, nBkLen);
			delete[] pBkData;
			pMemFile->Seek (orgLoc,CMyMemFile::begin);
		}

	}else if(pFile->nType ==3)//ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		INT orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
		if(orgLoc == HFILE_ERROR)
			return FALSE;
		
		
		DWORD dwNumOfByteRead;
		INT nBkLen = GetFileSize(hFile,NULL) - orgLoc;
		LPBYTE pBkData = NULL;
		if(nBkLen >0)
		{
			pBkData = new BYTE[nBkLen];
			if(!ReadFile(hFile, pBkData, nBkLen, &dwNumOfByteRead, 0))
			{
				delete[] pBkData;
				return FALSE;
			}
			nBkLen = dwNumOfByteRead;
			E_RC4_Calc(orgLoc, (unsigned char*)pBkData, nBkLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
			SetFilePointer(hFile,orgLoc,NULL,FILE_BEGIN);//ָԭλ
		}
		
		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPSTR pData;
			BOOL bNeedFree = FALSE;
			INT nPos = SetFilePointer(hFile,0,NULL,FILE_CURRENT);

			if(pArgInf[i].m_dtDataType == SDT_TEXT)
				pData = pArgInf[i].m_pText;
			else
			{
				pData = SDataToStr(&pArgInf[i]);
				if(pData == NULL)
					continue;
				bNeedFree = TRUE;
			}
			
			INT nLen = mystrlen(pData);
			if(nLen>0)
			{
				if (!bNeedFree)
				{
					LPSTR pTMP = (LPSTR)malloc(nLen);
					memcpy(pTMP, pData, nLen);
					pData = pTMP;
					bNeedFree = TRUE;
				}
				E_RC4_Calc(nPos, (unsigned char*)pData, nLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
				if(!WriteFile(hFile,pData,nLen,&dwNumOfByteRead,NULL))
					bRet = FALSE;
			}
			
			if(bNeedFree)
				free(pData);
			
			if(bRet == FALSE)
				break;
		}
		if(bRet && pBkData)
		{
			orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);//µǰλ,Աָ
			E_RC4_Calc(orgLoc, (unsigned char*)pBkData, nBkLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
			if(WriteFile(hFile,pBkData, nBkLen,&dwNumOfByteRead,NULL))
			{
				SetFilePointer(hFile,orgLoc,NULL,FILE_BEGIN);//ָԭλ
			}
			else
				bRet = FALSE;
		}
		if(pBkData)
			delete[] pBkData;	
	}
	return bRet;
}


================================================
FILE: krnln/krnln_IsCalcOK.cpp
================================================
#include "stdafx.h"
#include <float.h>
// - Ƿȷ
/*
    øʽ ߼͡ Ƿȷ ˫С Уļ - ϵͳֿ֧->
    ӢƣIsCalcOK
    ԳˡηƽֵֵֵֵȻ󷴶ȵѧ˫ȽֵУ飬ֵȷЧ档ֵĽؼ١Ϊ
    <1>ΪУļΪ˫Сͣdouble

*/
LIBAPI(BOOL, krnln_IsCalcOK)
{
	if(_finite(ArgInf.m_double)!=0)
		return TRUE;
	return FALSE;

}


================================================
FILE: krnln/krnln_IsDebugVer.cpp
================================================
#include "stdafx.h"

// - ǷΪ԰

extern "C" void _cdecl krnln_IsDebugVer (INT nArgCount,MDATA_INF ArgInf,...)
{

}


================================================
FILE: krnln/krnln_IsFileExist.cpp
================================================
#include "stdafx.h"
#include <SHLWAPI.h>
#pragma comment(lib,"SHLWAPI.lib") 
//̲ - ļǷ
/*
    øʽ ߼͡ ļǷ ı Եļƣ - ϵͳֿ֧->̲
    ӢƣIsFileExist
    жָĴļǷʵڡڷ棬򷵻ؼ١Ϊ
    <1>ΪԵļơΪıͣtext
*/
LIBAPI(BOOL, krnln_IsFileExist)
{
	return PathFileExists(ArgInf.m_pText);
}


================================================
FILE: krnln/krnln_IsHaveTextInClip.cpp
================================================
#include "stdafx.h"

//ϵͳ - пı
/*
    øʽ ߼͡ пı  - ϵͳֿ֧->ϵͳ
    ӢƣIsHaveTextInClip
    ǰ Windows ϵͳıݣ򷵻棬򷵻ؼ١Ϊ
*/
LIBAPI(BOOL, krnln_IsHaveTextInClip)
{
	BOOL bRet = FALSE;
	if(OpenClipboard(NULL))
	{
		HANDLE hClip =  GetClipboardData(CF_TEXT);
		if(hClip)
			bRet = TRUE;
		CloseClipboard();
	}
	return bRet;
}


================================================
FILE: krnln/krnln_IsRegItemExist.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

#pragma comment(lib,"advapi32.lib") 
//ϵͳ - עǷ
/*
    øʽ ߼͡ עǷ  Ŀ¼ı ȫ·ע - ϵͳֿ֧->ϵͳ
    ӢƣIsRegItemExist
    ָעڣ棬򷵻ؼ١עǷĬֵĿӡ\ţ硰test\Ϊм
    <1>ΪĿ¼ΪͣintΪ³ֵ֮һ 1#ࣻ 2#ã 3#û 4#ػ 5#û
    <2>Ϊȫ·עΪıͣtext
*/
LIBAPI(BOOL, krnln_IsRegItemExist)
{
	PMDATA_INF pArgInf = &ArgInf;
	HKEY hRootkey = GetRegRootVal(pArgInf[0].m_int);
	BOOL bRet = FALSE;
	INT nLen = mystrlen(pArgInf[1].m_pText);
	if(hRootkey && nLen)
	{
		HKEY hkey;
		LPSTR pSubkey = new char [nLen +1];
		strcpy(pSubkey,pArgInf[1].m_pText);
		LPSTR pKeyname = strrchr(pSubkey,'\\');
		if(pKeyname)
		{
			*pKeyname = 0;
			pKeyname++;
		}
		if(RegOpenKey(hRootkey,pSubkey,&hkey)==ERROR_SUCCESS)
		{
			DWORD nLen = MAX_PATH;
			DWORD dwType;
			char sRetVal[MAX_PATH];
			INT nRet = RegQueryValueEx(hkey,pKeyname,NULL,&dwType,(LPBYTE)sRetVal,&nLen);
			if(ERROR_SUCCESS == nRet || nRet == ERROR_MORE_DATA)
			{
				bRet = TRUE;
			}
			RegCloseKey(hkey);
		}
		delete [] pSubkey;
	}

	return bRet;
}


================================================
FILE: krnln/krnln_LCase.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
//ı - Сд
/*
    øʽ ı͡ Сд ı 任ı - ϵͳֿ֧->ı
    ӢƣLCase
    ıеĴдӢĸ任ΪСдر任ĽıΪ
    <1>Ϊ任ıΪıͣtext
*/
LIBAPI(char*, krnln_LCase)
{// ߺŸ
	register char* pSrc = ArgInf.m_pText;
	UINT nLen = mystrlen(pSrc);
	if (nLen==0) return NULL;
	char *pText = (char*)E_MAlloc_Nzero(nLen+1);
	register char* pDes = pText;
	register unsigned char* ltb = lowtable;
	for (UINT i=0; i<nLen; i++)
	{
		if (pSrc[i]<0)
		{
			*((short*)(pDes+i)) = *((short*)(pSrc+i));
			i++;
		}
		else
		{
			pDes[i] = ltb[(unsigned char)(pSrc[i])];
		}
	}
	pText[nLen] = '\0';
	return pText;
}
// {// ԭ
// 	UINT nLen = strlen(ArgInf.m_pText);
// 	if(nLen==0)return NULL;
// 	char *pText = (char*)E_MAlloc(nLen+1);
// 	strcpy(pText,ArgInf.m_pText);
// 	UINT i=0;
// 	while(i < nLen)
// 	{
// 		if(pText[i]<0)
// 			i+=2;//
// 		else
// 		{
// 			pText[i] = tolower(pText[i]);
// 			i++;
// 		}
// 
// 	}
// 	return pText;	
// }


================================================
FILE: krnln/krnln_LTrim.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

//ı - ɾ׿
/*
    øʽ ı͡ ɾ׿ ı ɾոı - ϵͳֿ֧->ı
    ӢƣLTrim
    һıаɾײȫǻǿոָıΪ
    <1>ΪɾոıΪıͣtext

*/
LIBAPI(char*, krnln_LTrim)
{// ߺ 
	PMDATA_INF pArgInf = &ArgInf;
	register unsigned char *str1 = (unsigned char*)pArgInf[0].m_pText;

	while ( *str1 )
	{
		if (*str1 == ' ')
			str1++;
		else if (*((unsigned short*)str1) == 0xA1A1)
			str1+=2;
		else
			break;
	}

	if (!*str1) return NULL; //ıֱӷ
	INT nLen = mystrlen((char*)str1);
	char *pText = (char*)E_MAlloc_Nzero(nLen+1);
	memcpy(pText, str1, nLen+1);
	
	return pText;
}
// {// ԭ
// 	INT nLen = strlen(ArgInf.m_pText);
// 	if(nLen==0)return NULL;
// 	INT i = 0;
// 	char* pSrc = ArgInf.m_pText;
// 	while(i < nLen)
// 	{
// 		if(*pSrc == ' ' || strncmp(pSrc,"",2)==0)
// 		{
// 			if(*pSrc< 0)
// 			{
// 				i+=2;
// 				pSrc+=2;
// 			}
// 			else
// 			{
// 				pSrc++;
// 				i++;
// 			}
// 		}
// 		else
// 			break;
// 
// 	}
// 	nLen = strlen(pSrc);
// 	if(nLen==0)return NULL;
// 
// 	char *pText = (char*)E_MAlloc(nLen+1);
// 	strcpy(pText,pSrc);
// 
// 	return pText;
// 
// }


================================================
FILE: krnln/krnln_MakeLong.cpp
================================================
#include "stdafx.h"

//λ - ϲ
/*
    øʽ ͡ ϲ  ϲ1 ϲ2 - ϵͳֿ֧->λ
    ӢƣMakeLong
    һĵ16λõĵ16λڶĵ16λõĸ16λԴ˺ϲһغϲĽΪм
    <1>Ϊϲ1Ϊͣint
    <2>Ϊϲ2Ϊͣint
*/
LIBAPI(int, krnln_MakeLong)
{
	PMDATA_INF pArg = &ArgInf;
	int n = MAKELONG (pArg[0].m_int, pArg[1].m_int);
	return n;
}


================================================
FILE: krnln/krnln_MakeWord.cpp
================================================
#include "stdafx.h"

//λ - ϲ
/*
    øʽ ͡ ϲ  ϲ1 ϲ2 - ϵͳֿ֧->λ
    ӢƣMakeWord
    һĵ8λõĵ8λڶĵ8λõĸ8λԴ˺ϲһغϲĽΪм
    <1>Ϊϲ1Ϊͣint
    <2>Ϊϲ2Ϊͣint
*/
LIBAPI(int, krnln_MakeWord)
{
	PMDATA_INF pArg = &ArgInf;
	int n = MAKEWORD (pArg[0].m_int, pArg[1].m_int);
	return n;
}


================================================
FILE: krnln/krnln_MkDir.cpp
================================================
#include "stdafx.h"

//̲ - Ŀ¼
/*
    øʽ ߼͡ Ŀ¼ ı Ŀ¼ƣ - ϵͳֿ֧->̲
    ӢƣMkDir
    һµĿ¼ɹ棬ʧܷؼ١Ϊ
    <1>ΪĿ¼ơΪıͣtext
*/
LIBAPI(BOOL, krnln_MkDir)
{
	SECURITY_ATTRIBUTES SecAttrib;
	SecAttrib.nLength=sizeof(SECURITY_ATTRIBUTES);
	SecAttrib.lpSecurityDescriptor = NULL;
	SecAttrib.bInheritHandle = FALSE;
	
	return CreateDirectory(ArgInf.m_pText,&SecAttrib);//Ŀ¼
}


================================================
FILE: krnln/krnln_MsgBox.cpp
================================================
#include "stdafx.h"
#include <stdio.h>
#include "LTrimZeroChr.h"

//#pragma comment(lib,"oleaut32.lib") 

//ϵͳ - Ϣ
/*
    øʽ ͡ Ϣ ͨ ʾϢ ťı ڱݣ - ϵͳֿ֧->ϵͳ
    ӢƣMsgBox
    ڶԻʾϢȴûťһûһťΪ³ֵ֮һ 0#ȷť 1#ȡť 2#ť 3#ť 4#ť 5#ť 6#ťԻСȡť ESC 뵥ȡťЧͬΪ
    <1>ΪʾϢΪͨͣallʾϢֻΪıֵ߼ֵʱ䡣ʾϢΪıҰУڸ֮ûس (ַ (13))з (ַ (10)) سз (ַ (13) + ַ (10)) ָ
    <2>ΪťΪͣintʼֵΪ0ֵ¼鳣ֵɣڽЩֵɲֵʱÿֵֻȡһ֣⣩ 
  һ飨ԻʾťĿ
    0#ȷť 1#ȷȡť 2#Ժť 3#ȡǷť     4#Ƿť 5#ȡť
  ڶ飨ͼʽ
    16#ͼꣻ 32#ѯͼꣻ 48#ͼꣻ 64#Ϣͼ
  飨˵һťȱʡĬֵ
    0#Ĭϰťһ 256#Ĭϰť 512#Ĭϰť 768#Ĭϰť
  飨εȴϢ
    0#ȴ 4096#ϵͳȴ
  飨
    65536#λǰ̨ 524288#ıҶ

    <3>Ϊڱ⡱ΪıͣtextԱʡԡֵָʾڶԻеıʡԣĬΪıϢ
*/

LIBAPI(int, krnln_MsgBox)
{
	char str [MAX_PATH];
    HWND hWnd=NULL;
	LPCSTR lpText=NULL;
	LPCSTR lpCaption="Ϣ";
    UINT uType=MB_OK;

	if((ArgInf.m_dtDataType & DT_IS_ARY) == 0)//
	{
		
		
		switch(ArgInf.m_dtDataType)
		{
		case SDT_TEXT:
			lpText = ArgInf.m_pText;
			break;
		case SDT_BYTE:
			{
				INT nVal = ArgInf.m_byte;
				sprintf(str,"%d",nVal);
				lpText = str;
			}
			break;
		case SDT_SHORT:
			{
				INT nVal = ArgInf.m_short;
				sprintf(str,"%d",nVal);
				lpText = str;
			}
			break;
		case SDT_INT:
		case SDT_SUB_PTR:
			sprintf(str,"%d",ArgInf.m_int);
			lpText = str;
			break;
		case SDT_INT64:
			sprintf(str,"%I64d",ArgInf.m_int64);
			lpText = str;
			break;
		case SDT_FLOAT:
			sprintf(str,"%f",ArgInf.m_float);
			LTrimZeroChr(str);
			lpText = str;
			break;
		case SDT_DOUBLE:
			sprintf(str,"%.13g",ArgInf.m_double);
			LTrimZeroChr(str);
			lpText = str;
			break;
		case SDT_BOOL:
			if(ArgInf.m_bool)
				strcpy(str,"");
			else
				strcpy(str,"");
			lpText = str;
			break;

		case SDT_DATE_TIME:
			DateTimeFormat(str,ArgInf.m_double);
			lpText = str;
		}

	}
	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[1].m_dtDataType!=_SDT_NULL)
	{
		uType=pArgInf[1].m_int;
	}
	if(pArgInf[2].m_dtDataType!=_SDT_NULL)
	{
		lpCaption=pArgInf[2].m_pText;
	}
	if(nArgCount>3)//5.3""
	{
		if(pArgInf[3].m_dtDataType==SDT_INT)
		{
			hWnd=(HWND)pArgInf[3].m_int;
		}
	}
	INT nRet = MessageBox(hWnd,lpText,lpCaption,uType);
	return (nRet-1);
}


================================================
FILE: krnln/krnln_NumToRMB.cpp
================================================
#include "stdafx.h"
#include <math.h>
#include "Myfunctions.h"

//ֵת - ֵд 
/*
    øʽ ı͡ ֵ ˫С תʽֵ߼ ǷתΪ壩 - ϵͳֿ֧->ֵת
    ӢƣNumToRMB
    ֵתΪļдʽתıΪ
    <1>ΪתʽֵΪ˫Сͣdouble
    <2>ΪǷתΪ塱Ϊ߼ͣboolʼֵΪ١ֵΪ٣תΪ塣
*/
LIBAPI(char*, krnln_NumToRMB)
{
	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[0].m_double<0)
		return NULL;
	double dInt;
	double dFloat = modf(pArgInf[0].m_double,&dInt);
	LPSTR pInt = NULL;
	LPSTR pFloat = NULL;
	INT nLen = 64;
	INT nPre=1;
	if(dInt !=0)
	{
		pInt = IntNumToChn(dInt,pArgInf[1].m_bool,nPre);
		nLen += mystrlen(pInt);
	}

	if(dFloat !=0)
	{
		pFloat = FloatNumToRMB(dFloat,pArgInf[1].m_bool);
		if(pFloat)
			nLen += mystrlen(pFloat);
	}
	
	LPSTR pText = (LPSTR)E_MAlloc (nLen);
	if(pFloat==NULL && pInt==NULL)
	{
		strcpy(pText,"");
		return pText;
	}
	*pText=0;//MessageBox(NULL,pText,NULL,MB_OK);
	if(pInt)
	{
		strcpy(pText,pInt);
		free(pInt);
		strcat(pText,"Ԫ");
	}

	if(pFloat && *pFloat)
	{
		if(pInt && nPre==0)
			strcat(pText,"");
		strcat(pText,pFloat);
		free(pFloat);
	}
	else
		strcat(pText,"");

	return pText;	
}


================================================
FILE: krnln/krnln_NumToText.cpp
================================================
#include "stdafx.h"
#include <stdio.h>
#include "LTrimZeroChr.h"
#include "Myfunctions.h"

//ֵת - ֵʽı 
/*
    øʽ ı͡ ֵʽı ˫С תΪıֵ Сλݣ߼ Ƿǧλָ - ϵͳֿ֧->ֵת
    ӢƣNumToText
    һıֵָʽתĽΪ
    <1>ΪתΪıֵΪ˫Сͣdouble
    <2>ΪСλΪͣintԱʡԡ0ʾСұӦ뱣λ0ʾ뵽С0ʾС뵽λá磺ֵʽı (1056.65, 1, )  1056.7 ֵʽı (1056.65, 0, )  1057 ֵʽı (1056.65, -1, )  1060ʡԱĬΪʵʴڵСλ
    <3>ΪǷǧλָΪ߼ͣboolʼֵΪ١ֵΪ棬ֵıÿǧλ϶ԶһŽзָ
*/
LIBAPI(char*, krnln_NumToText)
{
	PMDATA_INF pArgInf = &ArgInf;
	char str [MAX_PATH];
	char strFomar [MAX_PATH];
	if(pArgInf[1].m_dtDataType == _SDT_NULL)
	{
		strcpy(strFomar,"%lf");
		
	}
	else
	{
		INT nNum = pArgInf[1].m_int;
		if(nNum <0)
			nNum = 0;
		if(nNum>8)
			nNum = 8;
		sprintf(&strFomar[1],".%dlf",nNum);
		strFomar[0]='%';
	}

	sprintf(str,strFomar,ArgInf.m_double);
	if(pArgInf[1].m_dtDataType == _SDT_NULL)
		LTrimZeroChr(str);

	if(pArgInf[2].m_bool)
	{
		strcpy(strFomar,str);
		LPSTR pStr = strFomar;
		while(*pStr!=0 && *pStr !='.')
			pStr++;
		INT nNum = pStr - strFomar;
		pStr = strFomar;
		if(strFomar[0]=='-')
		{
			nNum--;
			pStr++;
		}
		if(nNum>3)
		{
			INT nMax = nNum/3;
			INT nMod = nNum % 3;
			if(nMod)
				nMax++;
			INT i = 0;
			LPSTR pSrc = strFomar;
			LPSTR pDest = str;
			
			while(i<nMax)
			{
				if(i==0 && nMod)
					pStr+=nMod;
				else
					pStr+=3;
				nNum = pStr - pSrc;
				
				if(i == nMax-1)
				{
					strcat(pDest,pSrc);
					break;
				}
				strncpy(pDest,pSrc,nNum);
				pDest+=nNum;
				*pDest=',';
				pDest++;
				*pDest=0;
				
				pSrc+=nNum;
				pStr=pSrc;
				i++;
				
			}
		}



	}
	INT nLen = mystrlen(str);
	char *pText = (char*)E_MAlloc(nLen+1);
	strcpy(pText,str);
	return pText;
}

================================================
FILE: krnln/krnln_OpenManyFileDialog.cpp
================================================
#include "stdafx.h"
#include <stdio.h>
#include "mem.h"
#include "Myfunctions.h"
#pragma comment(lib,"comdlg32.lib") 

//ϵͳ - ļԻ
/*
    øʽ ı页 ļԻ ı ݣı ݣ ʼݣı ʼĿ¼ݣ߼ ıĿ¼ݣ - ϵͳֿ֧->ϵͳ
    ӢƣOpenManyFileDialog
    ʾһļ򿪶ԻûѡҪ򿪵ѴļûѡĽı顣ûδ򰴡ȡť˳򷵻һԱΪ0Ŀı顣Ϊ
    <1>Ϊ⡱ΪıͣtextԱʡԡָļ򿪶Իı⣬ʡԣĬΪ򿪵ļ
    <2>ΪΪıͣtextԱʡԡıɵɶԵıɣÿıĵһʾʽ磺ıļ*.txtڶָʵʵĹƥ磺*.txtиı֮á|ŸʡԣĬûй
    <3>ΪʼΪͣintԱʡԡһṩЧĹı򱾲ָʼĹ0ΪһʡԣĬֵΪ0
    <4>ΪʼĿ¼ΪıͣtextԱʡԡָ򿪶ԻʱԶתĿ¼ʡԣĬΪǰĿ¼
    <5>ΪıĿ¼Ϊ߼ͣboolԱʡԡָڶԻرպǷԶصԻǰļĿ¼ʡԣĬֵΪ١
    <6>ΪڡΪͨͣallԱʡԡָԻĸ,һ""ݻһʹھ.ʡ,ĬΪ.

*/
LIBAPI(void*, krnln_OpenManyFileDialog)
{
	PMDATA_INF pArgInf = &ArgInf;
	CMyDWordArray aryText;

	OPENFILENAME fileinfo;
	memset(&fileinfo,0,sizeof(OPENFILENAME));
	fileinfo.lpstrTitle = pArgInf[0].m_pText;
	if(pArgInf[1].m_dtDataType != _SDT_NULL && pArgInf[1].m_pText)
	{
		INT nLen = mystrlen(pArgInf[1].m_pText);
		if(nLen)
		{
			LPSTR pTemp = new char[nLen+2];
			strcpy(pTemp,pArgInf[1].m_pText);
			pTemp[nLen+1]=0;
			INT i=0;
			fileinfo.lpstrFilter=pTemp;
			while(i < nLen)
			{
				if(*pTemp=='|')
					*pTemp = 0;
				pTemp++;
				i++;
			}


		}

	}
	fileinfo.nFilterIndex = pArgInf[2].m_int + 1; //1ʼ״0ʼ
	if(pArgInf[3].m_dtDataType != _SDT_NULL && pArgInf[3].m_pText)
	{
		fileinfo.lpstrInitialDir = pArgInf[3].m_pText;
	}
	


	fileinfo.lStructSize = sizeof(OPENFILENAME);
	char pszFileName[8192];
	pszFileName[0]=0;
	fileinfo.nMaxFile = 8192;
	fileinfo.lpstrFile = pszFileName;
	fileinfo.Flags = OFN_EXPLORER | OFN_ALLOWMULTISELECT |OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
	char preDir [MAX_PATH];
	preDir[0]=0;
	if(pArgInf[4].m_dtDataType != _SDT_NULL && pArgInf[4].m_bool)
	{
		GetCurrentDirectory (MAX_PATH,preDir);
	}
	if(nArgCount>5) //5.3""
	{
		if(pArgInf[5].m_dtDataType != _SDT_NULL)
		{
			fileinfo.hwndOwner = (HWND)pArgInf[5].m_int;
		}
	}
	if(GetOpenFileName(&fileinfo))
	{
		LPSTR pText = pszFileName+fileinfo.nFileOffset;
		LPSTR pPath = pszFileName;

		INT nLen = mystrlen(pPath);
		if(pPath[nLen-1]=='\\')
			pPath[nLen-1]=0;
		nLen = mystrlen(pText);
		if(pText[nLen+1]==0)//ѡļ
		{
			nLen = mystrlen(pPath);
			aryText.Add ((DWORD)CloneTextData (pPath, nLen));
		}else{//ѡļ
			LPSTR pEnd = pText + 8192;
			while(*pText !=0 && pText < pEnd)
			{
				char szFileName [MAX_PATH];
				sprintf(szFileName,"%s\\%s",pPath,pText);
				nLen = mystrlen(szFileName);
				aryText.Add ((DWORD)CloneTextData (szFileName, nLen));
				nLen = mystrlen(pText);
				
				pText+=(nLen+1);
			}

		}


		


		if(preDir[0] !=0)
			SetCurrentDirectory (preDir);



	}
	if(fileinfo.lpstrFilter)
		delete[] (LPSTR)fileinfo.lpstrFilter;

	
	// ±ݡ
	INT nSize = aryText.GetDWordCount () * sizeof (DWORD);
	LPSTR p = (LPSTR)E_MAlloc (sizeof (INT) * 2 + nSize);
	*(LPINT)p = 1;  // ά
	*(LPINT)(p + sizeof (INT)) = aryText.GetDWordCount ();
	memcpy (p + sizeof (INT) * 2, aryText.GetPtr (), nSize);
	return  p;  // дظ
}


================================================
FILE: krnln/krnln_OpenMemFile.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
//ļд - ڴļ
/*
    øʽ ͡ ڴļ  - ϵͳֿ֧->ļд
    ӢƣOpenMemFile
    һڴļԼڴΪ洢ʶݽļʽĿɹرļļţʧܷ 0Ϊ
*/
LIBAPI(void*, krnln_OpenMemFile)
{
	CMyMemFile* pMemFile = new CMyMemFile();
	if(pMemFile)
	{
		PFILEELEMENT pFile = new FILEELEMENT;
		pFile->nType = 2;
		pFile->FileHandle = pMemFile;
		AddFileMangerList(pFile);
		return pFile;
	}
	return NULL;
}


================================================
FILE: krnln/krnln_PlayMID.cpp
================================================
#include "stdafx.h"
#include "midi.h"
#include "Myfunctions.h"

struct MIDIFILEDATAINFO
{
	LPBYTE pData;
    DWORD	dwSize;			
};

extern "C" PDESTROY DestroyMidiPlayer;

CMIDI* pMidiPlayer = NULL;
MIDIFILEDATAINFO* pMidiFileData = NULL;
INT nLoopNum;
INT nPlayWaitTime;
INT nMidiArrySize = 0;
HANDLE	hLoopPlayEvent = NULL;
HANDLE  hMidiPlayerThrd = NULL; 
void CloseMidiPlayer()
{
	DestroyMidiPlayer = NULL;
	if(hMidiPlayerThrd)
	{
		TerminateThread(hMidiPlayerThrd,0);//ǿֹ߳
		::CloseHandle(hMidiPlayerThrd);
		hMidiPlayerThrd = NULL;
	}

	if(hLoopPlayEvent)
	{
		SetEvent(hLoopPlayEvent);
		::CloseHandle(hLoopPlayEvent);
		hLoopPlayEvent = NULL;
	}
	

	if(pMidiPlayer)
	{
		delete pMidiPlayer;
		pMidiPlayer=NULL;
	}
	if(pMidiFileData)
	{
		for(INT i=0;i<nMidiArrySize;i++)
		{
			if(pMidiFileData[i].pData)
			{
				delete [] pMidiFileData[i].pData;
				pMidiFileData[i].pData=NULL;
				pMidiFileData[i].dwSize=0;
			}
		}
		delete [] pMidiFileData;
		pMidiFileData=NULL;
		nMidiArrySize = 0;
	}
	

}
BOOL IsValidMidiDataPtr(LPBYTE pData)
{
	if(pData==NULL)return FALSE;
	LPINT pInt = (LPINT)pData;


	if(pInt[1] > (3*sizeof(WORD)+2*sizeof(DWORD)))
		return TRUE;
	return FALSE;

}
BOOL IsValidMidiFileName(LPSTR pStr)
{
	if(pStr==NULL)return FALSE;
	INT nLen = mystrlen(pStr);
	if(nLen >=4)
		return TRUE;
	return FALSE;

}

INT GetMidiDataCount(PMDATA_INF pArgInf,INT nArg)
{
	INT nCount = 0;
	for(INT i=0;i<nArg;i++)
	{
		if((pArgInf[i].m_dtDataType & DT_IS_ARY) == 0)//
		{

			if(pArgInf[i].m_dtDataType == SDT_BIN)
			{

				if(IsValidMidiDataPtr(pArgInf[i].m_pBin))
					nCount++;
				
			}else if(pArgInf[i].m_dtDataType == SDT_TEXT){

				if(IsValidMidiFileName(pArgInf[i].m_pText))
					nCount++;
			
			}
			
		}else{
			INT nDataType = pArgInf[i].m_dtDataType & ~DT_IS_ARY;

			if(nDataType == SDT_BIN)
			{
				if(pArgInf[i].m_pAryData)
				{
					DWORD dwMax = 0;
					LPBYTE* pArry = (LPBYTE*)GetAryElementInf(pArgInf[i].m_pAryData,dwMax);
					for(DWORD j=0;j<dwMax;j++)
					{
						if(IsValidMidiDataPtr(pArry[j]))
							nCount++;
					}

				}

				
			}else if(nDataType == SDT_TEXT){

				if(pArgInf[i].m_pAryData)
				{
					DWORD dwMax = 0;
					LPSTR* pArry = (LPSTR*)GetAryElementInf(pArgInf[i].m_pAryData,dwMax);
					for(DWORD j=0;j<dwMax;j++)
					{
						if(IsValidMidiFileName(pArry[j]))
							nCount++;
					}

				}
			
			}
			
			
		}
	}

	return nCount;


}

BOOL GetMidiDataFromPtr(LPBYTE pData,INT nIDX)
{
	LPINT pInt = (LPINT)pData;
	pMidiFileData[nIDX].dwSize = pInt[1];
	pMidiFileData[nIDX].pData = new BYTE[pInt[1]];
	if(pMidiFileData[nIDX].pData==NULL)return FALSE;
	pInt+=2;
	memcpy(pMidiFileData[nIDX].pData,pInt,pMidiFileData[nIDX].dwSize);
	return TRUE;

}
BOOL GetMidiDataFromFile(LPSTR pStr,INT nIDX)
{
	HANDLE hFile = CreateFile(pStr,
		GENERIC_READ,
		FILE_SHARE_READ|FILE_SHARE_WRITE,
		NULL,
		OPEN_EXISTING,
		FILE_ATTRIBUTE_ARCHIVE,
		0);
	

	if(hFile != INVALID_HANDLE_VALUE)
	{

		DWORD dwNumOfByteRead;
		INT nLen = GetFileSize(hFile, &dwNumOfByteRead);
		pMidiFileData[nIDX].dwSize = nLen;
		pMidiFileData[nIDX].pData =  new BYTE[nLen];
		if(pMidiFileData[nIDX].pData)
		{
			if(ReadFile(hFile, pMidiFileData[nIDX].pData, nLen, &dwNumOfByteRead, 0))
			{
				CloseHandle(hFile);
				return TRUE;
			}
		}
		CloseHandle(hFile);
		
	}
	pMidiFileData[nIDX].dwSize = 0;
	pMidiFileData[nIDX].pData = NULL;
	return FALSE;

}

INT GetMidiDataFromArg(PMDATA_INF pArgInf,INT nArg)
{
	INT nCount = 0;
	INT nArry =0;
	for(INT i=0;i<nArg;i++)
	{
		if((pArgInf[i].m_dtDataType & DT_IS_ARY) == 0)//
		{

			if(pArgInf[i].m_dtDataType == SDT_BIN)
			{

				if(IsValidMidiDataPtr(pArgInf[i].m_pBin))
				{
					if(GetMidiDataFromPtr(pArgInf[i].m_pBin,nArry))
						nArry++;

					nCount++;
				}
				
			}else if(pArgInf[i].m_dtDataType == SDT_TEXT){

				if(IsValidMidiFileName(pArgInf[i].m_pText))
				{
					if(GetMidiDataFromFile(pArgInf[i].m_pText,nArry))
						nArry++;
					nCount++;
				}
			
			}
			
		}else{
			INT nDataType = pArgInf[i].m_dtDataType & ~DT_IS_ARY;

			if(nDataType == SDT_BIN)
			{
				if(pArgInf[i].m_pAryData)
				{
					DWORD dwMax = 0;
					LPBYTE* pArry = (LPBYTE*)GetAryElementInf(pArgInf[i].m_pAryData,dwMax);
					for(DWORD j=0;j<dwMax;j++)
					{
						if(IsValidMidiDataPtr(pArry[j]))
						{
					
							if(GetMidiDataFromPtr(pArry[j],nArry))
								nArry++;
							nCount++;
						}
					}

				}

				
			}else if(nDataType == SDT_TEXT){

				if(pArgInf[i].m_pAryData)
				{
					DWORD dwMax = 0;
					LPSTR* pArry = (LPSTR*)GetAryElementInf(pArgInf[i].m_pAryData,dwMax);
					for(DWORD j=0;j<dwMax;j++)
					{
						if(IsValidMidiFileName(pArry[j]))
						{					
							if(GetMidiDataFromFile(pArry[j],nArry))
								nArry++;
							nCount++;
						}
					}

				}
			
			}
			
			
		}
	}

	return nArry;


}

DWORD WINAPI  PlayMidiManager(PVOID pParam)
{
	/*
INT nLoopNum;
INT nPlayWaitTime;
INT nMidiArrySize = 0;
HANDLE	hLoopPlayEvent = NULL;
HANDLE  hMidiPlayerThrd = NULL; 
*/
	for(INT n=0;n<nLoopNum;n++)
	{
		for(INT i=0;i<nMidiArrySize;i++)
		{
			if(pMidiFileData[i].pData)
			{
				if(pMidiPlayer)
					delete  pMidiPlayer;
				pMidiPlayer = new CMIDI();
				pMidiPlayer->m_hhLoopPlayEvent = hLoopPlayEvent; 
				BOOL bRet = pMidiPlayer->Create(pMidiFileData[i].pData,pMidiFileData[i].dwSize);
				if(bRet)
				{
					
					bRet = pMidiPlayer->Play();
					if(bRet)
					{
						ResetEvent(hLoopPlayEvent);
						WaitForSingleObject(hLoopPlayEvent,INFINITE);
						Sleep(nPlayWaitTime);
					}

				}else{
					delete [] pMidiFileData[i].pData;
					pMidiFileData[i].pData=NULL;
					pMidiFileData[i].dwSize=0;
				}
			}
		}

	}
	::CloseHandle(hMidiPlayerThrd);
	hMidiPlayerThrd = NULL;
	CloseMidiPlayer();
	return 1;
}

//ý岥 - MID
/*
    øʽ ޷ֵ MID  Ŵݣ ʱݣͨ/ ŵMIDI֣...  - ϵͳֿ֧->ý岥
    ӢƣPlayMID
    ԶŶ MIDI ļעⲻ֧ WAV ӦʽֽڼݡԴΪһԱظӡ
    <1>ΪŴΪͣintԱʡԡΪ -1 ʾָֽѭţָֻĴʡԣĬֵΪ 1 
    <2>Ϊʱ䡱ΪͣintԱʡԡָ MIDI ֮IJżʱ䣬λΪ 0.1 롣ʡԣĬֵΪ 0 
    <3>ΪŵMIDI֡ΪͨͣallṩʱͬʱṩݡֵΪ MIDI ļƻӦʽֽڼݡԴ
*/
LIBAPI(void, krnln_PlayMID)
{
	//ֹ߳
	CloseMidiPlayer();

	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[0].m_dtDataType==_SDT_NULL)
		nLoopNum = 1;
	else
	{
		nLoopNum = pArgInf[0].m_int;

		if(nLoopNum == -1)
			nLoopNum = 2147483647;
		else if(nLoopNum <=0)
			return;
	}
	if(pArgInf[1].m_dtDataType==_SDT_NULL)
		nPlayWaitTime = 0;
	else
	{
		nPlayWaitTime = pArgInf[1].m_int;

		if(nPlayWaitTime <0)
			nPlayWaitTime = 0;
	}
	nPlayWaitTime = nPlayWaitTime *100;
	INT nArg = nArgCount-2;

	INT nCount = GetMidiDataCount(&pArgInf[2],nArg);
	if(nCount==0)
		return;
	pMidiFileData = new MIDIFILEDATAINFO[nCount];
	nCount = GetMidiDataFromArg(&pArgInf[2],nArg);
	if(nCount==0)
	{
		delete [] pMidiFileData;
		pMidiFileData = NULL;
		return;
	}
	nMidiArrySize = nCount;
	
	hLoopPlayEvent = ::CreateEvent(0, FALSE, FALSE, TEXT("Wait For Midi Play End"));

	DWORD dwThreadId;
	HANDLE  hMidiPlayerThrd = CreateThread(NULL,
                0,
                PlayMidiManager,
                0,
                0,
               &dwThreadId);
	if(hMidiPlayerThrd==NULL)
	{
		CloseMidiPlayer();
		return;
	}
	//char tt[16];
	//itoa(nCount,tt,10);
	//MessageBox(NULL,tt,"nMidiArrySize",MB_OK);
	DestroyMidiPlayer=(PDESTROY)CloseMidiPlayer;



}


================================================
FILE: krnln/krnln_PlayMusic.cpp
================================================
#include "stdafx.h"
#pragma comment(lib,"winmm.lib") 

//ý岥 - 
/*
    øʽ ߼͡  ͨ ŵ֣߼ Ƿѭţݣ - ϵͳֿ֧->ý岥
    ӢƣPlayMusic
    Բ .WAV.MID ļӦʽֽڼݡԴɹ棬ʧܷؼ١Ϊ
    <1>Ϊŵ֡ΪͨͣallֵΪ .WAV.MID ļƻӦʽֽڼݡԴ
    <2>ΪǷѭšΪ߼ͣboolԱʡԡΪʾָֽѭţֻһΡʡԣĬΪһΡ
*/
extern HANDLE hBlackMoonInstanceHandle;

LIBAPI(BOOL, krnln_PlayMusic)
{
	DWORD dwSound = SND_ASYNC|SND_NODEFAULT;
	LPCSTR pszMusicData;
	HMODULE hmod = NULL;
	if(ArgInf.m_dtDataType == SDT_TEXT)
	{
		dwSound |= SND_FILENAME;
		pszMusicData = ArgInf.m_pText;

	}else if(ArgInf.m_dtDataType == SDT_BIN)
	{
		dwSound |= SND_MEMORY;

		pszMusicData = ArgInf.m_pText + 2*sizeof(INT);

	}else if(ArgInf.m_dtDataType == SDT_INT || ArgInf.m_dtDataType == SDT_BYTE || ArgInf.m_dtDataType == SDT_SHORT)
	{
		dwSound |=SND_RESOURCE;
		pszMusicData = MAKEINTRESOURCE(ArgInf.m_int);
		if(hBlackMoonInstanceHandle)
			hmod = (HMODULE)hBlackMoonInstanceHandle;
		else
			hmod = ::GetModuleHandle(NULL);
			

	}else
		return FALSE;

	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[1].m_dtDataType != _SDT_NULL && pArgInf[1].m_bool)
		dwSound |= SND_LOOP;

	return PlaySound(pszMusicData,hmod,dwSound);
}


================================================
FILE: krnln/krnln_PlayStop.cpp
================================================
#include "stdafx.h"
#pragma comment(lib,"winmm.lib") 
//ý岥 - ֹͣ
/*
    øʽ ޷ֵ ֹͣ  - ϵͳֿ֧->ý岥
    ӢƣPlayStop
    ֹͣڲŵ֡Ϊ
*/
LIBAPI(void, krnln_PlayStop)
{
	PlaySound(NULL,NULL,SND_PURGE);
}


================================================
FILE: krnln/krnln_PutEnv.cpp
================================================
#include "stdafx.h"

//ȡ - д
/*
    øʽ ߼͡ д ı ƣı дݣ - ϵͳֿ֧->ȡ
    ӢƣPutEnv
    ޸ĻָIJϵͳɹ棬ʧܷؼ١Ϊ
    <1>ΪơΪıͣtext
    <2>ΪдݡΪıͣtext
*/
LIBAPI(int, krnln_PutEnv)
{
	PMDATA_INF pArgInf = &ArgInf;
	return SetEnvironmentVariable(pArgInf[0].m_pText,pArgInf[1].m_pText);

}


================================================
FILE: krnln/krnln_QJCase.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

//ı - ȫ
/*
    øʽ ı͡ ȫ ı 任ı - ϵͳֿ֧->ı
    ӢƣQJCase
    ıеİĸոֱ任Ϊȫǣر任ĽıΪ
    <1>Ϊ任ıΪıͣtext

' ַΧ163ͷ176--185
' дĸ163ͷ193--218
' Сдĸ163ͷ225--250
' ///////////Ϊȫǵģǰǵ
' ַΧ48--57
' дĸ65--90
' Сдĸ97-122
ֽڼ ()  ' 163,174,163,173
*/
LIBAPI(char*, krnln_QJCase)
{
	PMDATA_INF pArgInf = &ArgInf;
	size_t nLen = mystrlen(ArgInf.m_pText);
	if (nLen == 0) return NULL;
	
	char* pszLast = ArgInf.m_pText + nLen;
	char* pszFirst = ArgInf.m_pText;
	char* pszSrc = (char*)malloc(nLen * 2 + 1);
	char* pszTmp = pszSrc;
	size_t sSublen;
	for (;;)
	{
		char* pPos = strstr(pszFirst, "\\");
		if (!pPos) break;
		sSublen = pPos - pszFirst;
		if (sSublen > 0)
		{
			memcpy(pszTmp, pszFirst, sSublen);
		}

		*(short*)(pszTmp + sSublen) = *(short*)"";
		pszTmp += sSublen + 2;
		pszFirst = pPos	+ 1;
	}
	sSublen = pszLast - pszFirst;
	if (sSublen > 0)
	{
		memcpy(pszTmp, pszFirst, sSublen);
		pszTmp += sSublen;
	}
	pszTmp[0] = '\0';
	
	INT nBufLen = nLen * 2 + 1;
	nLen = mystrlen(pszSrc);

	char *pQJText = (char*)E_MAlloc(nBufLen);
	LCMapString (2052, LCMAP_FULLWIDTH, pszSrc, nLen, pQJText, nBufLen);
	free(pszSrc);
	return pQJText;
}


================================================
FILE: krnln/krnln_RTrim.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
//ı - ɾβ
/*
    øʽ ı͡ ɾβ ı ɾոı - ϵͳֿ֧->ı
    ӢƣRTrim
    һıаɾβȫǻǿոָıΪ
    <1>ΪɾոıΪıͣtext
*/
LIBAPI(char*, krnln_RTrim)
{// ߺ 
	PMDATA_INF pArgInf = &ArgInf;
	char* pSrc = pArgInf[0].m_pText;
	register char *str1 = pSrc;
	
	register char* pLastNS = NULL;
	while ( *str1 )
	{
		if (*((unsigned short*)str1) == 0xA1A1)
			str1++;
		else
		{
			if (*str1 != ' ')
			{
				
				if (*str1 < 0)
				{
					pLastNS = str1 + 1;
					str1++;
				}else{
					pLastNS = str1;
				}
			}
		}
		str1++;
	}
	
	if (!pLastNS) return NULL; //ıֱӷ
	INT nLen = pLastNS - pSrc + 1;
	char *pText = (char*)E_MAlloc_Nzero(nLen+1);
	memcpy(pText, pSrc, nLen);
	pText[nLen] = '\0';
	
	return pText;
}
// {//ԭ
// 	INT nLen = mystrlen(ArgInf.m_pText);
// 	if(nLen==0)return NULL;
// 	char *pText = (char*)E_MAlloc_Nzero(nLen+1);
// 	strcpy(pText,ArgInf.m_pText);
// 
// 	char* pSrc = pText + nLen - 1;
// 	while(pSrc >= pText)
// 	{
// 		if(*pSrc == ' ' || (*pSrc == -95 && *(pSrc-1) == -95))
// 		{
// 			if(*pSrc< 0)
// 			{
// 				pSrc-=2;
// 			}
// 			else
// 			{
// 				pSrc--;
// 			}
// 		}
// 		else
// 		{
// 			pSrc++;
// 			*pSrc = 0;
// 
// 			break;
// 		}
// 
// 	}
// 	nLen = mystrlen(pText);
// 	if(nLen == 0)
// 	{
// 		E_MFree(pText);
// 		pText = NULL;
// 	}
// 	return pText;
// 
// }


================================================
FILE: krnln/krnln_ReadBin.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
#include "Myfunctions.h"
//ļд - ֽڼ
/*
    øʽ ֽڼ ֽڼ  ݵļţ ݵijȣ - ϵͳֿ֧->ļд
    ӢƣReadBin
    ļеǰдλöȡһֽڼݣʵʶ볤ȣصֽڼijߴ磩ܻС볤ȡʧܣһֽڼԶǰļдλƵļβΪ
    <1>ΪݵļšΪͣintļɡļء
    <2>ΪݵijȡΪͣint
*/
LIBAPI(void*, krnln_ReadBin)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return NULL;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return NULL;
	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[1].m_int <=0)
		return NULL;

	LPBYTE pbRet = NULL;

	if(pFile->nType == 1)//ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		DWORD dwNumOfByteRead;
		INT nLen = pArgInf[1].m_int;
		LPBYTE pData = new BYTE[nLen];
		INT nRet = ReadFile(hFile, pData, nLen, &dwNumOfByteRead, 0);
		if(nRet == FALSE)
		{
			delete[] pData;
			return NULL;
		}
		nLen = dwNumOfByteRead;
		pbRet = CloneBinData(pData,nLen);
		delete[] pData;
		

	}else if(pFile->nType ==2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*) pFile->FileHandle;
		INT nLen = pArgInf[1].m_int;
		LPBYTE pData =  (LPBYTE)E_MAlloc_Nzero(nLen+2*sizeof(INT));
		*(LPINT)pData = 1;
		*(LPINT)(pData + sizeof(INT)) = nLen;
		DWORD dwNumOfByteRead = pMemFile->Read (pData + 2*sizeof(INT),nLen);
		if(dwNumOfByteRead == 0)
		{
			E_MFree(pData);
			return NULL;
		}
		*(LPINT)(pData + sizeof(INT)) = dwNumOfByteRead;
		pbRet = pData;

	}else if (pFile->nType == 3) //ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		DWORD dwNumOfByteRead;
		INT nLen = pArgInf[1].m_int;
		LPBYTE pData = new BYTE[nLen];
		INT nPos = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
		INT nRet = ReadFile(hFile, pData, nLen, &dwNumOfByteRead, 0);
		if(nRet == FALSE)
		{
			delete[] pData;
			return NULL;
		}
		nLen = dwNumOfByteRead;
		E_RC4_Calc(nPos, pData, nLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
		pbRet = CloneBinData(pData,nLen);
		delete[] pData;
	}
	return pbRet;
}


================================================
FILE: krnln/krnln_ReadFile.cpp
================================================
#include "stdafx.h"

//̲ - ļ
/*
    øʽ ֽڼ ļ ı ļ - ϵͳֿ֧->̲
    ӢƣReadFile
    һֽڼаָļݡΪ
    <1>ΪļΪıͣtext
*/
LIBAPI(void*, krnln_ReadFile)
{
	HANDLE hFile = CreateFile(ArgInf.m_pText,
		GENERIC_READ,
		FILE_SHARE_READ|FILE_SHARE_WRITE,
		NULL,
		OPEN_EXISTING,
		FILE_ATTRIBUTE_ARCHIVE,
		0);
	LPBYTE pData = NULL;

	if(hFile != INVALID_HANDLE_VALUE)
	{

		DWORD dwNumOfByteRead;
		INT nLen = GetFileSize(hFile, &dwNumOfByteRead);
		pData =  (LPBYTE)E_MAlloc_Nzero(nLen+2*sizeof(INT));
		*(LPINT)pData = 1;
		*(LPINT)(pData + sizeof(INT)) = nLen;
		INT nRet = ReadFile(hFile, pData + 2*sizeof(INT), nLen, &dwNumOfByteRead, 0);
		CloseHandle(hFile);
	}
	return pData;
}


================================================
FILE: krnln/krnln_ReadLine.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
#include "Myfunctions.h"
#include <vector>

using namespace std;

//ļд - һ
/*
    øʽ ı͡ һ  ıݵļţ - ϵͳֿ֧->ļд
    ӢƣReadLine
    ļеǰдλöȡһıݣĩĻسзʧܣһıԶǰļдλƵļβΪ
    <1>ΪıݵļšΪͣintļɡļء
*/
LIBAPI(char*, krnln_ReadLine)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return NULL;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return NULL;

	char* pszRet = NULL;

	if(pFile->nType ==1)//ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		INT orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
		if(orgLoc == HFILE_ERROR)
		{
			SetFilePointer(hFile,0,NULL,FILE_END);
			return NULL;
		}
		
		DWORD dwNumOfByteRead;
		INT nLen = GetFileSize(hFile,NULL) - orgLoc;

		vector<MEMSP> vecMEMSP;
		INT nTLen = 0;
		for (INT i=0; i<nLen; i+=4096)
		{
			MEMSP tmpMEMSP;
			tmpMEMSP.pData = (char*)malloc(4096);
			INT nRet = ReadFile(hFile, tmpMEMSP.pData, min(nLen-i,4096), &dwNumOfByteRead, 0);
			if(nRet == FALSE)
			{
				SetFilePointer(hFile, 0, NULL, FILE_END);
				free(tmpMEMSP.pData);
				break;
			}
			BOOL bFind = FALSE;
			for (DWORD j=0; j < dwNumOfByteRead; j++)
			{
				if (tmpMEMSP.pData[j] == '\0')
				{
					bFind = TRUE;
					dwNumOfByteRead = j;
					SetFilePointer(hFile, orgLoc + nTLen + j, NULL, FILE_BEGIN);
					break;
				}
				else if (tmpMEMSP.pData[j] == '\n')
				{
					bFind = TRUE;
					dwNumOfByteRead = j;
					SetFilePointer(hFile, orgLoc + nTLen + j + 1, NULL, FILE_BEGIN);
					break;
				}
				else if (tmpMEMSP.pData[j] == '\r')
				{
					if (j + 1 == dwNumOfByteRead)
					{
						char szNewline = 0;
						nRet = ReadFile(hFile, &szNewline, 1, &dwNumOfByteRead, 0);//ٶһֽڣDz\r\n
						if (szNewline != '\n')
						{
							//\r\nϣѶдλ÷ŵ\r
							SetFilePointer(hFile, orgLoc + nTLen + j + 1, NULL, FILE_BEGIN);
						}
						//else
						//{
							//պ\r\nϣдλþͲҪˡ
							//SetFilePointer(hFile, orgLoc + nTLen + j + 2, NULL, FILE_BEGIN);
						//}
					}
					else if (tmpMEMSP.pData[j + 1] == '\n')
					{
						SetFilePointer(hFile, orgLoc + nTLen + j + 2, NULL, FILE_BEGIN);
					}
					else
					{
						SetFilePointer(hFile, orgLoc + nTLen + j + 1, NULL, FILE_BEGIN);
					}
					bFind = TRUE;
					dwNumOfByteRead = j;
					break;
				}
			}
			tmpMEMSP.nLen = dwNumOfByteRead;
			nTLen += dwNumOfByteRead;
			vecMEMSP.push_back(tmpMEMSP);
			if (bFind || dwNumOfByteRead != 4096)
				break;
		}
		if (nTLen > 0)
		{
			pszRet = (LPSTR)E_MAlloc_Nzero(nTLen + 1);
			
			LPSTR pszRetold = pszRet;
			vector<MEMSP>::iterator iterMEMSP;
			for (iterMEMSP = vecMEMSP.begin(); iterMEMSP != vecMEMSP.end(); iterMEMSP++)
			{
				memcpy(pszRetold, iterMEMSP->pData, iterMEMSP->nLen);
				pszRetold += iterMEMSP->nLen;
				free(iterMEMSP->pData);
			}
			pszRet[nTLen] = 0;
		}
		vecMEMSP.clear();
		return pszRet;
	}
	else if(pFile->nType ==2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*) pFile->FileHandle;

		INT orgLoc = pMemFile->GetPosition();

		DWORD dwNumOfByteRead;
		INT nLen = -1;
		LPSTR pBufStart, pBufMax;

		dwNumOfByteRead = pMemFile->GetBufferPtr (CMyMemFile::bufferRead,nLen,(void **)&pBufStart,(void **)&pBufMax);

		LPSTR pStr = pBufStart;
		nLen = 0;
		while(nLen < (INT)dwNumOfByteRead)
		{
			if(*pStr =='\r' || *pStr =='\n')
				break;
			nLen++;
			pStr++;
		}
		pszRet = (LPSTR)E_MAlloc_Nzero(nLen+1);
		orgLoc += nLen;
		if(*pStr =='\r' || *pStr =='\n')
		{
			orgLoc++;
			pStr++;
			if(*pStr =='\n')
				orgLoc++;
		}
		pMemFile->Seek(orgLoc,CMyMemFile::begin);
		strncpy(pszRet,pBufStart,nLen);
		pszRet[nLen] = 0;
	}else if(pFile->nType ==3)//ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		INT orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
		if(orgLoc == HFILE_ERROR)
		{
			SetFilePointer(hFile,0,NULL,FILE_END);
			return NULL;
		}
		
		DWORD dwNumOfByteRead;
		INT nLen = GetFileSize(hFile,NULL) - orgLoc;
		
		vector<MEMSP> vecMEMSP;
		INT nTLen = 0;
		for (INT i=0; i<nLen; i+=4096)
		{
			MEMSP tmpMEMSP;
			tmpMEMSP.pData = (char*)malloc(4096);
			INT nPos = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
			INT nRet = ReadFile(hFile, tmpMEMSP.pData, min(nLen-i,4096), &dwNumOfByteRead, 0);
			if(nRet == FALSE)
			{
				SetFilePointer(hFile, 0, NULL, FILE_END);
				free(tmpMEMSP.pData);
				break;
			}
			BOOL bFind = FALSE;
			E_RC4_Calc(nPos, (unsigned char*)tmpMEMSP.pData, dwNumOfByteRead, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
			for (DWORD j=0; j < dwNumOfByteRead; j++)
			{
				if (tmpMEMSP.pData[j] == '\0')
				{
					bFind = TRUE;
					dwNumOfByteRead = j;
					SetFilePointer(hFile, orgLoc + nTLen + j, NULL, FILE_BEGIN);
					break;
				}
				else if (tmpMEMSP.pData[j] == '\n')
				{
					bFind = TRUE;
					dwNumOfByteRead = j;
					SetFilePointer(hFile, orgLoc + nTLen + j + 1, NULL, FILE_BEGIN);
					break;
				}
				else if (tmpMEMSP.pData[j] == '\r')
				{
					if (j + 1 == dwNumOfByteRead)
					{
						char szNewline = 0;
						nPos = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
						nRet = ReadFile(hFile, &szNewline, 1, &dwNumOfByteRead, 0);//ٶһֽڣDz\r\n
						E_RC4_Calc(nPos, (unsigned char*)&szNewline, dwNumOfByteRead, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
						if (szNewline != '\n')
						{
							//\r\nϣѶдλ÷ŵ\r
							SetFilePointer(hFile, orgLoc + nTLen + j + 1, NULL, FILE_BEGIN);
						}
						//else
						//{
						//պ\r\nϣдλþͲҪˡ
						//SetFilePointer(hFile, orgLoc + nTLen + j + 2, NULL, FILE_BEGIN);
						//}
					}
					else if (tmpMEMSP.pData[j + 1] == '\n')
					{
						SetFilePointer(hFile, orgLoc + nTLen + j + 2, NULL, FILE_BEGIN);
					}
					else
					{
						SetFilePointer(hFile, orgLoc + nTLen + j + 1, NULL, FILE_BEGIN);
					}
					bFind = TRUE;
					dwNumOfByteRead = j;
					break;
				}
			}
			tmpMEMSP.nLen = dwNumOfByteRead;
			nTLen += dwNumOfByteRead;
			vecMEMSP.push_back(tmpMEMSP);
			if (bFind || dwNumOfByteRead != 4096)
				break;
		}
		if (nTLen > 0)
		{
			pszRet = (LPSTR)E_MAlloc_Nzero(nTLen + 1);
			
			LPSTR pszRetold = pszRet;
			vector<MEMSP>::iterator iterMEMSP;
			for (iterMEMSP = vecMEMSP.begin(); iterMEMSP != vecMEMSP.end(); iterMEMSP++)
			{
				memcpy(pszRetold, iterMEMSP->pData, iterMEMSP->nLen);
				pszRetold += iterMEMSP->nLen;
				free(iterMEMSP->pData);
			}
			pszRet[nTLen] = 0;
		}
		vecMEMSP.clear();
		return pszRet;
	}
	return pszRet;
}


================================================
FILE: krnln/krnln_ReadText.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
#include "Myfunctions.h"
#include <vector>

using namespace std;
//ļд - ı
/*
    øʽ ı͡ ı  ıݵļţ ıݵijȣݣ - ϵͳֿ֧->ļд
    ӢƣReadText
    ļеǰдλöȡһıݣʵʶ볤ȣıijߴ磩ܻС볤ȡдֽ 0  26ı־ظֽ֮ǰݡʧܣһıԶǰļдλƵļβΪ
    <1>ΪıݵļšΪͣintļɡļء
    <2>ΪıݵijȡΪͣintԱʡԡʡԣĬ϶ļеıݡ
*/
LIBAPI(char*, krnln_ReadText)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return NULL;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return NULL;
	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[1].m_dtDataType != _SDT_NULL && pArgInf[1].m_int <=0)
		return NULL;

	char* pszRet = NULL;

	if(pFile->nType ==1)//ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		INT orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
		if(orgLoc == HFILE_ERROR)
		{
			SetFilePointer(hFile,0,NULL,FILE_END);
			return NULL;
		}

		DWORD dwNumOfByteRead;
		INT nLen;
		if(pArgInf[1].m_dtDataType == _SDT_NULL)
			nLen = GetFileSize(hFile,NULL) - orgLoc;
		else
			nLen = pArgInf[1].m_int;
		//Ĵ
		vector<MEMSP> vecMEMSP;
		INT nTLen = 0;
		for (INT i=0; i<nLen; i+=4096)
		{
			MEMSP tmpMEMSP;
			tmpMEMSP.pData = (char*)malloc(4096);
			INT nRet = ReadFile(hFile, tmpMEMSP.pData, min(nLen-i,4096), &dwNumOfByteRead, 0);
			if(nRet == FALSE)
			{
				SetFilePointer(hFile, 0, NULL, FILE_END);
				free(tmpMEMSP.pData);
				break;
			}
			BOOL bFind = FALSE;
			for (DWORD j=0; j < dwNumOfByteRead; j++)
			{
				if (tmpMEMSP.pData[j] == 0 || tmpMEMSP.pData[j] == 26)
				{
					dwNumOfByteRead = j;
					orgLoc++;// ֽ
					bFind = TRUE;
					break;
				}
			}
			tmpMEMSP.nLen = dwNumOfByteRead;
			nTLen += dwNumOfByteRead;
			vecMEMSP.push_back(tmpMEMSP);
			if (bFind || dwNumOfByteRead != 4096)
				break;
		}
		if (nTLen > 0)
		{
			pszRet = (LPSTR)E_MAlloc_Nzero(nTLen + 1);
			orgLoc += nTLen;
			SetFilePointer(hFile, orgLoc, NULL, FILE_BEGIN);
			
			LPSTR pszRetold = pszRet;
			vector<MEMSP>::iterator iterMEMSP;
			for (iterMEMSP = vecMEMSP.begin(); iterMEMSP != vecMEMSP.end(); iterMEMSP++)
			{
				memcpy(pszRetold, iterMEMSP->pData, iterMEMSP->nLen);
				pszRetold += iterMEMSP->nLen;
				free(iterMEMSP->pData);
			}
			pszRet[nTLen] = 0;
		}
		vecMEMSP.clear();
		return pszRet;
		// ԭĴ
// 		char* pData = new char[nLen];
// 		INT nRet = ReadFile(hFile, pData, nLen, &dwNumOfByteRead, 0);
// 		if(nRet == FALSE)
// 		{
// 			SetFilePointer(hFile,0,NULL,FILE_END);
// 			delete[] pData;
// 			return NULL;
// 		}
// 		nLen = 0;
// 		LPSTR pStr = pData;
// 		while(nLen < (INT)dwNumOfByteRead)
// 		{
// 			if(*pStr ==0 || *pStr ==26)
// 				break;
// 			nLen++;
// 			pStr++;
// 		}
// 		pszRet = (LPSTR)E_MAlloc_Nzero(nLen+1);
// 		orgLoc += nLen;
// 		SetFilePointer(hFile,orgLoc,NULL,FILE_BEGIN);
// 		strncpy(pszRet,pData,nLen);
// 		pszRet[nLen] = 0;
// 		
// 		delete[] pData;		

	}else if(pFile->nType ==2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*) pFile->FileHandle;

		INT orgLoc = pMemFile->GetPosition();

		DWORD dwNumOfByteRead;
		INT nLen;
		LPSTR pBufStart, pBufMax;
		if(pArgInf[1].m_dtDataType == _SDT_NULL)
			nLen = -1;
		else
			nLen = pArgInf[1].m_int;

		dwNumOfByteRead = pMemFile->GetBufferPtr (CMyMemFile::bufferRead,nLen,(void **)&pBufStart,(void **)&pBufMax);

		LPSTR pStr = pBufStart;
		nLen = 0;
		while(nLen < (INT)dwNumOfByteRead)
		{
			if(*pStr ==0 || *pStr ==26)
				break;
			nLen++;
			pStr++;
		}
		pszRet = (LPSTR)E_MAlloc_Nzero(nLen+1);
		orgLoc += nLen;
		pMemFile->Seek(orgLoc,CMyMemFile::begin);
		strncpy(pszRet,pBufStart,nLen);
		pszRet[nLen] = 0;
	}if(pFile->nType ==3)//ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		INT orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
		if(orgLoc == HFILE_ERROR)
		{
			SetFilePointer(hFile,0,NULL,FILE_END);
			return NULL;
		}
		
		DWORD dwNumOfByteRead;
		INT nLen;
		if(pArgInf[1].m_dtDataType == _SDT_NULL)
			nLen = GetFileSize(hFile,NULL) - orgLoc;
		else
			nLen = pArgInf[1].m_int;
		//Ĵ
		vector<MEMSP> vecMEMSP;
		INT nTLen = 0;
		for (INT i=0; i<nLen; i+=4096)
		{
			MEMSP tmpMEMSP;
			tmpMEMSP.pData = (char*)malloc(4096);
			INT nPos = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
			INT nRet = ReadFile(hFile, tmpMEMSP.pData, min(nLen-i,4096), &dwNumOfByteRead, 0);
			if(nRet == FALSE)
			{
				SetFilePointer(hFile, 0, NULL, FILE_END);
				free(tmpMEMSP.pData);
				break;
			}
			BOOL bFind = FALSE;
			E_RC4_Calc(nPos, (unsigned char*)tmpMEMSP.pData, dwNumOfByteRead, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
			for (DWORD j=0; j < dwNumOfByteRead; j++)
			{
				if (tmpMEMSP.pData[j] == 0 || tmpMEMSP.pData[j] == 26)
				{
					dwNumOfByteRead = j;
					orgLoc++;// ֽ
					bFind = TRUE;
					break;
				}
			}
			tmpMEMSP.nLen = dwNumOfByteRead;
			nTLen += dwNumOfByteRead;
			vecMEMSP.push_back(tmpMEMSP);
			if (bFind || dwNumOfByteRead != 4096)
				break;
		}
		if (nTLen > 0)
		{
			pszRet = (LPSTR)E_MAlloc_Nzero(nTLen + 1);
			orgLoc += nTLen;
			SetFilePointer(hFile, orgLoc, NULL, FILE_BEGIN);
			
			LPSTR pszRetold = pszRet;
			vector<MEMSP>::iterator iterMEMSP;
			for (iterMEMSP = vecMEMSP.begin(); iterMEMSP != vecMEMSP.end(); iterMEMSP++)
			{
				memcpy(pszRetold, iterMEMSP->pData, iterMEMSP->nLen);
				pszRetold += iterMEMSP->nLen;
				free(iterMEMSP->pData);
			}
			pszRet[nTLen] = 0;
		}
		vecMEMSP.clear();
		return pszRet;	
	}
	return pszRet;
}


================================================
FILE: krnln/krnln_RemoveData.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
#include "Myfunctions.h"
//ļд - ɾ
/*
    øʽ ߼͡ ɾ  ļţ ɾݵֽ - ϵͳֿ֧->ļд
    ӢƣRemoveData
    ļеǰдλôɾһֽݣļ˳ǰơļʱ"#д""#Ķ"Ȩޡɹ棬ʧܷؼ١Ϊ
    <1>ΪļšΪͣintļɡļء
    <2>ΪɾݵֽΪͣint
*/
LIBAPI(BOOL, krnln_RemoveData)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return NULL;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return NULL;
	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[1].m_int<=0)
		return FALSE;

	BOOL bRet = FALSE;

	if(pFile->nType ==1)//ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		INT orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
		if(orgLoc == HFILE_ERROR)
			return FALSE;


		bRet = TRUE;
		DWORD dwNumOfByteRead;
		INT nBkLen = GetFileSize(hFile,NULL) - orgLoc - pArgInf[1].m_int;
		LPBYTE pBkData = NULL;
		if(nBkLen >0)//в
		{
			pBkData = new BYTE[nBkLen];
			INT nLen = pArgInf[1].m_int;
			SetFilePointer(hFile,nLen,NULL,FILE_CURRENT);//Ƶ
			if( ReadFile(hFile, pBkData, nBkLen, &dwNumOfByteRead, 0)==FALSE)
			{
				delete[] pBkData;
				return FALSE;
			}
			SetFilePointer(hFile,orgLoc,NULL,FILE_BEGIN);//ָԭλ
			if(WriteFile(hFile,pBkData,nBkLen,&dwNumOfByteRead,NULL))
			{
//				if(FlushFileBuffers(hFile)==FALSE)
//					bRet = FALSE;
			}
			else
				bRet = FALSE;
			delete[] pBkData;
		}
		if(bRet)
			SetEndOfFile(hFile);

	}else if(pFile->nType ==2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*) pFile->FileHandle;

		INT orgLoc = pMemFile->GetPosition();

		INT nBkLen = pMemFile->GetFileSize() - orgLoc - pArgInf[1].m_int;
		LPBYTE pBkData = NULL;

		bRet = TRUE;
		if(nBkLen >0)//в
		{
			pMemFile->Seek(pArgInf[1].m_int,CMyMemFile::current);
			pBkData = new BYTE[nBkLen];
			pMemFile->Read(pBkData,nBkLen);
			pMemFile->Seek(orgLoc,CMyMemFile::begin);//ָ
			pMemFile->Write(pBkData, nBkLen);
			orgLoc = pMemFile->GetPosition();
			delete[] pBkData;
		}
		pMemFile->SetLength(orgLoc);
	}else if(pFile->nType ==3)//ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		INT orgLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
		if(orgLoc == HFILE_ERROR)
			return FALSE;
		
		bRet = TRUE;
		DWORD dwNumOfByteRead;
		INT nBkLen = GetFileSize(hFile,NULL) - orgLoc - pArgInf[1].m_int;
		INT nPos;
		LPBYTE pBkData = NULL;
		if(nBkLen >0)//в
		{
			pBkData = new BYTE[nBkLen];
			INT nLen = pArgInf[1].m_int;
			SetFilePointer(hFile,nLen,NULL,FILE_CURRENT);//Ƶ
			nPos = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
			if( ReadFile(hFile, pBkData, nBkLen, &dwNumOfByteRead, 0)==FALSE)
			{
				delete[] pBkData;
				return FALSE;
			}
			nBkLen = dwNumOfByteRead;
			E_RC4_Calc(nPos, (unsigned char*)pBkData, nBkLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);

			SetFilePointer(hFile,orgLoc,NULL,FILE_BEGIN);//ָԭλ
			nPos = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
			E_RC4_Calc(nPos, (unsigned char*)pBkData, nBkLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
			if(!WriteFile(hFile,pBkData,nBkLen,&dwNumOfByteRead,NULL))
				bRet = FALSE;

			delete[] pBkData;
		}
		if(bRet)
			SetEndOfFile(hFile);
	}
	return bRet;
}


================================================
FILE: krnln/krnln_ReplaceText.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
//ı - ı滻
/*
    øʽ ı͡ ı滻 ı 滻ı ʼ滻λã 滻ȣı 滻ıݣ - ϵͳֿ֧->ı
    ӢƣReplaceText
    ָıijһı滻Ϊ
    <1>Ϊ滻ıΪıͣtext
    <2>Ϊʼ滻λáΪͣint滻ʼλã1Ϊλã2Ϊ2λãơ
    <3>Ϊ滻ȡΪͣint
    <4>Ϊ滻ıΪıͣtextԱʡԡʡԣɾıеָ֡
*/
LIBAPI(char*, krnln_ReplaceText)
{// ߺŸ
	PMDATA_INF pArgInf = &ArgInf;
	char* pStr = pArgInf[0].m_pText;
	char* pSubstr = pArgInf[3].m_pText;
	INT nSubLen;
	INT nLen = mystrlen(pStr);
	if (pArgInf[3].m_dtDataType==_SDT_NULL)
		nSubLen = 0;
	else
		nSubLen = mystrlen(pSubstr);
	
	INT nRpLen = pArgInf[2].m_int;
	if (nRpLen < 0) nRpLen = 0;

	INT nStart = pArgInf[1].m_int - 1;
	if (nStart < 0) 
		nStart = 0;
	else if (nStart > nLen)
		nStart = nLen - 1;

	// ³ = Դ - 滻 + Ӵ
	// ʼ + 滻 <= Դ
	if (nStart + nRpLen > nLen) nRpLen = nLen - nStart;
	INT nNewLen = nLen - nRpLen + nSubLen;
	if (nNewLen <= 0) return NULL;

	char* pText;
	if (nStart == 0) // ǰƴ
	{
		if (nSubLen == 0) // ӴΪ
			return CloneTextData(pStr + nRpLen, nNewLen);

		pText = (char*)E_MAlloc_Nzero ((DWORD)(nNewLen + 1));
		memcpy(pText, pSubstr, nSubLen);
		memcpy(pText + nSubLen, pStr + nRpLen, nLen - nRpLen + 1);//+1ǰ\0Ҳƽȥ
		return pText;
	}
	else if (nStart >= nLen) // ƴ
	{
		if (nSubLen == 0) // ӴΪ
			return CloneTextData(pStr, nNewLen);

		pText = (char*)E_MAlloc_Nzero ((DWORD)(nNewLen + 1));
		memcpy(pText, pStr, nLen);
		memcpy(pText + nLen, pSubstr, nSubLen + 1);//+1ǰ\0Ҳƽȥ
		return pText;
	}

	// мƴ
	pText = (char*)E_MAlloc_Nzero ((DWORD)(nNewLen + 1));
	char* pTemp = pText;
	memcpy(pTemp, pStr, nStart);
	pTemp+=nStart;
	if (nSubLen > 0)
	{
		memcpy(pTemp, pSubstr, nSubLen);
		pTemp+=nSubLen;
	}
	if (nStart + nSubLen < nNewLen)
		memcpy(pTemp, pStr + nStart + nRpLen, nLen - nStart - nRpLen);

	pText[nNewLen] = '\0';
	return pText;
}
// {//ԭ
// 	PMDATA_INF pArgInf = &ArgInf;
// 	UINT nLen = mystrlen(ArgInf.m_pText);
// 	if(nLen==0)
// 	{
// 		if(pArgInf[3].m_dtDataType == _SDT_NULL)
// 			return NULL;
// 		nLen = mystrlen(pArgInf[3].m_pText);
// 		if(nLen==0)
// 			return NULL;
// 		return CloneTextData(pArgInf[3].m_pText,nLen);
// 
// 	}
// 	if(pArgInf[1].m_int > nLen || pArgInf[2].m_int <= 0)
// 		return CloneTextData(ArgInf.m_pText,nLen);
// 	INT nSubStr = 0;
// 	char* pSubStr = NULL;
// 	if(pArgInf[3].m_dtDataType != _SDT_NULL)
// 	{
// 		pSubStr = pArgInf[3].m_pText;
// 		nSubStr = mystrlen(pSubStr);
// 	}
// 	if(pArgInf[1].m_int <=0 )
// 		pArgInf[1].m_int = 1;
// 	INT nForce = pArgInf[1].m_int - 1;
// 	INT nBack = nLen - nForce;
// 	BOOL bStrcat;
// 	INT nCount ;
// 	if(nBack < pArgInf[2].m_int)
// 	{
// 		nCount = nForce + nSubStr;
// 		bStrcat = TRUE;
// 	}else{
// 
// 		nCount = nLen - pArgInf[2].m_int + nSubStr;
// 		bStrcat = FALSE;
// 	}
// 
// 	char *pText = (char*)E_MAlloc(nCount+1);
// 	if(bStrcat)
// 	{
// 		strncpy(pText,ArgInf.m_pText,nForce);
// 		pText[nForce]=0;
// 		if(pSubStr)
// 			strcat(pText,pSubStr);
// 	}
// 	else
// 	{
// 		strncpy(pText,ArgInf.m_pText,nForce);
// 		pText[nForce]=0;
// 		if(pSubStr)
// 			strcat(pText,pSubStr);
// 		pSubStr = ArgInf.m_pText + nForce + pArgInf[2].m_int;
// 		strcat(pText,pSubStr);
// 	}
// 	return pText;
// 
// }

================================================
FILE: krnln/krnln_RestroeCursor.cpp
================================================
#include "stdafx.h"

//ϵͳ - ָ
/*
    øʽ ޷ֵ ָ  - ϵͳֿ֧->ϵͳ
    ӢƣRestroeCursor
    ָԭ״롰õȴꡱʹáΪ
*/
HCURSOR hCurOld = NULL;

LIBAPI(void, krnln_RestroeCursor)
{

	if(hCurOld)
	{
		SetCursor(hCurOld);
		hCurOld = NULL;
	}
}


================================================
FILE: krnln/krnln_ReverseIntBytes.cpp
================================================
#include "stdafx.h"

// øʽ ͡ תֽ  תֵ - ϵͳֿ֧->ֵת
// ӢƣReverseIntBytes
// ָֽת,طתĽֵ. Ʃʮ0x12345678,ת󽫷0x78563412. JavaԽݽʱô.Ϊ
// <1>ΪתֵΪͣintṩתֵֽ
// 
// ϵͳ WindowsLinux
LIBAPI(int, krnln_ReverseIntBytes)
{
	unsigned int nRes = ArgInf.m_uint >> 24;
	nRes |= ((ArgInf.m_uint & 0x00FF0000) >> 8);
	nRes |= ((ArgInf.m_uint & 0x0000FF00) << 8);
	nRes |= ((ArgInf.m_uint & 0x000000FF) << 24);
	return nRes;
}

================================================
FILE: krnln/krnln_RmDir.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

BOOL BlackMoonDeleteDir(LPSTR strDirName)
{
	
	char szName [MAX_PATH];
	char szFile [MAX_PATH];
	strcpy(szName,strDirName);
	INT nLen = mystrlen(szName);
	if(szName[nLen-1] != '\\')
		strcat(szName,"\\");

	strcpy(szFile,szName);//\ΪβĵǰĿ¼
	strcat(szName,"*");//ͨĿ¼

	WIN32_FIND_DATA FindFileData;
	HANDLE hFile = FindFirstFile(szName,&FindFileData);
	if(hFile==NULL || hFile == INVALID_HANDLE_VALUE) 
		return FALSE;
	BOOL bOK = TRUE;
	do{
		if(strcmp(FindFileData.cFileName,".")!=0 &&
			strcmp(FindFileData.cFileName,"..")!=0)
		{

			strcpy(szName,szFile);
			strcat(szName,FindFileData.cFileName);//ĿļĿ¼
			if ((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)//ΪĿ¼
			{
				bOK = BlackMoonDeleteDir(szName);//ݹѭ
				if(bOK)
					bOK = RemoveDirectory(szName);//ɾĿ¼
				
			}else
				bOK = DeleteFile(szName);//ɾļ
		}
		if(bOK == FALSE)
			break;
	}while(FindNextFile(hFile,&FindFileData));

	FindClose(hFile); //رվ 
	return bOK;

}

//̲ - ɾĿ¼
/*
    øʽ ߼͡ ɾĿ¼ ı ɾĿ¼ƣ - ϵͳֿ֧->̲
    ӢƣRmDir
    ɾһڵĿ¼еĿ¼ļؽʹñɹ棬ʧܷؼ١Ϊ
    <1>ΪɾĿ¼ơΪıͣtextĿ¼ӦʵʴڣĿ¼дļĿ¼һɾʹñǧء
*/
LIBAPI(BOOL, krnln_RmDir)
{
	if(ArgInf.m_pText == NULL)
		return FALSE;
	int nLen = mystrlen(ArgInf.m_pText);
	if(nLen==0)//ֹɾǰĿ¼ĸĿ¼"\*"
		return FALSE;
	if(nLen ==1 && ArgInf.m_pText[0]=='\\')//ֹɾǰĿ¼ĸĿ¼"\*"
		return FALSE;
	BOOL bOK = BlackMoonDeleteDir(ArgInf.m_pText);
	if(bOK)
		bOK = RemoveDirectory(ArgInf.m_pText);//ɾĿ¼
	return bOK;
}


================================================
FILE: krnln/krnln_RpBin.cpp
================================================
#include "stdafx.h"

//ֽڼ - ֽڼ滻
/*
    øʽ ֽڼ ֽڼ滻 ֽڼ 滻䲿ֵֽڼ ʼ滻λã 滻ȣֽڼ 滻ֽڼݣ - ϵͳֿ֧->ֽڼ
    ӢƣRpBin
    ָֽڼijһֽڼ滻Ȼ󷵻滻ĽΪ
    <1>Ϊ滻䲿ֵֽڼΪֽڼbin
    <2>Ϊʼ滻λáΪͣint滻ʼλã1Ϊλã2Ϊ2λãơ
    <3>Ϊ滻ȡΪͣint
    <4>Ϊ滻ֽڼΪֽڼbinԱʡԡʡԣɾֽڼеָ֡
*/
LIBAPI(void*, krnln_RpBin)
{// ߺŸ
	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[0].m_pBin==NULL)
		return NULL;
	LPBYTE pBin = pArgInf[0].m_pBin + 2*sizeof(INT);
	LPBYTE pSubBin = pArgInf[3].m_pBin + 2*sizeof(INT);
	INT nSubLen;
	INT nLen = pArgInf[0].m_pInt[1];
	if (pArgInf[3].m_dtDataType==_SDT_NULL)
		nSubLen = 0;
	else
		nSubLen = pArgInf[3].m_pInt[1];
	
	INT nRpLen = pArgInf[2].m_int;
	if (nRpLen < 0) nRpLen = 0;
	
	INT nStart = pArgInf[1].m_int - 1;
	if (nStart < 0) 
		nStart = 0;
	else if (nStart > nLen)
		nStart = nLen - 1;
	
	// ³ = Դ - 滻 + Ӵ
	// ʼ + 滻 <= Դ
	if (nStart + nRpLen > nLen) nRpLen = nLen - nStart;
	INT nNewLen = nLen - nRpLen + nSubLen;
	if (nNewLen <= 0) return NULL;
	
	LPBYTE pRetn;
	LPBYTE pTemp;
	if (nStart == 0) // ǰƴ
	{
		if (nSubLen == 0) // ӴΪ
			return CloneBinData(pBin + nRpLen, nNewLen);
		
		pRetn = (LPBYTE)E_MAlloc_Nzero ((DWORD)(nNewLen + 2*sizeof(INT)));
		pTemp = pRetn;
		*(LPINT)pTemp = 1; //һά
		pTemp+=sizeof(INT);
		*(LPINT)pTemp = nNewLen;
		pTemp+=sizeof(INT);
		memcpy(pTemp, pSubBin, nSubLen);
		memcpy(pTemp + nSubLen, pBin + nRpLen, nLen - nRpLen);
		return pRetn;
	}
	else if (nStart >= nLen) // ƴ
	{
		if (nSubLen == 0) // ӴΪ
			return CloneBinData(pBin, nNewLen);
		
		pRetn = (LPBYTE)E_MAlloc_Nzero ((DWORD)(nNewLen + 2*sizeof(INT)));
		pTemp = pRetn;
		*(LPINT)pTemp = 1; //һά
		pTemp+=sizeof(INT);
		*(LPINT)pTemp = nNewLen;
		pTemp+=sizeof(INT);
		memcpy(pTemp, pBin, nLen);
		memcpy(pTemp + nLen, pSubBin, nSubLen);
		return pRetn;
	}
	
	// мƴ
	pRetn = (LPBYTE)E_MAlloc_Nzero ((DWORD)(nNewLen + 2*sizeof(INT)));
	pTemp = pRetn;

	*(LPINT)pTemp = 1; //һά
	pTemp+=sizeof(INT);
	*(LPINT)pTemp = nNewLen;
	pTemp+=sizeof(INT);

	memcpy(pTemp, pBin, nStart);
	pTemp+=nStart;
	if (nSubLen > 0)
	{
		memcpy(pTemp, pSubBin, nSubLen);
		pTemp+=nSubLen;
	}
	if (nStart + nSubLen < nNewLen)
		memcpy(pTemp, pBin + nStart + nRpLen, nLen - nStart - nRpLen);
	
	return pRetn;
}
// { ԭ
// 	PMDATA_INF pArgInf = &ArgInf;
// 	if(pArgInf[0].m_pBin==NULL)
// 		return NULL;
// 	UINT nLen = pArgInf[0].m_pInt[1];
// 	
// 	if(nLen==0 )
// 	{
// 		if(pArgInf[3].m_pBin == _SDT_NULL)
// 			return NULL;
// 		nLen = pArgInf[3].m_pInt[1];
// 		if(nLen==0)
// 			return NULL;
// 		
// 		return CloneBinData(pArgInf[3].m_pBin + 2*sizeof(INT),nLen);
// 	}
// 	LPBYTE pSrc = pArgInf[0].m_pBin + 2 *sizeof(INT);
// 	if(pArgInf[1].m_int > nLen || pArgInf[2].m_int <= 0)
// 		return CloneBinData (pSrc, nLen);
// 
// 	INT nSubStr = 0;
// 	LPBYTE pSubStr = NULL;
// 	
// 	if(pArgInf[3].m_dtDataType != _SDT_NULL && pArgInf[3].m_pBin)
// 	{
// 		pSubStr = pArgInf[3].m_pBin + 2 *sizeof(INT);
// 		nSubStr = pArgInf[3].m_pInt[1];
// 	}
// 	if(pArgInf[1].m_int <=0 )
// 		pArgInf[1].m_int = 1;
// 	INT nForce = pArgInf[1].m_int - 1;
// 	INT nBack = nLen - nForce;
// 	BOOL bStrcat;
// 	INT nCount ;
// 	if(nBack < pArgInf[2].m_int)
// 	{
// 		nCount = nForce + nSubStr;
// 		bStrcat = TRUE;
// 	}else{
// 
// 		nCount = nLen - pArgInf[2].m_int + nSubStr;
// 		bStrcat = FALSE;
// 	}
// 
// 	LPBYTE pText = (LPBYTE)E_MAlloc(nCount+2 *sizeof(INT));
// 	LPBYTE pDest = (LPBYTE)pText;
// 	*(LPINT)pDest=1;
// 	pDest+=sizeof(INT);
// 	*(LPINT)pDest=nCount;
// 	pDest+=sizeof(INT);
// 
// 	if(bStrcat)
// 	{
// 		memcpy(pDest,pSrc,nForce);
// 		if(pSubStr)
// 		{
// 			pDest+=nForce;
// 			memcpy(pDest,pSubStr,nSubStr);
// 		}
// 	}
// 	else
// 	{
// 		memcpy(pDest,pSrc,nForce);
// 		pDest+=nForce;
// 		if(pSubStr)
// 		{
// 			memcpy(pDest,pSubStr,nSubStr);
// 			pDest+=nSubStr;
// 		}
// 		nBack = nBack-pArgInf[2].m_int;
// 		pSubStr = pSrc + nForce + pArgInf[2].m_int;
// 		memcpy(pDest,pSubStr,nBack);
// 	}
// 	return pText;
// }


================================================
FILE: krnln/krnln_RpSubBin.cpp
================================================
#include "stdafx.h"
#include "mem.h"
#include "Myfunctions.h"
#include <stdio.h>

LPBYTE __cdecl krnln_fnRpSubBin(int a2, int a3)
{
  int v3; // ecx@1
  int v4; // ebx@1
  int v5; // ebp@1
  int v6; // edi@1
  int v7; // esi@1
  LPBYTE v8; // ebx@16
  int v9; // ebp@16
  int v10; // edi@16
  int v11; // eax@19
  int v12; // esi@19
  char v13; // zf@21
  int v14; // edx@21
  int v15; // ecx@21
  int v16; // edi@21
  LPBYTE v17; // esi@21
  int v18; // eax@26
  LPBYTE v20; // eax@33
  LPBYTE v21; // [sp+0h] [bp-40h]@31
  int v22; // [sp+4h] [bp-3Ch]@31
  int v23; // [sp+18h] [bp-28h]@1
  int v24; // [sp+1Ch] [bp-24h]@1
  int v25; // [sp+20h] [bp-20h]@5
  int v26; // [sp+24h] [bp-1Ch]@2
  BYTE v27; // [sp+28h] [bp-18h]@16
  //void **v28; // [sp+2Ch] [bp-14h]@12
  //int v29; // [sp+34h] [bp-Ch]@33
  //int v30; // [sp+3Ch] [bp-4h]@33
  int v31; // [sp+4Ch] [bp+Ch]@10

  v5 = *(int*)(*(int*)a3 + 4);
  v24 = *(int*)(a3 + 12) + 8;
  v4 = *(int*)(*(int*)(a3 + 12) + 4);
  v3 = *(int*)(a3 + 32);
  v7 = *(int*)a3 + 8;
  v6 = 0;
  v23 = *(int*)(*(int*)(a3 + 12) + 4);
  if ( v3 )
    v26 = *(int*)(a3 + 24) + 8;
  else
    v26 = 0;
  if ( v3 )
    v25 = *(int*)(*(int*)(a3 + 24) + 4);
  else
    v25 = 0;
  if ( *(int*)(a3 + 44) )
    v6 = (*(int*)(a3 + 36) - 1) & ((*(int*)(a3 + 36) - 1 < 0) - 1);
  if ( *(int*)(a3 + 56) )
    v31 = *(int*)(a3 + 48) & ((*(int*)(a3 + 48) < 0) - 1);
  else
    v31 = -1;
  CFreqMem v28;
  if ( v5 && v4 && v6 < v5 && v31 )
  {
    v28.Append((LPBYTE) v7, v6);
    v8 = (LPBYTE)(v6 + v7);
    v9 = v5 - v6;
    v10 = v23;
    v27 = *(BYTE*)v24;
    if ( v9 >= v23 )
    {
      while ( 1 )
      {
        v11 = FindByte(v8, v9, v27);
        v12 = v11;
        if ( v11 == -1 )
          break;
        v28.Append( v8, v11);
        v9 -= v12;
        v8 += v12;
        if ( v9 < v10 )
          break;
        v15 = v10;
        v16 = v24;
        v17 = v8;
        v14 = 0;
        v13 = 1;
        do
        {
          if ( !v15 )
            break;
          v13 = *v17++ == *(LPBYTE)(v16++);
          --v15;
        }
        while ( v13 );
        if ( v13 )
        {
          v28.Append((LPBYTE) v26, v25);
          v18 = v23;
          v8 += v23;
          v9 -= v23;
          if ( v31 != -1 )
          {
            --v31;
            if ( !v31 )
              break;
          }
        }
        else
        {
          v14 =(BYTE) *v8;//(LOBYTE)
          v28.AddByte( v14);
          v18 = v23;
          ++v8;
          --v9;
        }
        if ( v9 < v18 )
          break;
        v10 = v23;
      }
    }
    v22 = v9;
    v21 = v8;
  }
  else
  {
    v22 = v5;
    v21 = (LPBYTE)v7;
  }
  v28.Append( v21, v22);
  v20 = CloneBinData(v28.GetPtr(), v28.GetSize());
 // v28 = &CFreqMem___vftable_;
  v28.Free();
  return v20;
}

//ֽڼ - ֽڼ滻
/*
    øʽ ֽڼ ֽڼ滻 ֽڼ 滻ֽڼֽڼ 滻ֽڼֽڼ 滻ֽڼݣ 滻ʼλãݣ 滻еĴݣ - ϵͳֿ֧->ֽڼ
    ӢƣRpSubBin
    һֽڼֽڼָֽڼѱ滻һֽڼ滻ĴҲDZָġΪ
    <1>Ϊ滻ֽڼΪֽڼbin
    <2>Ϊ滻ֽڼΪֽڼbin
    <3>Ϊ滻ֽڼΪֽڼbinԱʡԡʡԱĬΪֽڼ
    <4>Ϊ滻ʼλáΪͣintԱʡԡ滻ֽڼʼλáʡԣĬϴ1ʼ
    <5>Ϊ滻еĴΪͣintԱʡԡֽڼ滻ĴʡԣĬϽпܵ滻
*/

LIBAPI(void*, krnln_RpSubBin)
{// ߺ 
	PMDATA_INF pArgInf = &ArgInf;

	LPBYTE pSrc = pArgInf[0].m_pBin;
	INT nSLen = pArgInf[0].m_pInt[1];
	if (nSLen <= 0 || !pSrc) return NULL;

	LPBYTE pDes = pArgInf[1].m_pBin;
	INT nDLen = pArgInf[1].m_pInt[1];

	pSrc += 2*sizeof(INT);
	INT nCount = pArgInf[4].m_int;
	if (pArgInf[4].m_dtDataType == _SDT_NULL) 
		nCount = 0x7FFFFFFF; // 滻21

	INT nStart;
	if (pArgInf[3].m_dtDataType == _SDT_NULL || pArgInf[3].m_int <= 1)
		nStart = 0;
	else
		nStart = pArgInf[3].m_int - 1;

	if (nDLen <= 0 || !pDes || nCount <=0 || nStart >= nSLen || nDLen > nSLen) // ؼϷֱӷԭֽڼ
		return CloneBinData(pSrc, nSLen);
	
	pDes += 2*sizeof(INT);
	LPBYTE pSub = NULL;
	INT nSubLen = 0;
	if (pArgInf[2].m_dtDataType != _SDT_NULL)
	{
		nSubLen = pArgInf[2].m_pInt[1];
		if (nSubLen < 0)
			nSubLen = 0;
		else
			pSub = pArgInf[2].m_pBin + 2*sizeof(INT);
	}

	// ʼ
	TBR tbr;
	INT nPos;
	LPBYTE pFirst = pSrc;
	LPBYTE pSearch = pSrc + nStart;
	INT nSYLen = nSLen;
	LPBYTE pLast = pSrc + nSLen;

	for (; nCount > 0; nCount--)
	{
		nPos = myinstring(pSearch, nSYLen, pDes, nDLen);
		if (nPos == -1)
			break;
		if (pSearch + nPos - pFirst > 0)
			tbr.add(pFirst, pSearch + nPos - pFirst);

		if (nSubLen > 0)
			tbr.add(pSub, nSubLen);

		pSearch += nPos + nDLen;
		pFirst = pSearch;
		nSYLen -= nPos + nDLen;
	}

	if (pLast - pFirst > 0)
		tbr.add(pFirst, pLast - pFirst);

	// Ƽ
	LPBYTE pRetn = (LPBYTE)E_MAlloc_Nzero(tbr.m_nTLen + 2*sizeof(INT));
	LPBYTE pRetnTmp = pRetn;
	*(LPINT)pRetnTmp = 1;
	pRetnTmp += sizeof(INT);
	*(LPINT)pRetnTmp = tbr.m_nTLen;
	pRetnTmp += sizeof(INT);

	nCount = tbr.m_nCount;
	for (int i = 0; i < nCount; i++)
	{
		memcpy(pRetnTmp, tbr.m_data[i].addr, tbr.m_data[i].len);
		pRetnTmp += tbr.m_data[i].len;
	}

	return pRetn;
}
// {
// 
// 	return krnln_fnRpSubBin(nArgCount,(INT)&ArgInf);
// }
/*
extern "C" void* _cdecl krnln_RpSubBin (INT nArgCount,MDATA_INF ArgInf,...)
{
	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[0].m_pBin==NULL)
		return NULL;
	INT nLen = pArgInf[0].m_pInt [1];
	LPBYTE pData = pArgInf[0].m_pBin + 2*sizeof(INT);
	if(nLen==0)return NULL;
	if(pArgInf[1].m_pBin==NULL)//Ҫ滻ֽڼ
		return CloneBinData (pData, nLen);

	INT nSubLen = pArgInf[1].m_pInt [1];
	if(nSubLen > nLen)return NULL;
	if(nSubLen==0)
		return CloneBinData (pData, nLen);
	LPBYTE pObj = pArgInf[1].m_pBin + 2*sizeof(INT);
	
	LPBYTE pStrRpl = NULL;
	INT nStrRpl = 0;
	if(pArgInf[2].m_dtDataType !=_SDT_NULL && pArgInf[2].m_pBin)
	{
		pStrRpl = pArgInf[2].m_pBin + 2*sizeof(INT);
		nStrRpl = pArgInf[2].m_pInt [1];
	}

	INT nStart;
	if(pArgInf[3].m_dtDataType ==_SDT_NULL)
		nStart = 1;
	else
		nStart = pArgInf[3].m_int;

	INT nRplCount;
	if(pArgInf[4].m_dtDataType ==_SDT_NULL)
		nRplCount = 0x7fffffff;
	else
		nRplCount = pArgInf[4].m_int;

	INT nEnd = nLen - nSubLen;
	if(nStart > nEnd || nRplCount <= 0  || nStart <= 0)//ѰҵıڿʼѰλ  û滻
		return CloneBinData (pData, nLen);

//ͳҵĴͻ峤
	LPBYTE pSrc = pData;
	LPBYTE pStart = pSrc + nStart -1;
	LPBYTE pEnd = pSrc + nEnd+1;
	INT nFind = 0;

	while(pStart < pEnd)
	{
		if(memcmp(pStart,pObj,nSubLen)==0)
		{
			nFind++;
			if(nFind == nRplCount)
				break;
			pStart+=nSubLen;
		}
		else
			pStart++;
	}


	if(nFind==0)//һҲûҵ
		return CloneBinData (pData, nLen);

	INT nBuf = nLen + (nStrRpl - nSubLen) * nFind;
	LPBYTE pText = (LPBYTE)E_MAlloc(nBuf+2*sizeof(INT));
	LPBYTE pDest = pText;
	*(LPINT)pDest=1;
	pDest+=sizeof(INT);
	*(LPINT)pDest=nBuf;
	pDest+=sizeof(INT);

//ʼ滻

	pStart = pSrc + nStart -1;
	pEnd = pSrc + nEnd+1;

	while(pStart < pEnd)
	{
		if(memcmp(pStart,pObj,nSubLen)==0)
		{
			INT nStr = pStart - pSrc;
			memcpy(pDest,pSrc,nStr);//ϴζ
			pDest+=nStr;
			if(pStrRpl)
			{
				memcpy(pDest,pStrRpl,nStrRpl);//滻ı
				pDest+=nStrRpl;
			}
			pStart+=nSubLen;
			pSrc = pStart; //һ;
			nFind--;
			if(nFind == 0)
			{
				if(pStart - pData <=nLen)
				{
					nStr = pEnd - pSrc+nSubLen-1;
					memcpy(pDest,pSrc,nStr);//滻ı
				}
				break;
			}
		}
		else
			pStart++;

	}

	return pText;
}
*/

================================================
FILE: krnln/krnln_RpSubText.cpp
================================================
#include "stdafx.h"
#include "mem.h"
#include "Myfunctions.h"
//ı - ı滻
/*
    øʽ ı͡ ı滻 ı 滻ıı 滻ıı 滻ıݣ 滻ʼλãݣ 滻еĴݣ߼ ǷִСд - ϵͳֿ֧->ı
    ӢƣRpSubText
    һııָıѱ滻һı滻ĴҲDZָġΪ
    <1>Ϊ滻ıΪıͣtext
    <2>Ϊ滻ıΪıͣtext
    <3>Ϊ滻ıΪıͣtextԱʡԡʡԣĬΪı
    <4>Ϊ滻ʼλáΪͣintԱʡԡֵָ滻ıʼλáʡԣĬϴ 1 ʼ
    <5>Ϊ滻еĴΪͣintԱʡԡֵָı滻ĴʡԣĬϽпܵ滻
    <6>ΪǷִСдΪ߼ͣboolʼֵΪ桱ΪִСдΪٲ֡


char* StrCpyForE(char* pSrc)
{
	INT nLen = strlen(pSrc);
	char *pText = (char*)E_MAlloc(nLen+1);
	strcpy(pText,pSrc);
	return pText;
}*/
LIBAPI(char*, krnln_RpSubText)
{// ߺ 
	PMDATA_INF pArgInf = &ArgInf;
	char* pSrc = pArgInf[0].m_pText;
	if (!pSrc || !*pSrc) return NULL;
	//ʼ滻λ
	INT nStart;
	if (pArgInf[3].m_dtDataType == _SDT_NULL || pArgInf[3].m_int <= 1)
		nStart = 0;
	else
		nStart = pArgInf[3].m_int - 1;
	//жϿʼλ
	char* cp = pSrc;
	char* pStart = pSrc + nStart;
	for (; *cp && cp < pStart; cp++)
		if (*cp < 0) cp++; // 

	if (!*cp)
		return CloneTextData(pSrc, cp - pSrc);

	INT nSLen = (cp + mystrlen(cp)) - pSrc;
	//ı
	char* pDes = pArgInf[1].m_pText;
	INT nDLen = 0;
	if (pDes)
		nDLen = mystrlen(pDes);
	//滻
	INT nCount = pArgInf[4].m_int;
	if (pArgInf[4].m_dtDataType == _SDT_NULL)
		nCount = 0x7FFFFFFF;// 滻21

	if (nDLen <=0 || nCount<=0) // ؼϷֱӷԭı
		return CloneTextData(pSrc, nSLen);

	char* pSub = NULL;
	INT nSubLen = 0;
	if (pArgInf[2].m_dtDataType != _SDT_NULL)
	{
		pSub = pArgInf[2].m_pText;
		if (pSub)
			nSubLen = mystrlen(pSub);
	}

	// ʼ
	TBR tbr;
	INT nPos;
	char* pFirst = pSrc;
	char* pLast = pSrc + nSLen;
	if (pArgInf[5].m_bool) // ִСд
	{
		for (; nCount > 0; nCount--)
		{
			nPos = mystrstr((char*)cp, (char*)pDes);
			if (nPos == -1)
				break;
			if (cp + nPos - pFirst > 0)
				tbr.add(pFirst, cp + nPos - pFirst);
		
			if (nSubLen > 0)
				tbr.add(pSub, nSubLen);
		
			cp += nPos + nDLen;
			pFirst = cp;
		}
	}
	else
	{
		for (; nCount > 0; nCount--)
		{
			nPos = mystristr((char*)cp, (char*)pDes);
			if (nPos == -1)
				break;
			if (cp + nPos - pFirst > 0)
				tbr.add(pFirst, cp + nPos - pFirst);
			
			if (nSubLen > 0)
				tbr.add(pSub, nSubLen);
			
			cp += nPos + nDLen;
			pFirst = cp;
		}
	}

	if (pLast - pFirst > 0)
		tbr.add(pFirst, pLast - pFirst);
	
	// Ƽ
	return tbr.toString();
}



================================================
FILE: krnln/krnln_RunConsoleApp.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
#include <stdio.h>
BOOL __cdecl ReadPepi(HANDLE hFile, TBR* tbr)
{
	DWORD nSize;
	char* pBuffer = NULL;
	char* pHH = (char*)"\r\n\0";
	while(1)
	{
		nSize = 0;
		if (!PeekNamedPipe(hFile, NULL, NULL, NULL, &nSize, NULL))
			return FALSE;
		if (!nSize)
			break;
		pBuffer = (char*)malloc(0x400);
		if (!ReadFile(hFile, pBuffer, 0x400, &nSize, NULL))
		{
			if(pBuffer) free(pBuffer);
			return FALSE;
		}
		if (!nSize)
			break;
		tbr->add(pBuffer, nSize);
		tbr->add(pHH, 2);
		pBuffer = NULL;
	}
	if(pBuffer) free(pBuffer);
	return TRUE;
}
/*
//  - п̨
øʽ ߼͡ п̨ ı еУıͱ ׼ݴűݣıͱ ݴűݣͱ ֵűݣ - ϵͳֿ֧->
ӢƣRunConsoleApp
ָĿ̨(򿪿̨),Ƿгɹ.Ϊ
<1>ΪеСΪıͣtextṩп̨ı
<2>Ϊ׼ݴűΪıͣtextԱʡԣṩʱֻṩ̨ڼ׼豸ݽŵ˱СʡԣĬֵΪޡ
<3>ΪݴűΪıͣtextԱʡԣṩʱֻṩ̨ڼ׼豸ݽŵ˱СʡԣĬֵΪޡ
<4>ΪֵűΪͣintԱʡԣṩʱֻṩ̨˳ʱṩķֵŵ˱СʡԣĬֵΪޡ

*/
LIBAPI(BOOL, krnln_RunConsoleApp)
{
	PMDATA_INF pArgInf = &ArgInf;
	char* pCMD = pArgInf[0].m_pText;

	char** pStdOut = NULL;
	char** pStdError = NULL;
	PINT pRetn = NULL;
	if (pArgInf[1].m_dtDataType != _SDT_NULL)
		pStdOut = pArgInf[1].m_ppText;
	if (pArgInf[2].m_dtDataType != _SDT_NULL)
		pStdError = pArgInf[2].m_ppText;
	if (pArgInf[3].m_dtDataType != _SDT_NULL)
		pRetn = (PINT)pArgInf[3].m_int;

	if (!pCMD || !*pCMD)
	{
		if (pRetn)
			*pRetn = 0;
		if (pStdOut && *pStdOut)
		{
			E_MFree(((void*)(*pStdOut)));
			*pStdOut = NULL;
		}
		if (pStdError && *pStdError)
		{
			E_MFree(((void*)(*pStdError)));
			*pStdError = NULL;
		}
		return FALSE;
	}

	SECURITY_ATTRIBUTES pa;
	PROCESS_INFORMATION pi;
	STARTUPINFO si;

	memset(&pi, 0, sizeof(pi));
	pi.hProcess = NULL;
	pi.hThread = NULL;
	pi.dwProcessId = NULL;
	pi.dwThreadId = NULL;
	memset(&pa, 0, sizeof(pa));
	pa.lpSecurityDescriptor = NULL;
	pa.nLength = sizeof(pa);
	pa.bInheritHandle = 1;

	HANDLE hFile1 = NULL;
	HANDLE hFile2 = NULL;
	HANDLE hStdOut = NULL;
	HANDLE hStdError = NULL;
	BOOL bSucess = FALSE;
	if(CreatePipe(&hFile1, &hStdOut, &pa, NULL))
	{
		if(CreatePipe(&hFile2, &hStdError, &pa, NULL))
		{
			memset(&si, 0, sizeof(si));
			si.cb = 68;
			si.dwFlags = 257;
			si.wShowWindow = 0;
			si.hStdOutput = hStdOut;
			si.hStdError = hStdError;

			if (CreateProcess(NULL, pCMD, NULL, NULL, TRUE, NULL, NULL, NULL, &si, &pi))
			{
				BOOL bWait = TRUE;
				TBR tbrOut;
				TBR tbrError;
				do 
				{
					if (bWait)
						if (WaitForSingleObject(pi.hProcess, 0x64) != WAIT_TIMEOUT)
							bWait = FALSE;
				} while (bWait);
				if (pRetn)
					if (!GetExitCodeProcess(pi.hProcess, (LPDWORD)pRetn))
						*pRetn = 0;
				bSucess = TRUE;
				if (pStdOut)
				{
					ReadPepi(hFile1, &tbrOut);
					if (*pStdOut) E_MFree(*pStdOut);
					*pStdOut = tbrOut.toString();
				}
				if (pStdError)
				{
					ReadPepi(hFile2, &tbrError);
					if (*pStdError) E_MFree(*pStdError);
					*pStdError = tbrError.toString();
				}
			}
		}
	}
	if (hFile1)
		CloseHandle(hFile1);
	if (hFile2)
		CloseHandle(hFile2);
	if (hStdOut)
		CloseHandle(hStdOut);
	if (hStdError)
		CloseHandle(hStdError);
	return bSucess;
}

================================================
FILE: krnln/krnln_SaveRegItem.cpp
================================================
#include "stdafx.h"
#pragma comment(lib,"advapi32.lib") 
#include "Myfunctions.h"

//ϵͳ - дע
/*
    øʽ ߼͡ дע  Ŀ¼ı ȫ·עͨ дֵ - ϵͳֿ֧->ϵͳ
    ӢƣSaveRegItem
     Windows עбָעдעĬֵĿӡ\ţ硰test\ɹ棬򷵻ؼ١롰дעͬDZдλôעΪм
    <1>ΪĿ¼ΪͣintΪ³ֵ֮һ 1#ࣻ 2#ã 3#û 4#ػ 5#û
    <2>Ϊȫ·עΪıͣtext
    <3>ΪдֵΪͨͣallֵָд뵽ָעеֵֻΪֵıֽڼʧܡ
*/
LIBAPI(BOOL, krnln_SaveRegItem)
{
	PMDATA_INF pArgInf = &ArgInf;
	DWORD dwLen=0;
	DWORD dwType;
	DWORD dwNewVal;
	LPBYTE pData=NULL;

	switch(pArgInf[2].m_dtDataType)
	{
	case SDT_TEXT:
		dwType = REG_SZ;
		dwLen = mystrlen(pArgInf[2].m_pText)+1;
		pData = (LPBYTE)pArgInf[2].m_pText;
		break;
	case SDT_BIN:
		dwType = REG_BINARY;
		if(pArgInf[2].m_pBin)
		{
			dwLen = pArgInf[2].m_pInt[1];
			pData = pArgInf[2].m_pBin+2*sizeof(INT);
		}
		break;
	case SDT_INT:
	case SDT_BYTE:
	case SDT_SHORT:
		dwType = REG_DWORD;
		dwLen = sizeof(INT);
		pData = (LPBYTE)&pArgInf[2].m_int;
		break;
	case SDT_FLOAT:
		{
			dwType = REG_DWORD;
			dwLen = sizeof(INT);
			dwNewVal = (DWORD)pArgInf[2].m_float;
			//pArgInf[2].m_dwSubCodeAdr = dwVal;
			pData = (LPBYTE)&dwNewVal;
			break;
		}
	case SDT_INT64:
		{
			dwType = REG_DWORD;
			dwLen = sizeof(INT);
			dwNewVal = (DWORD)pArgInf[2].m_int64;
			//pArgInf[2].m_dwSubCodeAdr = dwVal;
			pData = (LPBYTE)&dwNewVal;
			break;
		}
	case SDT_DOUBLE:
		{
			dwType = REG_DWORD;
			dwLen = sizeof(INT);
			dwNewVal = (DWORD)pArgInf[2].m_double;
			//pArgInf[2].m_dwSubCodeAdr = dwVal;
			pData = (LPBYTE)&dwNewVal;
			break;
		}
	default:
		return FALSE;

	}

	HKEY hRootkey = GetRegRootVal(pArgInf[0].m_int);
	BOOL bRet = FALSE;
	INT nLen = mystrlen(pArgInf[1].m_pText);
	if(hRootkey && nLen)
	{
		HKEY hkey;
		LPSTR pSubkey = new char [nLen +1];
		strcpy(pSubkey,pArgInf[1].m_pText);
		LPSTR pKeyname = strrchr(pSubkey,'\\');
		if(pKeyname)
		{
			*pKeyname = 0;
			pKeyname++;
		}
		if(RegCreateKeyEx(hRootkey,pSubkey,0,NULL,0,KEY_WRITE,NULL,&hkey,NULL)==ERROR_SUCCESS)
		{
			if(RegSetValueEx(hkey,pKeyname,0,dwType,pData,dwLen)==ERROR_SUCCESS)
			{
				bRet = TRUE;
			}
		

			RegCloseKey(hkey);


		}
		delete [] pSubkey;
	}

	return bRet;
}


================================================
FILE: krnln/krnln_SeekToBegin.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
//ļд - Ƶļ
/*
    øʽ ߼͡ Ƶļ  вļţ - ϵͳֿ֧->ļд
    ӢƣSeekToBegin
    ڱ򿪵ļУһдλõļסɹ棬ʧܷؼ١Ϊ
    <1>ΪвļšΪͣintļɡļء
*/
LIBAPI(BOOL, krnln_SeekToBegin)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return FALSE;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return FALSE;

	BOOL bRet = FALSE;

	if(pFile->nType ==1 || pFile->nType == 3)//ļ ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		bRet = SetFilePointer(hFile,0,NULL,FILE_BEGIN)!= HFILE_ERROR;

	}else if(pFile->nType ==2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*) pFile->FileHandle;
		bRet = (pMemFile->Seek(0,CMyMemFile::begin) != -1);

	}
	return bRet;
}


================================================
FILE: krnln/krnln_SeekToEnd.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
//ļд - Ƶļβ
/*
    øʽ ߼͡ Ƶļβ  вļţ - ϵͳֿ֧->ļд
    ӢƣSeekToEnd
    ڱ򿪵ļУһдλõļβɹ棬ʧܷؼ١Ϊ
    <1>ΪвļšΪͣintļɡļء
*/
LIBAPI(BOOL, krnln_SeekToEnd)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return FALSE;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return FALSE;

	BOOL bRet = FALSE;

	if(pFile->nType ==1 || pFile->nType == 3)//ļ ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		bRet = SetFilePointer(hFile,0,NULL,FILE_END);

	}else if(pFile->nType ==2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*) pFile->FileHandle;
		bRet = (pMemFile->Seek(0,CMyMemFile::end) != -1);

	}
	return bRet;
}


================================================
FILE: krnln/krnln_SetAttr.cpp
================================================
#include "stdafx.h"

//̲ - ļ
/*
    øʽ ߼͡ ļ ı Եļƣ Ϊֵ - ϵͳֿ֧->̲
    ӢƣSetAttr
    ΪһļϢɹ棬ʧܷؼ١Ϊ
    <1>ΪԵļơΪıͣtext
    <2>ΪΪֵΪͣintֵΪ³ֵͣ 1#ֻļ 2#ļ 4#ϵͳļ 32#浵ļ ͨЩֵһöļԡ
*/
LIBAPI(BOOL, krnln_SetAttr)
{
	PMDATA_INF pArgInf = &ArgInf;
	return SetFileAttributes (pArgInf[0].m_pText,pArgInf[1].m_int);
}


================================================
FILE: krnln/krnln_SetClipBoardText.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

//ϵͳ - üı
/*
    øʽ ߼͡ üı ı ׼ı - ϵͳֿ֧->ϵͳ
    ӢƣSetClipBoardText
    ָıŵǰ Windows ϵͳȥеԭݱǡɹ棬ʧܷؼ١Ϊ
    <1>Ϊ׼ıΪıͣtext

*/
LIBAPI(BOOL, krnln_SetClipBoardText)
{
	BOOL bRet = FALSE;
	if(ArgInf.m_pText && OpenClipboard(NULL))
	{
		EmptyClipboard();
		INT nLen = mystrlen(ArgInf.m_pText)+1;
		HGLOBAL hClip = GlobalAlloc(0x42,nLen);
		if(hClip)
		{
			LPSTR pStr = (LPSTR)GlobalLock(hClip);
			strcpy(pStr,ArgInf.m_pText);
			GlobalUnlock(hClip);
			SetClipboardData(CF_TEXT,hClip);
			bRet = TRUE;
		}
		CloseClipboard();
	}
	return bRet;

}


================================================
FILE: krnln/krnln_SetDiskLabel.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

//̲ - ô̾
/*
    øʽ ߼͡ ô̾ ı ַݣı ľı - ϵͳֿ֧->̲
    ӢƣSetDiskLabel
    ̵ָľıɹ棬ʧܷؼ١Ϊ
    <1>ΪַΪıͣtextԱʡԡơABCȣֻȡøıĵһַʡԣĬʹõǰ
    <2>ΪľıΪıͣtext
*/
LIBAPI(BOOL, krnln_SetDiskLabel)
{
	char DirName [MAX_PATH];
	if(ArgInf.m_dtDataType == _SDT_NULL)
	{
		if(GetCurrentDirectory(MAX_PATH,DirName)==0)
			return FALSE;
		DirName[3]=0;

	}
	else
	{
		if(mystrlen(ArgInf.m_pText)==0)
			return FALSE;

		DirName[0]=*ArgInf.m_pText;
		DirName[1]=':';
		DirName[2]='\\';
		DirName[3]=0;

	}

	PMDATA_INF pArgInf = &ArgInf;

	return SetVolumeLabel (DirName,pArgInf[1].m_pText);
}


================================================
FILE: krnln/krnln_SetIntInsideBin.cpp
================================================
#include "stdafx.h"

// øʽ ޷ֵ ֽڼ ֽڼ ֽڼ ƫƣ õֵ߼ Ƿתֽݣ - ϵͳֿ֧->ֽڼ
// ӢƣSetIntInsideBin
// ֽڼָλôֵΪ
// <1>ΪֽڼΪֽڼbinṩֽڼ
// <2>ΪƫơΪͣintṩõֵֽڼеƫλá
// <3>ΪõֵΪͣintṩõľֵ
// <4>ΪǷתֽ򡱣Ϊ߼ͣboolԱʡԡָǷֽзת,Ʃʮ0x12345678,תΪ0x78563412. JavaԽݽʱô. ʡԣĬֵΪ.
// 
// ϵͳ WindowsLinux
LIBAPI(void, krnln_SetIntInsideBin)
{
	PMDATA_INF pArgInf = &ArgInf;

	LPBYTE pSrc = pArgInf[0].m_pBin;
	if (!pSrc) return;

	int nLen = pArgInf[0].m_pInt[1];
	int off = pArgInf[1].m_int;
	if (nLen - off < 4) return;

	int nValue = pArgInf[2].m_int;
	if (pArgInf[3].m_dtDataType != _SDT_NULL && pArgInf[3].m_bool)
	{
		int nTmp = nValue;
		nValue = nTmp >> 24;
		nValue |= ((nTmp & 0x00FF0000) >> 8);
		nValue |= ((nTmp & 0x0000FF00) << 8);
		nValue |= ((nTmp & 0x000000FF) << 24);
	}
	*(LPINT)(pSrc + off + 2*sizeof(int)) = nValue;
}


================================================
FILE: krnln/krnln_SetKeyText.cpp
================================================
#include "stdafx.h"

//ϵͳ - д
/*
    øʽ ߼͡ д ı ļı ƣı ƣݣı дֵݣ - ϵͳֿ֧->ϵͳ
    ӢƣSetKeyText
    ָıдָлɾָڣָļڣԶɹ棬ʧܷؼ١Ϊ
    <1>ΪļΪıͣtextָļƣͨ.iniΪļ׺
    <2>ΪơΪıͣtextдڵơ
    <3>ΪơΪıͣtextԱʡԡֵָдеơֵʡԣɾָڼµ
    <4>ΪдֵΪıͣtextԱʡԡֵָд뵽ָеıֵʡԣɾָ
*/
LIBAPI(BOOL, krnln_SetKeyText)
{
	PMDATA_INF pArgInf = &ArgInf;
	return WritePrivateProfileString(pArgInf[1].m_pText, pArgInf[2].m_pText, pArgInf[3].m_pText, pArgInf[0].m_pText);
}


================================================
FILE: krnln/krnln_SetSysTime.cpp
================================================
#include "stdafx.h"
#include <math.h>
#include <oleauto.h>
#pragma comment(lib, "OleAut32.lib")

//ʱ - ʱ
/*
    øʽ ߼͡ ʱ ʱ õʱ䣩 - ϵͳֿ֧->ʱ
    ӢƣSetSysTime
    õǰϵͳڼʱ䡣ɹ棬ʧܷؼ١Ϊ
    <1>Ϊõʱ䡱Ϊʱͣdate
*/
LIBAPI(BOOL, krnln_SetSysTime)
{
	SYSTEMTIME now = { 0 };
	VariantTimeToSystemTime(ArgInf.m_date, &now);
	return SetLocalTime(&now);
}


================================================
FILE: krnln/krnln_SetWaitCursor.cpp
================================================
#include "stdafx.h"

//ϵͳ - õȴ
/*
    øʽ ޷ֵ õȴ  - ϵͳֿ֧->ϵͳ
    ӢƣSetWaitCursor
    ״Ϊɳ©ΣڼʱִгǰʾߡΪ
*/
extern HCURSOR hCurOld;

LIBAPI(void, krnln_SetWaitCursor)
{
	if(hCurOld==NULL)
	{
		HCURSOR hCur =  LoadCursor(NULL,IDC_WAIT);
		hCurOld = SetCursor(hCur);
	}
}


================================================
FILE: krnln/krnln_SortAry.cpp
================================================
#include "stdafx.h"

// - 
/*
    øʽ ޷ֵ  ͨͱ ֵ߼ ǷΪСݣ - ϵͳֿ֧->
    ӢƣSortAry
    ֵָڵԱп򣬲ӰάϢŻظΪ
    <1>ΪֵΪͨͣallṩʱֻṩ顣
    <2>ΪǷΪС󡱣Ϊ߼ͣboolԱʡԡֵΪ棬ΪС󣬷ΪӴСʡԣĬֵΪ档
*/
extern DWORD dwBlackMoonPESizeOfImage;
extern DWORD dwBlackMoonPEAddrrStart;
extern DWORD dwBlackMoonPEAddrrEnd;
extern void GetBlackMoonPESizeOfImage();

int __cdecl krnl_MACopyConstAry(int a1, void **a2)
{
  int result; // eax@1
  void *v3; // esi@1
  int v4; // eax@2
  int v5; // edx@2
  int v6; // ecx@2
  int v7; // edi@3
  unsigned int v8; // edi@4
  int v9; // eax@4
  char v10; // zf@4
	
  if(dwBlackMoonPESizeOfImage==0)
	  GetBlackMoonPESizeOfImage();


  v3 = *a2;
  if(dwBlackMoonPEAddrrStart <= (DWORD)v3 && (DWORD)v3 <= dwBlackMoonPEAddrrEnd)
  {
    v5 = *(DWORD *)v3;
    v6 = (int)((char *)v3 + 4);
    v4 = 1;
    if ( *(DWORD *)v3 > 0 )
    {
      do
      {
        v7 = *(DWORD *)v6;
        v6 += 4;
        v4 *= v7;
        --v5;
      }
      while ( v5 );
    }
    v9 = a1 * v4 - (DWORD)v3;
    v10 = v6 + v9 == 0;
    result = v6 + v9;
    v8 = result;
    if ( !v10 )
    {
      result = (int)E_MAlloc_Nzero(result);
      memcpy((void *)result, v3, v8);
      *a2 = (void *)result;
    }
  }
  return result;
}
/*
int __cdecl GetDataTypeType(DWORD a1)
{
  DWORD result; // eax@1

  result = a1;
  if ( a1 )
  {
    if ( (a1 & 0xC0000000) == 0x80000000 )
      result = 1;
    else
      result = DWORD(((a1 & 0xC0000000) != 0x40000000) + 2);
  }
  return result;
}*/

int __cdecl IsNumDataType(DWORD a1)
{
  int result; // eax@1

  result = GetDataTypeType(a1);
  if ( result != 1 || (BYTE)a1 != 1 )
    result = 0;
  return result;
}

int __cdecl GetSysDataTypeDataSize( int a1)
{
  if ( (DWORD)a1 <= 0x80000101 )
  {
    if ( a1 == -2147483391 )
      return 1;
    switch ( a1 )
    {
      case -2147483645:
      case -2147483640:
        return 8;
      case -2147483646:
      case -2147483644:
      case -2147483643:
      case -2147483642:
        return 4;
      default:
        return 0;
    }
    return 0;
  }
  if ( (unsigned int)a1 <= 0x80000401 )
  {
    if ( a1 != -2147482623 )
    {
      if ( a1 == -2147483135 )
        return 2;
      if ( a1 == -2147482879 )
        return 4;
      return 0;
    }
    return 8;
  }
  if ( a1 == -2147482367 )
    return 4;
  if ( a1 == -2147482111 )
    return 8;
  return 0;
}
DWORD s_dtDataType=0;
BOOL s_blIsInc =0;
LPBYTE GetAryElementInf (void* pAryData, LPINT pnElementCount);
int __cdecl SortCompare(float *a1, unsigned int *a2)
{
  signed int v2; // edi@1
  char v3; // zf@6
  signed int v4; // eax@12
  unsigned int v5; // edx@12
  unsigned int v6; // ecx@12
  unsigned int v7; // esi@12
  char v8; // zf@14
  int result; // eax@31

  v2 = 1;
  if ( s_dtDataType > 0x80000401 )
  {
    if ( (int)s_dtDataType == -2147482367 )
    {
      if ( *a1 < (double)*(float *)a2 )
      {
        v2 = -1;
        goto LABEL_31;
      }
      if ( *a1 == *(float *)a2 )
        goto LABEL_30;
    }
    else
    {
      if ( (int)s_dtDataType != -2147482111 )
        goto LABEL_30;
      if ( *(double *)a1 < *(double *)a2 )
      {
        v2 = -1;
        goto LABEL_31;
      }
      if ( *(double *)a1 == *(double *)a2 )
        goto LABEL_30;
    }
  }
  else
  {
    if ( (int)s_dtDataType != -2147482623 )
    {
      if ( (int)s_dtDataType == -2147483391 )
      {
        v3 = *(BYTE *)a1 == *(BYTE *)a2;
        if ( *(BYTE *)a1 < *(BYTE *)a2 )
        {
          v2 = -1;
          goto LABEL_31;
        }
      }
      else
      {
        if ((int) s_dtDataType == -2147483135 )
        {
          v3 = *(WORD *)a1 == *(WORD *)a2;
          if ( *(WORD *)a1 < *(WORD *)a2 )
          {
            v2 = -1;
            goto LABEL_31;
          }
        }
        else
        {
          if ((int) s_dtDataType != -2147482879 )
          {
LABEL_30:
            v2 = 0;
            goto LABEL_31;
          }
          v3 = *(DWORD *)a1 == *a2;
          if ( *(DWORD *)a1 < (signed int)*a2 )
          {
            v2 = -1;
            goto LABEL_31;
          }
        }
      }
LABEL_19:
      if ( !v3 )
        goto LABEL_31;
      goto LABEL_30;
    }
    v5 = *(DWORD *)a1;
    v7 = *a2;
    v4 = *((DWORD *)a1 + 1);
    v6 = a2[1];
    if ( v4 > (int)v6 )
    {
      v8 = v5 == v7;
    }
    else
    {
      if ( v4 < (int)v6 || (v8 = v5 == v7, v5 < v7) )
      {
        v2 = -1;
        goto LABEL_31;
      }
    }
    if ( v8 )
    {
      v3 = v4 == (int)v6;
      goto LABEL_19;
    }
  }
LABEL_31:
  result = v2;
  if ( !s_blIsInc )
    result = -v2;
  return result;
}

LIBAPI(void, krnln_SortAry)
{
	PMDATA_INF pArgInf = &ArgInf;
  void** v3; // esi@1
  int v4; // edi@5
  LPBYTE v5; // eax@5

  v3 = pArgInf->m_ppAryData;
  s_dtDataType = pArgInf->m_dtDataType;//*(_DWORD *)(NumOfElements + 8);
  if ( IsNumDataType(s_dtDataType) )
  {
    if (pArgInf[1].m_dtDataType !=_SDT_NULL )
      s_blIsInc = pArgInf[1].m_bool;
    else
      s_blIsInc = 1;
    v4 = GetSysDataTypeDataSize((int)s_dtDataType);
    krnl_MACopyConstAry(v4, v3);
	INT NumOfElements =0;
    v5 = GetAryElementInf(*v3, &NumOfElements);
    qsort(v5, NumOfElements, v4, (int (__cdecl *)(const void *, const void *))SortCompare);
  }
}


================================================
FILE: krnln/krnln_SpaceBin.cpp
================================================
#include "stdafx.h"

//ֽڼ - ȡհֽڼ
/*
    øʽ ֽڼ ȡհֽڼ  ֽĿ - ϵͳֿ֧->ֽڼ
    ӢƣSpaceBin
    ؾضĿ 0 ֽڵֽڼΪ
    <1>ΪֽĿΪͣint
*/
LIBAPI(void*, krnln_SpaceBin)
{
	if(ArgInf.m_int <=0)return NULL;
	LPINT pData = (LPINT)E_MAlloc(ArgInf.m_int+2*sizeof(INT));
	pData[0]=1;
	pData[1]=ArgInf.m_int;
	return pData;
}


================================================
FILE: krnln/krnln_SplitBin.cpp
================================================
#include "stdafx.h"
#include "mem.h"
#include "Myfunctions.h"
//ֽڼ - ָֽڼ
/*
    øʽ ֽڼ页 ָֽڼ ֽڼ ָֽڼֽڼ ָֽڼݣ ҪصֽڼĿݣ - ϵͳֿ֧->ֽڼ
    ӢƣSplitBin
    ָֽڼзָطָһάֽڼ顣Ϊ
    <1>ΪָֽڼΪֽڼbinֵһΪֽڼ򷵻һ飬ûκγԱ顣
    <2>ΪָֽڼΪֽڼbinԱʡԡڱʶֽڼ߽硣ʡԣĬʹֽ 0 Ϊָ
    <3>ΪҪصֽڼĿΪͣintԱʡԡʡԣĬϷеֽڼ
*/
LIBAPI(void*, krnln_SplitBin)
{// ߺ 
	PMDATA_INF pArgInf = &ArgInf;
	INT nCount = pArgInf [2].m_dtDataType == _SDT_NULL ? 0x7FFFFFFF : pArgInf [2].m_int;
	if (nCount <= 0) 
		return E_NULLARRAY();
	
	LPBYTE pSrc = pArgInf[0].m_pBin ;
	if (!pSrc)
		return E_NULLARRAY();
	INT nSLen = pArgInf[0].m_pInt[1];
	if (nSLen <= 0)
		return E_NULLARRAY();
	pSrc += 2*sizeof(INT);

	LPBYTE pSub = NULL;
	INT nSubLen = 0;
	BYTE bMark [] = {0,0};
	if(pArgInf [1].m_dtDataType == _SDT_NULL)
	{
		pSub = bMark;
		nSubLen = 1;
	}
	else
	{
		if (pArgInf [1].m_pBin)
		{
			pSub = pArgInf [1].m_pBin + 2*sizeof(INT);
			nSubLen =  pArgInf [1].m_pInt[1];
		}
	}

	if (nSubLen == 0)
		nCount = -1;//һԱ

	// ʼ
	TBR tbr;
	INT nPos;
	INT nSYLen = nSLen;
	LPBYTE pFirst = pSrc;
	LPBYTE cp = pSrc;
	for (; nCount > 0; nCount--)
	{
		nPos = myinstring(cp, nSYLen, pSub, nSubLen);
		if (nPos == -1)
			break;
		cp += nPos;
		tbr.add(pFirst, cp - pFirst);
		cp += nSubLen;
		nSYLen -= nPos + nSubLen;
		pFirst = cp;
	}
	LPBYTE pLast = pSrc + nSLen;
	if (pLast - pFirst > 0 && nCount != 0)
		tbr.add(pFirst, pLast - pFirst);
	
	// ݡ
	nCount = tbr.m_nCount;
	INT nSize = nCount * sizeof (DWORD);
	LPBYTE p = (LPBYTE)E_MAlloc_Nzero (sizeof (INT) * 2 + nSize);
	*(LPINT)p = 1;  // ά
	*(LPINT)(p + sizeof (INT)) = nCount;
	LPINT pp = (LPINT)(p + 2*sizeof(INT));
	for (int i=0; i < nCount; i++)
	{
		*pp = (INT)CloneBinData((LPBYTE)(tbr.m_data[i].addr), tbr.m_data[i].len);
		pp++;
	}
	return p;  // 顣
}


================================================
FILE: krnln/krnln_StrComp.cpp
================================================
#include "stdafx.h"

//ı - ıȽ
/*
    øʽ ͡ ıȽ ı Ƚıһı Ƚı߼ ǷִСд - ϵͳֿ֧->ı
    ӢƣStrComp
    ֵС0ʾıһСı0ʾıһı0ʾıһıȽʱִСдҲʹñȽͬIJΪ
    <1>ΪȽıһΪıͣtext
    <2>ΪȽıΪıͣtext
    <3>ΪǷִСдΪ߼ͣboolʼֵΪ桱ΪִСдΪٲ֡
*/
LIBAPI(int, krnln_StrComp)
{
	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[2].m_bool)//ִСд
		return strcmp(pArgInf[0].m_pText,pArgInf[1].m_pText);

#if _MSC_VER == 1200
	return stricmp(pArgInf[0].m_pText,pArgInf[1].m_pText);
#else
	return _stricmp(pArgInf[0].m_pText, pArgInf[1].m_pText);
#endif
}


================================================
FILE: krnln/krnln_StrToUTF8.cpp
================================================
#include "stdafx.h"

// øʽ ֽڼ ıUTF8 ı תı - ϵͳֿ֧->ı
// ӢƣStrToUTF8
// ָıתUTF8ʽ󷵻,עUTF8ıݰַ.Ϊ
// <1>ΪתıΪıͣtextṩתUTF8ʽı
// 
// ϵͳ WindowsLinux
LIBAPI(void*, krnln_StrToUTF8)
{
	PMDATA_INF pArgInf = &ArgInf;
	char* pSrc = pArgInf[0].m_pText;
	if (!pSrc || !*pSrc) return NULL;

	//ȽASCIIתUNICODE
	int nNum = MultiByteToWideChar(CP_ACP, 0, pSrc, -1, NULL, 0);
	if (nNum <=0) return NULL;

	WCHAR* wcsUnicode = new WCHAR[nNum];
	nNum = MultiByteToWideChar(CP_ACP, 0, pSrc, -1, wcsUnicode, nNum);
	if (nNum <= 0)
	{
		delete []wcsUnicode;
		return NULL;
	}
	wcsUnicode[nNum - 1] = 0;

	//UNICODEתUTF8
	nNum = WideCharToMultiByte(CP_UTF8, 0, wcsUnicode, -1, NULL, 0, NULL, NULL);
	pSrc = NULL;
	if (nNum > 0)
	{
		pSrc = (char*)E_MAlloc_Nzero(nNum + 2*sizeof(int));
		if (pSrc)
		{
			*(LPINT)pSrc = 1;
			char* pDes = pSrc + 2*sizeof(int);
			nNum = WideCharToMultiByte(CP_UTF8, 0, wcsUnicode, -1, pDes, nNum, NULL, NULL);
			*(LPINT)(pSrc + sizeof(int)) = nNum - 1; // ȥβ'\0' Աһ
		}
	}
	delete []wcsUnicode;
	return pSrc;
}

//    øʽ ֽڼ ıUTF16 ı תı - ϵͳֿ֧->ı
//    ӢƣStrToUTF16
//    ָıתUTF16ʽ󷵻,עUTF16ıݰַ.Ϊ
//    <1>ΪתıΪıͣtextṩתUTF16ʽı
//
//    ϵͳ Windows
LIBAPI(void*, krnln_fnStrToUTF16)
{
	PMDATA_INF pArgInf = &ArgInf;
	char* pSrc = pArgInf[0].m_pText;
	if (!pSrc || !*pSrc) return NULL;
	
	//ȽASCIIתUNICODE
	int nNum = MultiByteToWideChar(CP_ACP, 0, pSrc, -1, NULL, 0);
	if (nNum <=0) return NULL;
	
	WCHAR* wcsUnicode = new WCHAR[nNum];
	nNum = MultiByteToWideChar(CP_ACP, 0, pSrc, -1, wcsUnicode, nNum);
	if (nNum <= 0)
	{
		delete []wcsUnicode;
		return NULL;
	}
	wcsUnicode[nNum - 1] = 0;
	
	//UNICODEתUTF8
	nNum = WideCharToMultiByte(CP_UTF8, 0, wcsUnicode, -1, NULL, 0, NULL, NULL);
	if (nNum <= 0)
	{
		delete []wcsUnicode;
		return NULL;
	}

	char* pszUtf8 = new char[nNum];
	nNum = WideCharToMultiByte(CP_UTF8, 0, wcsUnicode, -1, pszUtf8, nNum, NULL, NULL);

	//UTF8תUTF16
	nNum = MultiByteToWideChar(CP_UTF8, 0, pszUtf8, -1, NULL, 0);
	if (nNum > 0)
	{
		pSrc = (char*)E_MAlloc_Nzero(nNum * 2 + 2*sizeof(int));
		if (pSrc)
		{
			*(LPINT)pSrc = 1;
			char* pDes = pSrc + 2*sizeof(int);
			nNum = MultiByteToWideChar(CP_UTF8, 0, pszUtf8, -1, (LPWSTR)pDes, nNum);
			*(LPINT)(pSrc + sizeof(int)) = nNum * 2; // β'\0' Աһ
		}
	}
	delete []wcsUnicode;
	delete []pszUtf8;
	return pSrc;
}

================================================
FILE: krnln/krnln_TimeChg.cpp
================================================
#include "stdafx.h"
#include <math.h>

#include <oleauto.h>
#pragma comment(lib, "OleAut32.lib")

//ʱ - ʱ
/*void GetDatePart(DATE dt,INT& nYear,INT& nMonth,INT& nDay)
    øʽ ʱ͡ ʱ ʱ ʱ䣬 Ӳ֣ ֵ - ϵͳֿ֧->ʱ
    ӢƣTimeChg
    һʱ䣬һʱ䱻ϻȥһμıʱЧԶЧʱ䡣Ϊ
    <1>Ϊʱ䡱Ϊʱͣdate
    <2>ΪӲ֡Ϊͣintֵָӻʱһ֣Ϊ³
	1#ݣ 2#ȣ 3#·ݣ 4#ܣ 5#գ 6#Сʱ 7#ӣ 8#롣
    <3>ΪֵΪͣintڱӲֵӻֵ
*/
LIBAPI(void, krnln_TimeChg)
{
	PMDATA_INF pArgInf = &ArgInf;

	SYSTEMTIME st = {0};
	VariantTimeToSystemTime(pArgInf[0].m_date, &st);

	switch(pArgInf[1].m_int)
	{
	case 1://#
		{
			st.wYear += pArgInf[2].m_int;
			if(st.wMonth == 2 && st.wDay == 29)
				st.wDay = GetDaysOfSpecMonth(st.wYear, 2);

			SystemTimeToVariantTime(&st, &pArgInf[0].m_date);
			break;
		}
	case 2://#
		{
			INT nMonth;
			nMonth = st.wMonth + (pArgInf[2].m_int * 3);
			if(nMonth>0)
			{
				st.wYear += (nMonth / 12);
				nMonth %= 12;
			}
			else
			{
				INT decYear = nMonth / 12;
				if(nMonth % 12 != 0)
					decYear--;
				st.wYear += decYear;
				nMonth = 12 + (nMonth % 12);
			}
			st.wMonth = nMonth;

			INT nMaxDay = GetDaysOfSpecMonth(st.wYear, nMonth);
			if(st.wDay > nMaxDay)
				st.wDay = nMaxDay;

			SystemTimeToVariantTime(&st, &pArgInf[0].m_date);
			break;
		}
	case 3://#·
		{
			INT nMonth;

			nMonth = st.wMonth + pArgInf[2].m_int;
			if(nMonth > 0)
			{
				if(nMonth > 12)
					st.wYear += (nMonth / 12);
				nMonth %= 12;
				if(nMonth == 0)
					nMonth = 12;

			}
			else
			{
				INT decYear = nMonth / 12;
				if(nMonth % 12 !=0 || nMonth ==0)
					decYear--;
				st.wYear += decYear;
				nMonth = 12 + (nMonth % 12);
			}
			st.wMonth = nMonth;

			INT nMaxDay = GetDaysOfSpecMonth(st.wYear, nMonth);
			if(st.wDay > nMaxDay)
				st.wDay = nMaxDay;
			
			SystemTimeToVariantTime(&st, &pArgInf[0].m_date);
			break;
		}
	case 4://#
		{
			DATE objDate;
			DATE dt = modf(pArgInf[0].m_date, &objDate);
			objDate += (7 * pArgInf[2].m_int);
			pArgInf[0].m_date = makedb(objDate, dt);
			break;
		}
	case 5://#
		{
			DATE objDate;
			DATE dt = modf(pArgInf[0].m_date, &objDate);
			objDate += pArgInf[2].m_int;
			pArgInf[0].m_date = makedb(objDate, dt);
			break;
		}
	case 6://#Сʱ
		{
			SystemTimeToVariantTime(&st, &pArgInf[0].m_date); //ֹʱ侫ԽԽ
			pArgInf[0].m_date = toMyDate(pArgInf[0].m_date);
			pArgInf[0].m_date += double(pArgInf[2].m_int) / 24.0;
			pArgInf[0].m_date = toEDate(pArgInf[0].m_date);
			break;
		}
	case 7://#
		{
			SystemTimeToVariantTime(&st, &pArgInf[0].m_date); //ֹʱ侫ԽԽ
			pArgInf[0].m_date = toMyDate(pArgInf[0].m_date);
			pArgInf[0].m_date += double(pArgInf[2].m_int) / 1440.0;
			pArgInf[0].m_date = toEDate(pArgInf[0].m_date);
			break;
		}
	case 8://#롣
		{
			SystemTimeToVariantTime(&st, &pArgInf[0].m_date); //ֹʱ侫ԽԽ
			pArgInf[0].m_date = toMyDate(pArgInf[0].m_date);
			pArgInf[0].m_date += double(pArgInf[2].m_int) / 86400.0;
			pArgInf[0].m_date = toEDate(pArgInf[0].m_date);
			break;
		}
	}
	__asm{
		mov eax, ArgInf.m_unit.m_dwFormID;
		mov edx, ArgInf.m_unit.m_dwUnitID;
	}

}


================================================
FILE: krnln/krnln_TimeDiff.cpp
================================================
#include "stdafx.h"
#include <math.h>

//ʱ - ȡʱ
/*
    øʽ ˫С͡ ȡʱ ʱ ʱ1ʱ ʱ2 ȡ֣ - ϵͳֿ֧->ʱ
    ӢƣTimeDiff
    һֵʾʱ1ȥʱ2֮ļĿע⣺ÿΪһ졣Ϊ
    <1>Ϊʱ1Ϊʱͣdate
    <2>Ϊʱ2Ϊʱͣdate
    <3>Ϊȡ֡ΪͣintֵָȡʱĵλΪ³ 1#ݣ 2#ȣ 3#·ݣ 4#ܣ 5#գ 6#Сʱ 7#ӣ 8#롣
*/

//ʼڶ
//ʼ 18991230 ֵΪ0, Ϊһ()
//-13-7 ǵ-1
//-60 ǵ0
//17 ǵ1
double GetWeekDayNum(DATE dt)
{
	INT nRet;
	if ((INT)dt > 0) {
		nRet = ((INT)dt + 6) / 7;
	}
	else {
		nRet = (INT)dt / 7;
	}
	return (double)nRet;
}

LIBAPI(void, krnln_TimeDiff)
{
	PMDATA_INF pArgInf = &ArgInf;
	
	switch(pArgInf[2].m_int)
	{
	case 1://#
		{
			INT nYear, nMonth, nDay;
			INT nYear1, nMonth1, nDay1;
			GetDatePart(pArgInf[0].m_date, nYear, nMonth, nDay);
			GetDatePart(pArgInf[1].m_date, nYear1, nMonth1, nDay1);
			pArgInf[0].m_date = nYear - nYear1;
			break;
		}
	case 2://#
		{
			INT nYear, nMonth, nDay;
			INT nYear1, nMonth1, nDay1;
			GetDatePart(pArgInf[0].m_date, nYear, nMonth, nDay);
			GetDatePart(pArgInf[1].m_date, nYear1, nMonth1, nDay1);
			pArgInf[0].m_date = (nYear - nYear1) * 4 + ((nMonth - 1) / 3) - ((nMonth1 - 1) / 3);
			break;
		}
	case 3://#·
		{
			INT nYear, nMonth, nDay;
			INT nYear1, nMonth1, nDay1;
			GetDatePart(pArgInf[0].m_date, nYear, nMonth, nDay);
			GetDatePart(pArgInf[1].m_date, nYear1, nMonth1, nDay1);
			pArgInf[0].m_date = (nYear - nYear1) * 12 - nMonth1 + nMonth;
 			break;
		}
	case 4://#
		{
			DATE objDate, objDate1;
			DATE dt = modf(pArgInf[0].m_date, &objDate);
			dt = modf(pArgInf[1].m_date, &objDate1);

			pArgInf[0].m_date = GetWeekDayNum(objDate) - GetWeekDayNum(objDate1);
			break;
		}
	case 5://#
		{
			DATE objDate = toMyDate(pArgInf[0].m_date) - toMyDate(pArgInf[1].m_date);
			pArgInf[0].m_date = objDate;
			break;
		}
	case 6://#Сʱ
		{
			DATE objDate = toMyDate(pArgInf[0].m_date) - toMyDate(pArgInf[1].m_date);
			modf(objDate * 24.0 + 0.000005787037037037037, &pArgInf[0].m_date);
			break;
		}
	case 7://#
		{
			DATE objDate = toMyDate(pArgInf[0].m_date) - toMyDate(pArgInf[1].m_date);
			modf(objDate * 1440.0 + 0.000005787037037037037, &pArgInf[0].m_date);
			break;
		}
	case 8://#롣
		{
			DATE objDate = toMyDate(pArgInf[0].m_date) - toMyDate(pArgInf[1].m_date);
			modf(objDate * 86400.0 + 0.000005787037037037037, &pArgInf[0].m_date);
			break;
		}
	default:
		pArgInf[0].m_double = 0;

	}
	__asm{
		mov eax, ArgInf.m_unit.m_dwFormID;
		mov edx, ArgInf.m_unit.m_dwUnitID;
	}

}


================================================
FILE: krnln/krnln_TimePart.cpp
================================================
#include "stdafx.h"
#include <math.h>
//ʱ - ȡʱ䲿
/*
    øʽ ͡ ȡʱ䲿 ʱ ȡ䲿ֵʱ䣬 ȡʱ䲿֣ - ϵͳֿ֧->ʱ
    ӢƣTimePart
    һ֪ʱֵָΪ
    <1>Ϊȡ䲿ֵʱ䡱Ϊʱͣdate
    <2>Ϊȡʱ䲿֡ΪͣintֵΪ³
	1#ݣ 2#ȣ 3#·ݣ 4# 5#գ 6#Сʱ 7#ӣ 8#룻 9#ڼ 10#У 1 ʼ
*/
INT GetDaysFromYear(DATE date)
{
	INT nYear, nMonth, nDay;
	GetDatePart(date, nYear, nMonth, nDay);
	INT nCountDay = nDay;
	for(INT i = 1; i < nMonth; i++)
		nCountDay += GetDaysOfSpecMonth(nYear, i);
	return nCountDay;
}

LIBAPI(int, krnln_TimePart)
{
	PMDATA_INF pArgInf = &ArgInf;
	INT nRet = 0;
	switch(pArgInf[1].m_int)
	{
	case 1://#
		{
			INT nYear, nMonth, nDay;
			GetDatePart(pArgInf[0].m_date, nYear, nMonth, nDay);
			nRet = nYear;
			break;
		}
	case 2://#
		{
			INT nYear, nMonth, nDay;
			GetDatePart(pArgInf[0].m_date, nYear, nMonth, nDay);
			nRet = nMonth / 3;
			if(nMonth % 3) nRet++;
			break;
		}
	case 3://#·
		{
			INT nYear, nMonth, nDay;
			GetDatePart(pArgInf[0].m_date, nYear, nMonth, nDay);
			nRet = nMonth;
			break;
		}
	case 4://#
		{
			INT nCountDay = GetDaysFromYear(pArgInf[0].m_date);
			nRet = nCountDay / 7;
			if(nCountDay % 7) nRet++;
			break;
		}
	case 5://#
		{
			INT nYear, nMonth, nDay;
			GetDatePart(pArgInf[0].m_date, nYear, nMonth, nDay);
			nRet = nDay;
			break;
		}
	case 6://#Сʱ
		{
			INT nHour, nMinute, nSecond;
			GetTimePart(pArgInf[0].m_date, nHour, nMinute, nSecond);
			nRet = nHour;
			break;
		}
	case 7://#
		{
			INT nHour, nMinute, nSecond;
			GetTimePart(pArgInf[0].m_date, nHour, nMinute, nSecond);
			nRet = nMinute;
			break;
		}
	case 8://#롣
		{
			INT nHour, nMinute, nSecond;
			GetTimePart(pArgInf[0].m_date, nHour, nMinute, nSecond);
			nRet = nSecond;
			break;
		}
	case 9://#ڼ
		{
			nRet = GetWeekDay(pArgInf[0].m_date);
			break;
		}
	case 10://#
		{
			nRet = GetDaysFromYear(pArgInf[0].m_date);
			break;
		}
	}
	return nRet ;
}


================================================
FILE: krnln/krnln_TimeToText.cpp
================================================
#include "stdafx.h"
#include <stdio.h>
#include <math.h>
#include "Myfunctions.h"

//ʱ - ʱ䵽ı
/*
    øʽ ı͡ ʱ䵽ı ʱ תıʱ䣬 ת֣ݣ - ϵͳֿ֧->ʱ
    ӢƣTimeToText
    ָʱתΪıءΪ
    <1>Ϊתıʱ䡱Ϊʱͣdate
    <2>Ϊת֡ΪͣintԱʡԡֵΪ³
	1#ȫת 2#ڲ֣ 3#ʱ䲿֡ʡ˱ĬΪ#ȫת
*/
LIBAPI(char*, krnln_TimeToText)
{
	PMDATA_INF pArgInf = &ArgInf;
	char str[128];
	if(pArgInf[1].m_int==2)
	{
		DateTimeFormat(str,ArgInf.m_date,TRUE);

	}else if(pArgInf[1].m_int==3)
	{
		INT nHour, nMinute, nSecond;
		GetTimePart(ArgInf.m_date, nHour, nMinute, nSecond);
		sprintf(str,"%dʱ%d%d",nHour, nMinute, nSecond);

	}else{
		DateTimeFormat(str, ArgInf.m_date);
	}
	INT nLen = mystrlen(str);
	char* pText = (char*)E_MAlloc_Nzero(nLen+1);
	strcpy(pText,str);
	return pText;

}


================================================
FILE: krnln/krnln_ToBin.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
//ֽڼ - ֽڼ
/*
    øʽ ֽڼ ֽڼ ͨ/ תΪֽڼݣ - ϵͳֿ֧->ֽڼ
    ӢƣToBin
    ָתΪֽڼ󷵻תΪ
    <1>ΪתΪֽڼݡΪͨͣallṩʱͬʱṩݡֵֻΪݻֵ顣
*/
        // 
LPBYTE GetMDataPtr (PMDATA_INF pInf, LPINT pnDataSize)
{
//	ASSERT (GetDataTypeType (pInf->m_dtDataType) == DTT_IS_SYS_DATA_TYPE);
	
	switch (pInf->m_dtDataType)
	{
	case SDT_BYTE:
		*pnDataSize = sizeof (BYTE);
		return (LPBYTE)&pInf->m_byte;
	case SDT_SHORT:
		*pnDataSize = sizeof (SHORT);
		return (LPBYTE)&pInf->m_short;
	case SDT_INT:
		*pnDataSize = sizeof (INT);
		return (LPBYTE)&pInf->m_int;
	case SDT_INT64:
		*pnDataSize = sizeof (INT64);
		return (LPBYTE)&pInf->m_int64;
	case SDT_FLOAT:
		*pnDataSize = sizeof (FLOAT);
		return (LPBYTE)&pInf->m_float;
	case SDT_DOUBLE:
		*pnDataSize = sizeof (DOUBLE);
		return (LPBYTE)&pInf->m_double;
	case SDT_BOOL:
		*pnDataSize = sizeof (BOOL);
		return (LPBYTE)&pInf->m_bool;
	case SDT_DATE_TIME:
		*pnDataSize = sizeof (DATE);
		return (LPBYTE)&pInf->m_date;
	case SDT_SUB_PTR:
		*pnDataSize = sizeof (DWORD);
		return (LPBYTE)&pInf->m_dwSubCodeAdr;
	case SDT_TEXT:
		*pnDataSize = mystrlen (pInf->m_pText) + 1;
		return (LPBYTE)pInf->m_pText;
	case SDT_BIN: {
		LPBYTE pBinData = pInf->m_pBin + sizeof (INT) * 2;
		*pnDataSize = *(LPINT)(pBinData - sizeof (INT));
		return pBinData; }
	default:
//		ASSERT (FALSE);
		return NULL;
	}
}
int __cdecl IsNumDataType2(DWORD a1)
{
  int result; // eax@1

  result = GetDataTypeType(a1);
  if ( result != 1 || (BYTE)a1 != 1 )
    result = 0;
  return result;
}
int __cdecl GetSysDataTypeDataSize2( int a1)
{
  if ( (DWORD)a1 <= 0x80000101 )
  {
    if ( a1 == -2147483391 )
      return 1;
    switch ( a1 )
    {
      case -2147483645:
      case -2147483640:
        return 8;
      case -2147483646:
      case -2147483644:
      case -2147483643:
      case -2147483642:
        return 4;
      default:
        return 0;
    }
    return 0;
  }
  if ( (unsigned int)a1 <= 0x80000401 )
  {
    if ( a1 != -2147482623 )
    {
      if ( a1 == -2147483135 )
        return 2;
      if ( a1 == -2147482879 )
        return 4;
      return 0;
    }
    return 8;
  }
  if ( a1 == -2147482367 )
    return 4;
  if ( a1 == -2147482111 )
    return 8;
  return 0;
}

LIBAPI(void*, krnln_ToBin)
{
            //!!! ھ AS_RECEIVE_VAR_OR_ARRAY  AS_RECEIVE_ALL_TYPE_DATA ־IJ
            // пܴDT_IS_ARY־·ʽͺ־

	PMDATA_INF pArgInf = &ArgInf;
	DATA_TYPE dtDataType = pArgInf [0].m_dtDataType & ~DT_IS_ARY;
	BOOL blIsAry = (pArgInf [0].m_dtDataType & DT_IS_ARY) != 0;
	
	LPBYTE pData;
	INT nDataSize;
	if (IsNumDataType2(dtDataType) && blIsAry == TRUE)
	{
		DWORD dwSize;
		pData = (LPBYTE)GetAryElementInf(pArgInf [0].m_pAryData,dwSize);
		nDataSize = dwSize * GetSysDataTypeDataSize2(dtDataType);
	}
	else if (blIsAry == TRUE || GetDataTypeType (dtDataType) != DTT_IS_SYS_DATA_TYPE)
	{
		return NULL;
	}
	else if (dtDataType == SDT_TEXT)
	{
		pData = (LPBYTE)pArgInf->m_pText;
		nDataSize = mystrlen (pArgInf->m_pText);
	}
	else
		pData = GetMDataPtr (pArgInf, &nDataSize);
	
	return CloneBinData (pData, nDataSize);
}


================================================
FILE: krnln/krnln_ToByte.cpp
================================================
#include "stdafx.h"

//ֵת - ֽ
/*
    øʽ ֽ͡ ֽ ͨ תıֵ - ϵͳֿ֧->ֵת
    ӢƣToByte
    ذıڵֵֽıһʵ͵ֵ֧ȫдʽҲ͵תΪֽڡΪ
    <1>ΪתıֵΪͨͣall
*/
LIBAPI(BYTE, krnln_ToByte)
{
	BYTE nRet=0;
	switch(ArgInf.m_dtDataType)
	{
	case SDT_TEXT:
		{
			char* pStr = krnln_BJCase(1,ArgInf);
			if(pStr)
			{
				nRet = atoi(pStr);
				E_MFree(pStr);
			}
			else
				nRet = 0;
		}
		break;
	case SDT_BYTE:
	case SDT_BOOL:
		nRet = ArgInf.m_byte;
		break;
	case SDT_SHORT:
		nRet = (BYTE)ArgInf.m_short;
		break;
	case SDT_INT:
		nRet = ArgInf.m_int;
		break;
	case SDT_FLOAT:
		nRet = (BYTE)ArgInf.m_float;
		break;
	case SDT_DOUBLE:
		nRet = (BYTE)ArgInf.m_double;
		break;
	case SDT_INT64:
		nRet = (BYTE)ArgInf.m_int64;
		break;
	default:
		nRet = ArgInf.m_byte;
		break;

	}
	return nRet;
}


================================================
FILE: krnln/krnln_ToFloat.cpp
================================================
#include "stdafx.h"
//ֵת - С
/*
    øʽ С͡ С ͨ תıֵ - ϵͳֿ֧->ֵת
    ӢƣToFloat
    ذıڵСֵıһʵ͵ֵ֧ȫдʽҲ͵תΪСΪ
    <1>ΪתıֵΪͨͣall
*/
LIBAPI(void, krnln_ToFloat)
{
	float nRet=0;
	switch(ArgInf.m_dtDataType)
	{
	case SDT_TEXT:
		{
			char* pStr = krnln_BJCase(1,ArgInf);
			if(pStr)
			{
				nRet = (float)atof(pStr);
				E_MFree(pStr);
			}
		}
		break;
	case SDT_BYTE:
		nRet = ArgInf.m_byte;
		break;
	case SDT_SHORT:
		nRet = ArgInf.m_short;
		break;
	case SDT_INT:
	case SDT_SUB_PTR:
	case SDT_BOOL:
		nRet = (float)ArgInf.m_int;
		break;
	case SDT_FLOAT:
		nRet = ArgInf.m_float;
		break;
	case SDT_DOUBLE:
		nRet = (float)ArgInf.m_double;
		break;
	case SDT_INT64:
		nRet = (float)ArgInf.m_int64;
		break;
	default:
		break;

	}
	_asm mov eax, nRet;
	_asm xor edx, edx;
	//return nRet;
}


================================================
FILE: krnln/krnln_ToInt.cpp
================================================
#include "stdafx.h"

//ֵת - 
/*
    øʽ ͡  ͨ תıֵ - ϵͳֿ֧->ֵת
    ӢƣToInt
    ذıڵֵıһʵ͵ֵ֧ȫдʽҲ͵תΪΪ
    <1>ΪתıֵΪͨͣall
*/
LIBAPI(INT, krnln_ToInt)
{
	INT nRet=0;
	switch(ArgInf.m_dtDataType)
	{
	case SDT_TEXT:
		{
			char* pStr = krnln_BJCase(1,ArgInf);
			if(pStr)
			{
				nRet = atoi(pStr);
				E_MFree(pStr);
			}
			else
				nRet = 0;
		}
		break;
	case SDT_BYTE:
		nRet = ArgInf.m_byte;
		break;
	case SDT_SHORT:
		nRet = ArgInf.m_short;
		break;
	case SDT_INT:
	case SDT_SUB_PTR:
	case SDT_BOOL:
		nRet = ArgInf.m_int;
		break;
	case SDT_FLOAT:
		nRet = (INT)ArgInf.m_float;
		break;
	case SDT_DOUBLE:
		nRet = (INT)ArgInf.m_double;
		break;
	case SDT_INT64:
		nRet = (INT)ArgInf.m_int64;
		break;
	default:
		break;

	}
	return nRet;
}


================================================
FILE: krnln/krnln_ToLong.cpp
================================================
#include "stdafx.h"

//ֵת - 
/*
    øʽ ͡  ͨ תıֵ - ϵͳֿ֧->ֵת
    ӢƣToLong
    ذıڵijֵıһʵ͵ֵ֧ȫдʽҲ͵תΪΪ
    <1>ΪתıֵΪͨͣall
*/
LIBAPI(void, krnln_ToLong)
{
	INT64 nRet=0;
	switch(ArgInf.m_dtDataType)
	{
	case SDT_BYTE:
	case SDT_BOOL:
		nRet = ArgInf.m_byte;
		break;
	case SDT_SHORT:
		nRet = ArgInf.m_short;
		break;
	case SDT_TEXT:
		{
			char* pStr = krnln_BJCase(1,ArgInf);
			if(pStr)
			{
				nRet = _atoi64(pStr);
				ArgInf.m_int64 = nRet;
				E_MFree(pStr);
			}
		}
		break;
	case SDT_FLOAT:
		nRet = (INT64)ArgInf.m_float;
		break;
	case SDT_DOUBLE:
		nRet = (INT64)ArgInf.m_double;
		break;
	case SDT_SUB_PTR:
	case SDT_INT:
		nRet = ArgInf.m_int;
		break;
	case SDT_INT64:
		nRet = ArgInf.m_int64;
		break;
	default:
		break;
	}
	ArgInf.m_int64 = nRet;
	__asm{
		mov eax, ArgInf.m_unit.m_dwFormID;
		mov edx, ArgInf.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_ToShort.cpp
================================================
#include "stdafx.h"

//ֵת - 
/*
    øʽ ͡  ͨ תıֵ - ϵͳֿ֧->ֵת
    ӢƣToShort
    ذıڵĶֵıһʵ͵ֵ֧ȫдʽҲ͵תΪΪ
    <1>ΪתıֵΪͨͣall
*/
LIBAPI(SHORT, krnln_ToShort)
{
	SHORT nRet=0;
	switch(ArgInf.m_dtDataType)
	{
	case SDT_TEXT:
		{
			char* pStr = krnln_BJCase(1,ArgInf);
			if(pStr)
			{
				nRet = atoi(pStr);
				E_MFree(pStr);
			}
			else
				nRet = 0;
		}
		break;
	case SDT_BYTE:
		nRet = ArgInf.m_byte;
		break;
	case SDT_SHORT:
		nRet = ArgInf.m_short;
		break;
	case SDT_INT:
		nRet = ArgInf.m_int;
		break;
	case SDT_FLOAT:
		nRet = (SHORT)ArgInf.m_float;
		break;
	case SDT_DOUBLE:
		nRet = (SHORT)ArgInf.m_double;
		break;
	case SDT_INT64:
		nRet = (SHORT)ArgInf.m_int64;
		break;
	default:
		break;

	}
	return nRet;
}


================================================
FILE: krnln/krnln_ToTime.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
//ʱ - ʱ
/*
    øʽ ʱ͡ ʱ ͨ תı - ϵͳֿ֧->ʱ
    ӢƣToTime
    ָıתΪʱ䲢ءıдʽҪʱֵ²ܽת10011աʱݣֱӷظʱ䡣Ϊ
    <1>ΪתıΪͨͣallıӦ¸ʽ֮һṩݺʱ䲿ֿʡԣ
  11973111512ʱ3025
  21973/11/15 12:30:25
  31973/11/15/12/30/25
  41973/11/15/12:30:25
  51973-11-15-12-30-25
  61973-11-15-12:30:25
  71973.11.15 12:30:25
  819731115123025
*/
//189912300ʱ0000 Ϊ0׼,λΪСֵ
BOOL StrToTime (double& dbDateTime,LPCSTR pStr)
{
	INT nLen = mystrlen(pStr);
	if(nLen < 8) return FALSE;

	char* pStrSrc = new char[nLen + 1];
	strcpy(pStrSrc,pStr);
	LPSTR sDtArry[6]={0};
	LPSTR pStart = pStrSrc;
	LPSTR pEnd = pStrSrc + nLen;
	INT nIDX = 0;
	LPSTR pTemp = pStart;
	BOOL spliteChn = FALSE;
	BOOL spliteEng = FALSE;
	INT spliteChr = 0;
	while(pStart < pEnd)
	{
		if(*pStart < 0)//
		{
			if(spliteEng==FALSE && pStart > pStrSrc)//ѾҵһЩ
			{
				if(strncmp(pStart,"",2)==0)
				{
					if(nIDX !=0)//겻ǰ˳
						break;
					*pStart = 0;
					pStart+=2;
					sDtArry[0] = pTemp;
					pTemp = pStart;
					nIDX++;//
					spliteChn = TRUE;
				}else if(strncmp(pStart,"",2)==0)
				{
					if(nIDX !=1)//²ǰ˳
						break;
					*pStart = 0;
					pStart+=2;
					sDtArry[1] = pTemp;
					pTemp = pStart;
					nIDX++;//
				}else if(strncmp(pStart,"",2)==0)
				{
					if(nIDX !=2)//ղǰ˳
						break;
					*pStart = 0;
					pStart+=2;
					sDtArry[2] = pTemp;
					pTemp = pStart;
					nIDX++;
				}else if(strncmp(pStart,"ʱ",2)==0)
				{
					if(nIDX !=3)//ղǰ˳
						break;
					*pStart = 0;
					pStart+=2;
					sDtArry[3] = pTemp;
					pTemp = pStart;
					nIDX++;
				}else if(strncmp(pStart,"",2)==0)
				{
					if(nIDX !=4)//ղǰ˳
						break;
					*pStart = 0;
					pStart+=2;
					sDtArry[4] = pTemp;
					pTemp = pStart;
					nIDX++;
				}else if(strncmp(pStart,"",2)==0)
				{
					if(nIDX !=5)//ղǰ˳
						break;
					*pStart = 0;
					pStart+=2;
					sDtArry[5] = pTemp;
					nIDX++;
				}else
					break;


			}
			else
				break;//Ƿ
		}
		else
		{
			if(48 <= *pStart && *pStart <= 57)//' ַΧ48--57
			{
				pStart++;
				if(0 == *pStart)//
				{
					sDtArry[nIDX] = pTemp;
					nIDX++;
				}
			}
			else if(nIDX ==0 && spliteChr == 0)//ȷӢķָ
			{
				if(spliteChn)//ѾǺָʽ
					break;
				if(*pStart =='/' || *pStart =='-' || *pStart =='.')
				{
					spliteChr = *pStart;
					spliteEng = TRUE;
					*pStart = 0;
					pStart++;
					sDtArry[0] = pTemp;
					pTemp = pStart;
					nIDX++;



				}
				else
					break; //ǺϷָ

			}
			else if(nIDX ==3 && spliteChr == 0)//ȷʱָ
			{
				if(spliteChn)//ѾǺָʽ
					break;
				if(*pStart =='/' || *pStart =='-' || *pStart ==':')
				{
					spliteChr = *pStart;
					*pStart = 0;
					pStart++;
					sDtArry[3] = pTemp;
					pTemp = pStart;
					nIDX++;

				}
				else
					break; //ǺϷָ
			}
			else if(nIDX ==2 && (*pStart==' ' || *pStart =='/' || *pStart =='-' || *pStart==0))//ָ
			{
				*pStart = 0;
				pStart++;
				sDtArry[2] = pTemp;
				pTemp = pStart;
				nIDX++;
				spliteChr = 0;
			}
			else if(spliteChr == *pStart)//Ϸָ
			{
				*pStart = 0;
				pStart++;
				sDtArry[nIDX] = pTemp;
				pTemp = pStart;
				nIDX++;
			}else
				break; //ǺϷַ

		}

	}

	if(pStart >= pEnd)//ȫɨϲŽ,ʽȷ
	{
		if(nIDX==1)//ȫִʽ
		{
			delete [] pStrSrc;
			pStrSrc = new char[256];
			memset(pStrSrc,0,20);
			pStart = pStrSrc;
			INT nMax = 0;
			nIDX = 0;

			while(nMax < nLen)
			{
				if(nIDX==0)
				{
					strncpy(pStart,pStr,4);
					sDtArry[0] = pStart;
					pStart+=5;
					nIDX++;
					nMax +=4;
				}
				else
				{
					strncpy(pStart,pStr+nMax,2);
					sDtArry[nIDX] = pStart;
					pStart+=3;
					nIDX++;
					nMax +=2;
				}

			}


		}
		else if(nIDX < 2) //ڲֲȫ
		{
			delete [] pStrSrc;
			return FALSE;
		}
		INT nYear, nMonth, nDay, nHour, nMinute, nSecond;//ʱǷȷ
		nHour = nMinute = nSecond = 0;
		BOOL bError = FALSE;
		for(INT i=0; i < nIDX;i++)
		{
			INT nValue = atoi(sDtArry[i]);
			switch(i)
			{
			case 0://
				
				if(nValue==0)
				{
					bError = TRUE;
					break;
				}
				nYear = nValue;
				break;
			case 1://
				
				if(nValue < 1 || nValue > 12)
				{
					bError = TRUE;
					break;
				}
				nMonth = nValue;
				break;
			case 2://
				{
					DWORD nMonDay [12] = {31,28,31,30,31,30,31,31,30,31,30,31};
					if((nYear % 400==0) || (nYear % 100 != 0) && (nYear %4 ==0))//
						nMonDay [1] = 29; //				
					if(nValue < 1 || nValue > (INT)(nMonDay [nMonth-1]))
					{
						bError = TRUE;
						break;
					}
					nDay = nValue;
					break;
				}
			case 3://ʱ
				
				if(nValue > 23)
				{
					bError = TRUE;
					break;
				}
				nHour = nValue;
				break;
			case 4://
				
				if(nValue > 59)
				{
					bError = TRUE;
					break;
				}
				nMinute = nValue;
				break;
			case 5://
				
				if(nValue > 59)
				{
					bError = TRUE;
					break;
				}
				nSecond = nValue;
				break;
			}
		}
		delete [] pStrSrc;
		if(bError)
			return FALSE;

		dbDateTime = GetSpecDateTime(nYear, nMonth, nDay, nHour, nMinute, nSecond);//ʱ
		return TRUE;
	}

	delete [] pStrSrc;
	return FALSE;

}

LIBAPI(void, krnln_ToTime)
{

	switch(ArgInf.m_dtDataType)
	{
	case SDT_TEXT:
		{
			double dbDateTime;
			if(StrToTime(dbDateTime,ArgInf.m_pText)==FALSE)
				dbDateTime = -657434;//10011
			ArgInf.m_double = dbDateTime;
		}
		break;
	case SDT_DATE_TIME:
		break;
	default:
		ArgInf.m_double = -657434;//10011
	}
	__asm{
		mov eax, ArgInf.m_unit.m_dwFormID;
		mov edx, ArgInf.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_TrimAll.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
//ı - ɾȫ
/*
    øʽ ı͡ ɾȫ ı ɾոı - ϵͳֿ֧->ı
    ӢƣTrimAll
    һıаɾȫǻǿոָıΪ
    <1>ΪɾոıΪıͣtext
*/
LIBAPI(char*, krnln_TrimAll)
{// ߺ 
	PMDATA_INF pArgInf = &ArgInf;
	char* pSrc = pArgInf[0].m_pText;
	register char *str1 = pSrc;
	if (!*str1) return NULL;

	// ʼ
	TBR tbr;
	char* pFirst = pSrc;
	while (1)
	{
		//׿
		while ( *str1 )
		{
			if (*str1 == ' ')
				str1++;
			else if (*((unsigned short*)str1) == 0xA1A1)
				str1+=2;
			else
				break;
		}
		if (!*str1) break;
		pFirst = str1;
		if (*str1 < 0) {
			str1+=2;
		} else {
			str1++;
		}
		//β
		while ( *str1 )
		{
			if (*str1 == ' ')
				break;
			else if (*((unsigned short*)str1) == 0xA1A1)
				break;
			if (*str1 < 0)
				str1+=2;
			else
				str1++;
		}
		if (str1 - pFirst > 0)
			tbr.add(pFirst, str1 - pFirst);
	}
	return tbr.toString();
}


================================================
FILE: krnln/krnln_UCase.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

//ı - д
/*
    øʽ ı͡ д ı 任ı - ϵͳֿ֧->ı
    ӢƣUCase
    ıеСдӢĸ任Ϊдر任ĽıΪ
    <1>Ϊ任ıΪıͣtext
*/
LIBAPI(char*, krnln_UCase)
{// ߺŸ
	register char* pSrc = ArgInf.m_pText;
	UINT nLen = mystrlen(pSrc);
	if (nLen==0) return NULL;
	char *pText = (char*)E_MAlloc_Nzero(nLen+1);
	register char* pDes = pText;
	register unsigned char* ut = uptable;
	for (UINT i=0; i<nLen; i++)
	{
		if (pSrc[i]<0)
		{
			*((short*)(pDes+i)) = *((short*)(pSrc+i));
			i++;
		}
		else
		{
			pDes[i] = ut[(unsigned char)(pSrc[i])];
		}
	}
	pText[nLen] = '\0';
	return pText;
}
// {// ԭ
// 	UINT nLen = strlen(ArgInf.m_pText);
// 	if(nLen==0)return NULL;
// 	char *pText = (char*)E_MAlloc(nLen+1);
// 	strcpy(pText,ArgInf.m_pText);
// 	UINT i=0;
// 	while(i < nLen)
// 	{
// 		if(pText[i]<0)
// 			i+=2;//
// 		else
// 		{
// 			pText[i] = toupper(pText[i]);
// 			i++;
// 		}
// 
// 	}
// 	return pText;	
// }


================================================
FILE: krnln/krnln_UNum.cpp
================================================
#include "stdafx.h"
#include <math.h>
#include "Myfunctions.h"

//ֵת - ֵд 
/*
    øʽ ı͡ ֵд ˫С תʽֵ߼ ǷתΪ壩 - ϵͳֿ֧->ֵת
    ӢƣUNum
    ֵתΪĴдʽתıΪ
    <1>ΪתʽֵΪ˫Сͣdouble
    <2>ΪǷתΪ塱Ϊ߼ͣboolʼֵΪ١ֵΪ٣תΪ塣
*/
LIBAPI(char*, krnln_UNum)
{
	PMDATA_INF pArgInf = &ArgInf;
	double dInt;
	double dFloat = modf(pArgInf[0].m_double,&dInt);
	LPSTR pInt = NULL;
	LPSTR pFloat = NULL;
	INT nLen = 3;
	if(dInt !=0)
	{
		INT nPre=1;
		pInt = IntNumToChn(dInt,pArgInf[1].m_bool,nPre);
		nLen += mystrlen(pInt);
	}

	if(dFloat !=0)
	{
		pFloat = FloatNumToChn(dFloat,pArgInf[1].m_bool);
		if(pFloat)
			nLen += mystrlen(pFloat);
	}
	LPSTR pText = (LPSTR)E_MAlloc (nLen);
//	*pText=0;MessageBox(NULL,pText,NULL,MB_OK);
	if(pInt)
	{
		strcpy(pText,pInt);
		free(pInt);
	}else
		strcpy(pText,"");

	if(pFloat)
	{
		strcat(pText,pFloat);
		free(pFloat);
	}

	return pText;	
}


================================================
FILE: krnln/krnln_UTF8ToStr.cpp
================================================
#include "stdafx.h"

// øʽ ı͡ UTF8ı ֽڼ תUTF8ıݣ - ϵͳֿ֧->ı
// ӢƣUTF8ToStr
// ָUTF8ıתͨı󷵻ءΪ
// <1>ΪתUTF8ıݡΪֽڼbinṩתͨıUTF8ıݡ
// 
// ϵͳ WindowsLinux
LIBAPI(char*, krnln_UTF8ToStr)
{
	char* pSrc;
	char* pRet = NULL;
	int nUnicodeLen, nAnsiLen;
	WCHAR *unicodetext;

	if (ArgInf.m_pBin == NULL || ArgInf.m_pInt[1] <= 0) 
		return NULL;

	pSrc = (char*)ArgInf.m_pBin;
	pSrc += 2*sizeof(INT);

	//ȴUTF-8תUNICODE
	nUnicodeLen = MultiByteToWideChar(CP_UTF8, 0, pSrc, ArgInf.m_pInt[1], NULL, 0);
	if (nUnicodeLen <= 0) 
		return NULL;

	unicodetext = new WCHAR[nUnicodeLen + 1];
	MultiByteToWideChar(CP_UTF8, 0, pSrc, ArgInf.m_pInt[1], unicodetext, nUnicodeLen);
	unicodetext[nUnicodeLen] = '\0';

	//UNICDOEתANSI
	nAnsiLen = WideCharToMultiByte(936, 0, unicodetext, -1, NULL, 0, NULL, NULL);
	if (nAnsiLen > 0)
	{
		pRet = (char*)E_MAlloc_Nzero(nAnsiLen); //nAnsiLenֹ
		if (pRet)
			WideCharToMultiByte(936, 0, unicodetext, -1, pRet, nAnsiLen, NULL, NULL);
	}
	delete []unicodetext;
	return pRet;
}

//    øʽ ı͡ UTF16ı ֽڼ תUTF16ıݣ - ϵͳֿ֧->ı
//    ӢƣUTF16ToStr
//    ָUTF16ıתͨı󷵻ءΪ
//    <1>ΪתUTF16ıݡΪֽڼbinṩתͨıUTF16ıݡ
//
//    ϵͳ Windows
LIBAPI(char*, krnln_fnUTF16ToStr)
{
	char* pSrc;
	int nl, al;
	WCHAR *unicodetext;
	
	if(ArgInf.m_pBin == NULL || ArgInf.m_pInt[1] <= 0)
		return NULL;
	
	pSrc = (char*)ArgInf.m_pBin;
	pSrc += 2*sizeof(INT);
	
	//ȴUTF-16תUTF-8
	nl = WideCharToMultiByte(CP_UTF8, 0, (LPWSTR)pSrc, ArgInf.m_pInt[1], NULL, 0, NULL, NULL);
	if (nl <= 0) return NULL;

	char* pszUtf8 = new char[nl + 1];
	nl = WideCharToMultiByte(CP_UTF8, 0, (LPWSTR)pSrc, ArgInf.m_pInt[1], pszUtf8, nl, NULL, NULL);
	pszUtf8[nl] = '\0';

	pSrc = pszUtf8;

	//UTF-8תUNICODE
	nl = MultiByteToWideChar(CP_UTF8, 0, pSrc, -1, NULL, 0);
	if (nl <= 0) {
		delete []pszUtf8;
		return NULL;
	}
	
	unicodetext = new WCHAR[nl];
	nl = MultiByteToWideChar(CP_UTF8, 0, pSrc, -1, unicodetext, nl);
	if (0 >= nl)
	{
		delete []pszUtf8;
		delete []unicodetext;
		return NULL;
	}
	
	//UNICDOEתANSI
	al = WideCharToMultiByte(936, 0, unicodetext, -1, NULL, 0, NULL, NULL);
	pSrc = NULL;
	if (al > 0)
	{
		pSrc = (char*)E_MAlloc_Nzero(al);
		if (pSrc)
			WideCharToMultiByte(936, 0, unicodetext, -1, pSrc, al, NULL, NULL);
	}
	delete []pszUtf8;
	delete []unicodetext;
	return pSrc;
}


================================================
FILE: krnln/krnln_Unlock.cpp
================================================
#include "stdafx.h"

//ļд - ļ
/*
    øʽ ߼͡ ļ  ļţ λã ijȣ - ϵͳֿ֧->ļд
    ӢƣUnlock
    ɡסļļеɹ棬ʧܷؼ١ע⣺ʱṩIJֵáסļʱṩIJֵȫһ¡Ϊ
    <1>ΪļšΪͣintļɡļء
    <2>ΪλáΪͣintλֵ 0 ʼ
    <3>ΪijȡΪͣint
*/
LIBAPI(BOOL, krnln_Unlock)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return FALSE;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return FALSE;
	if(pFile->nType !=1)//ڴļ
		return TRUE;
	HANDLE hFile = (HANDLE)pFile->FileHandle;
	PMDATA_INF pArgInf = &ArgInf;

	return UnlockFile(hFile,
		pArgInf[1].m_int,
		0,
		pArgInf[2].m_int,
		0);
}


================================================
FILE: krnln/krnln_Variant.cpp
================================================
#include "stdafx.h"
#pragma comment(lib,"ole32.lib")
#pragma comment(lib,"oleaut32.lib")

#define		DTC_COM_OBJECT  		48
#define     DTC_VARIANT             49
#define		DTP_COM_OBJECT      MAKELONG (DTC_COM_OBJECT, 1)
#define     DTP_VARIANT         MAKELONG (DTC_VARIANT, 1)

BOOL E_GetVariantElement(PMDATA_INF pArgInf,VARIANTARG * pvargDest)
{
	memcpy(pvargDest,pArgInf[0].m_pCompoundData,sizeof(VARIANTARG));
	if(V_ISARRAY(pvargDest))
	{
		SAFEARRAY* psa = NULL;
		if(V_ISBYREF(pvargDest))
			psa = *pvargDest->pparray;
		else
			psa = pvargDest->parray;

		LONG lLb,lUb;
		UINT nDim = SafeArrayGetDim(psa);
		INT nCount=1;
		for(UINT i=1;i<=nDim;i++)
		{
			SafeArrayGetLBound(psa,i,&lLb);
			SafeArrayGetUBound(psa,i,&lUb);
			nCount*=(lUb - lLb +1);
			
		}
		if(pArgInf[1].m_int > nCount)
			return FALSE;

	//long lLbound = psa->rgsabound[0].lLbound;
		
		long nIdx;//ܰ忪ʼֵ
		if(pArgInf[1].m_dtDataType == _SDT_NULL)
		{
			nIdx = 0;

		}else{
			nIdx = pArgInf[1].m_int-1;
			if(nIdx < 0)
				nIdx = 0;		
		}

		if((VT_VARIANT & pvargDest->vt)==VT_VARIANT){
		/*char ErrorString [255];
  		wsprintf(ErrorString, "pvargDest->vt%d.  %d", pvargDest->vt,SafeArrayGetDim(psa));
			HRESULT hr = SafeArrayGetElement(psa,&nIdx,pvargDest);

  		MessageBox(0, ErrorString, "pvargDest->vt", MB_ICONERROR);*/

			VARIANTARG *pBuf = NULL; 
			HRESULT hr = SafeArrayAccessData(psa,(void **)&pBuf);
			if(FAILED(hr))
				return FALSE;
			pBuf+=nIdx;
			*pvargDest = *pBuf;
			
			SafeArrayUnaccessData (psa);
		
//			if(FAILED(hr))
//				return FALSE;
			
			if((VT_VARIANT|VT_BYREF) == pvargDest->vt){
		/*				char ErrorString [255];
  		wsprintf(ErrorString, "pvargDest->vt%d.", pvargDest->vt);
  		MessageBox(0, ErrorString, "pvargDest->vt", MB_ICONERROR);	*/

				VARIANT* pvt=pvargDest->pvarVal;
				memcpy(pvargDest,pvt,sizeof(VARIANTARG));

			}




		}else{
			/*HRESULT hr = SafeArrayGetElement(psa,&nIdx,&pvargDest->intVal);

			if(FAILED(hr))
				return FALSE;*/
			LPBYTE pBuf = NULL; 
			HRESULT hr = SafeArrayAccessData(psa,(void **)&pBuf);
			if(FAILED(hr))
				return FALSE;
			DWORD dwSize = SafeArrayGetElemsize(psa);
			pBuf+=(nIdx*dwSize);
			memcpy(&pvargDest->intVal,pBuf,dwSize);
			//pvargDest->intVal = *pBuf;

			SafeArrayUnaccessData (psa);
			pvargDest->vt = (~VT_ARRAY & pvargDest->vt);
		}
	}
	return TRUE;

}
LPOLESTR E_ASCII2Unicode(LPSTR pAsciiText)
{
	if(pAsciiText==NULL)// || IsBadReadPtr(pBStrText,8)
		return NULL;

	DWORD dwMinSize;
    dwMinSize = MultiByteToWideChar (CP_ACP, 0, pAsciiText, -1, NULL, 0);
	
    if(dwMinSize==0)
		return NULL;
    LPOLESTR lpwszStr = (LPOLESTR)new USHORT [dwMinSize];
    // Convert headers from ASCII to Unicode.
    MultiByteToWideChar (CP_ACP, 0, pAsciiText, -1, lpwszStr, dwMinSize);  
	return lpwszStr;
}

LPSTR E_Unicode2ASCII(LPOLESTR pBStrText)
{
	if(pBStrText==NULL)// || IsBadReadPtr(pBStrText,8)
		return NULL;
	//Ҫתַ 
	DWORD dwLen=WideCharToMultiByte (CP_ACP, 0, pBStrText, -1, NULL,0, NULL, NULL) ; 
	//תַ
    if(dwLen==0)
		return NULL;
	LPSTR pText =(char*)E_MAlloc (dwLen);
	WideCharToMultiByte (CP_ACP, 0, pBStrText, -1, pText,dwLen, NULL, NULL);
	return pText;
}

BOOL EDataLetToVariant(VARIANTARG * pvargDest,PMDATA_INF pArgInf)
{
	VARIANTARG pArg;
	memset(&pArg,0,sizeof(VARIANTARG));
	switch(pArgInf->m_dtDataType)
	{
	case SDT_BYTE:
		pArg.vt = VT_UI1;
		pArg.intVal = pArgInf->m_int;
		break;
	case SDT_SHORT:
		pArg.vt = VT_I2;
		pArg.intVal = pArgInf->m_int;
		break;
	case SDT_INT:
		pArg.vt = VT_I4;
		pArg.intVal = pArgInf->m_int;
		break;
	case SDT_SUB_PTR:
		pArg.vt = VT_UI4;
		pArg.intVal = pArgInf->m_int;
		break;
	case SDT_INT64:
		pArg.vt = VT_I8;
		pArg.date = pArgInf->m_date;
		break;
	case SDT_FLOAT:
		pArg.vt = VT_R4;
		pArg.fltVal= pArgInf->m_float;
		break;
	case SDT_DOUBLE:
		pArg.vt = VT_R8;
		pArg.date = pArgInf->m_date;
		break;
	case SDT_BOOL:
		pArg.vt = VT_BOOL;
		pArg.boolVal = pArgInf->m_bool?-1:0;
		break;
	case SDT_DATE_TIME:
		pArg.vt = VT_DATE;
		pArg.date = pArgInf->m_date;
		break;
	case SDT_TEXT:
		{
			pArg.vt = VT_BSTR;
			LPOLESTR lpsz = E_ASCII2Unicode(pArgInf->m_pText);
			pArg.bstrVal = ::SysAllocString(lpsz);
			delete [] lpsz;
		}
		break;
	
	case DTP_VARIANT:
		if(FAILED(VariantCopy(&pArg,(VARIANTARG *)pArgInf->m_pCompoundData)))
			return FALSE;
		break;
	case DTP_COM_OBJECT:
		{
			pArg.vt = VT_UNKNOWN;//VT_DISPATCH
			PEYDISPATCH pDest = (PEYDISPATCH)pArgInf->m_pCompoundData;
			pArg.pdispVal = pDest->pDisp;
			if(pArg.pdispVal)
				pArg.pdispVal->AddRef();
		}
		break;
	default:
		return FALSE;
		break;
	}

	VariantClear(pvargDest);
	memcpy(pvargDest,&pArg,sizeof(VARIANTARG));

	return TRUE;

}

BOOL EAryDataToVariant(VARIANTARG * pvargDest,PMDATA_INF pArgInf)
{
	INT nDataType = pArgInf->m_dtDataType;
	INT nVtype,nDataSize;

	DWORD dwSize=0;
	void* pData = GetAryElementInf(pArgInf->m_pAryData,dwSize);
	if(pData==NULL || dwSize==0)
		return FALSE;

	if(nDataType == SDT_BIN)
	{
		nVtype =  VT_UI1;
		nDataSize = sizeof (BYTE);

	}else{

		nDataType = ~DT_IS_ARY & nDataType;
		switch(nDataType)
		{
		case SDT_BYTE:
			nVtype = VT_UI1;
			nDataSize = sizeof (BYTE);
			break;
		case SDT_SHORT:
			nVtype = VT_I2;
			nDataSize = sizeof (SHORT);
			break;
		case SDT_INT:
			nVtype = VT_I4;
			nDataSize = sizeof (INT);
			break;
		case SDT_SUB_PTR:
			nVtype = VT_UI4;
			nDataSize = sizeof (DWORD);
			break;
		case SDT_INT64:
			nVtype = VT_I8;
			nDataSize = sizeof (INT64);
			break;
		case SDT_FLOAT:
			nVtype = VT_R4;
			nDataSize = sizeof (FLOAT);
			break;
		case SDT_DOUBLE:
			nVtype = VT_R8;
			nDataSize = sizeof (DOUBLE);
			break;
		case SDT_BOOL:
			nVtype = VT_BOOL;
			nDataSize = sizeof (BOOL);
			break;
		case SDT_DATE_TIME:
			nVtype = VT_DATE;
			nDataSize = sizeof (DATE);
			break;
		case SDT_TEXT:
			nVtype = VT_BSTR;
			nDataSize = sizeof (DWORD);
			break;
		default:
			return FALSE;
			break;
		}
	}

	SAFEARRAY* pArray=NULL;
	HRESULT hr=SafeArrayAllocDescriptor(1,&pArray);//SAFEARRAYṹĶ
	if(FAILED(hr))
		return FALSE;
	pArray->cbElements=nDataSize;
	pArray->rgsabound[0].cElements=dwSize;
	pArray->rgsabound[0].lLbound=0;
	SafeArrayAllocData(pArray);
	void * pDest =NULL;
	hr = SafeArrayAccessData(pArray,(void**)&pDest);
	if(FAILED(hr))
	{
		SafeArrayDestroy(pArray);
		return FALSE;
	}

	if(nVtype == VT_BSTR)
	{
		LPSTR* pArySrc = (LPSTR*)pData;
		LPOLESTR* pAryDest = (LPOLESTR*)pDest;
			
					
		for(INT i=0;i<(INT)dwSize;i++)
		{
			LPOLESTR lpsz = E_ASCII2Unicode(pArySrc[i]);
			pAryDest[i] = ::SysAllocString(lpsz);
			delete [] lpsz;
		}

	}else if(nVtype == VT_BOOL){
		LPINT pArySrc = (LPINT)pData;
		LPINT pAryDest = (LPINT)pDest;
		for(INT i=0;i<(INT)dwSize;i++)
		{
			if(pArySrc[i])
				pAryDest[i] = -1;
			else
				pAryDest[i] = 0;
		}

	}else{
		memcpy(pDest,pData,dwSize*nDataSize);
	}
	SafeArrayUnaccessData(pArray);
	VariantClear(pvargDest);
	pvargDest->vt = nVtype | VT_ARRAY;
	pvargDest->parray = pArray;
	return TRUE;

}
extern "C" 
{
	/*
	Ʊ
	
	*/
	void _cdecl krnln_VariantCopy (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		VARIANTARG * pvargDest = (VARIANTARG *)pArgInf[0].m_pCompoundData;
		if(pvargDest==NULL)return;
		VariantClear(pvargDest);
		VARIANTARG * pvargSrc = (VARIANTARG *)pArgInf[1].m_pCompoundData;
		if(pvargSrc)
			VariantCopy(pvargDest,pvargSrc);
	}

	/*
    øʽ ޷ֵ   - ϵͳֿ֧->
    ӢƣClear
    ͷŲաñ˳ʱԶͷš磺ӳֲУӳ˳ʱöᱻԶͷšΪԱ
	
	*/
	void _cdecl krnln_VariantClear (INT nArgCount,MDATA_INF ArgInf,...)
	{
		VARIANTARG * pvargDest = (VARIANTARG *)ArgInf.m_pCompoundData;
		VariantClear(pvargDest);
		VariantInit(pvargDest);

	}

	/*
    øʽ ͡ ȡ  - ϵͳֿ֧->
    ӢƣGetType
    ȡصǰͶ͡ΪԱ
    ƣ    ӢƣVariantType
    Ϊöٳͣ 15 öٳֵ
    ϵͳ Windows
    ṩܹ͵öֵ
    öٳֵ<1>Ϊδ֪ӢΪUnknownֵΪ-1
    öٳֵ<2>ΪաӢΪEmptyֵΪ0
    öٳֵ<3>Ϊֵ͡ӢΪNumberֵΪ1
    öٳֵ<4>Ϊı͡ӢΪTextֵΪ2
    öٳֵ<5>Ϊ߼͡ӢΪBoolֵΪ3
    öٳֵ<6>Ϊ͡ӢΪDateֵΪ4
    öٳֵ<7>Ϊ͡ӢΪObjectֵΪ5
    öٳֵ<8>Ϊֵ͡ӢΪErrorֵΪ6
    öٳֵ<9>Ϊֵ顱ӢΪNumberArrayֵΪ7
    öٳֵ<10>Ϊı顱ӢΪTextArrayֵΪ8
    öٳֵ<11>Ϊ߼顱ӢΪBoolArrayֵΪ9
    öٳֵ<12>Ϊ顱ӢΪDateArrayֵΪ10
    öٳֵ<13>Ϊ顱ӢΪObjectArrayֵΪ11
    öٳֵ<14>Ϊֵ顱ӢΪErrorArrayֵΪ12
    öٳֵ<15>Ϊ顱ӢΪVariantArrayֵΪ13	
	*/
	int _cdecl krnln_VariantGetType (INT nArgCount,MDATA_INF ArgInf,...)
	{
		VARIANTARG * pvargDest = (VARIANTARG *)ArgInf.m_pCompoundData;
		VARTYPE vt = pvargDest->vt;
		BOOL bIsArray = FALSE;
		if(vt & VT_ARRAY)
		{
			vt &=(~VT_ARRAY);//ȥ־
			bIsArray = TRUE;
		}
		int nType = -1;
		switch(vt)
		{
		case VT_UI1:
		case VT_UI2:
		case VT_UI4:
		case VT_UI8:
		case VT_I1:
		case VT_I2:
		case VT_I4:
		case VT_I8:
		case VT_R4:
		case VT_R8:
		case VT_INT:
		case VT_UINT:
		case VT_CY:
		case VT_DECIMAL:
			nType = 1;
			break;
		case VT_BSTR:
			nType = 2;
			break;
		case VT_BOOL:
			nType = 3;
			break;
		case VT_DATE:
			nType = 4;
			break;
		case VT_DISPATCH://Ƿдַ־?
			nType = 5;
			break;
		case VT_ERROR:
			nType = 6;
			break;
		case VT_EMPTY:
		case VT_NULL:
			nType = 0;
			break;			
		}
		if(bIsArray)
		{
			if(nType==-1 && vt==VT_VARIANT)
				nType = 13;
			else if(1 <= nType && nType <=6)
				nType +=6;
		}

		return nType;
	}

	/*
    øʽ ͡ ȡԱ  - ϵͳֿ֧->
    ӢƣGetElementCount
    дŵݣִбԱĿݣִб -1 ΪԱ

	
	*/
	int _cdecl krnln_VariantGetElementCount (INT nArgCount,MDATA_INF ArgInf,...)
	{
		VARIANTARG * pvargDest = (VARIANTARG *)ArgInf.m_pCompoundData;
		if(V_ISARRAY(pvargDest))
		{
			SAFEARRAY* psa = NULL;
			if(V_ISBYREF(pvargDest))
				psa = *pvargDest->pparray;
			else
				psa = pvargDest->parray;
			LONG lLb,lUb;
			UINT nDim = SafeArrayGetDim(psa);
			INT nCount=1;
			for(UINT i=1;i<=nDim;i++)
			{
				SafeArrayGetLBound(psa,i,&lLb);
				SafeArrayGetUBound(psa,i,&lUb);
				nCount*=(lUb - lLb +1);

			}
			return nCount;
		}
		return -1;
	}

	/*
    øʽ ı͡ ȡı  Աݣ - ϵͳֿ֧->
    ӢƣGetText
    رл򱾶ԱеıݣǰݵͲΪıͣԶתתʧܽؿıΪԱ
    <1>ΪԱΪͣintԱʡԡǰΪݣڵijԱвڴ˲ֵֵָ 1 ʼ⣬ʡԱ

	
	*/
	char* _cdecl krnln_VariantGetText (INT nArgCount,MDATA_INF ArgInf,...)
	{
		VARIANTARG vargSrc;
		if(E_GetVariantElement(&ArgInf,&vargSrc)==FALSE)
			return NULL;

		LPSTR pText = NULL;
		if(vargSrc.vt == VT_BOOL)
		{
			if(vargSrc.boolVal != 0)
				pText = CloneTextData((LPSTR)"",2);
			else
				pText = CloneTextData((LPSTR)"",2);
			return pText;
		}
		BOOL bIsFromChg = FALSE;
		if(vargSrc.vt != VT_BSTR)
		{
			VARIANTARG vargDest;
			memcpy(&vargDest,&vargSrc,sizeof(VARIANTARG));
			memset(&vargSrc,0,sizeof(VARIANTARG));
			HRESULT hr = VariantChangeType(&vargSrc,&vargDest,0,VT_BSTR);
			if(FAILED(hr))
				return NULL;
			bIsFromChg = TRUE;
		}
		pText = E_Unicode2ASCII(vargSrc.bstrVal);
		if(bIsFromChg)
			VariantClear(&vargSrc);
		return pText;
	}

	/*
    øʽ ˫С͡ ȡֵ  Աݣ - ϵͳֿ֧->
    ӢƣGetNum
    رл򱾶ԱеֵݣǰݵͲΪֵֵͣԶתתʧܽ 0 ΪԱ
    <1>ΪԱΪͣintԱʡԡǰΪݣڵijԱвڴ˲ֵֵָ 1 ʼ⣬ʡԱ	
	*/
	void _cdecl krnln_VariantGetNum (INT nArgCount,MDATA_INF ArgInf,...)
	{
		VARIANTARG vargSrc;
		MDATA_INF RetVal;
		if(E_GetVariantElement(&ArgInf,&vargSrc))
		{
			if(vargSrc.vt != VT_R8)
			{
				VARIANTARG vargDest;
				memcpy(&vargDest,&vargSrc,sizeof(VARIANTARG));
				memset(&vargSrc,0,sizeof(VARIANTARG));
				VariantChangeType(&vargSrc,&vargDest,0,VT_R8);
			}
			RetVal.m_double = vargSrc.dblVal;
		}
		else
			RetVal.m_double = 0;
		__asm
		{
			mov eax,RetVal.m_unit.m_dwFormID;
			mov edx,RetVal.m_unit.m_dwUnitID;
		}
	}

	/*
    øʽ ߼͡ ȡ߼ֵ  Աݣ - ϵͳֿ֧->
    ӢƣGetBool
    رл򱾶Աе߼ֵݣǰݵͲΪ߼ͣԶתתʧܽؼ١ΪԱ
    <1>ΪԱΪͣintԱʡԡǰΪݣڵijԱвڴ˲ֵֵָ 1 ʼ⣬ʡԱ
	*/
	BOOL _cdecl krnln_VariantGetBool (INT nArgCount,MDATA_INF ArgInf,...)
	{
		VARIANTARG vargSrc;
		BOOL bRet = FALSE;

		if(E_GetVariantElement(&ArgInf,&vargSrc))
		{
			if(vargSrc.vt != VT_BOOL)
			{
				VARIANTARG vargDest;
				memcpy(&vargDest,&vargSrc,sizeof(VARIANTARG));
				memset(&vargSrc,0,sizeof(VARIANTARG));
				HRESULT hr = VariantChangeType(&vargSrc,&vargDest,0,VT_BSTR);
				if(FAILED(hr))
					return bRet;
			}
			bRet = (vargSrc.boolVal !=0 ?1:0);
		}
		return bRet;

	}
	/*
    øʽ ʱ͡ ȡ  Աݣ - ϵͳֿ֧->
    ӢƣGetDateTime
    رл򱾶ԱеʱֵݣǰݵͲΪʱͣԶתתʧܽ10011աΪԱ
    <1>ΪԱΪͣintԱʡԡǰΪݣڵijԱвڴ˲ֵֵָ 1 ʼ⣬ʡԱ
	*/
	void _cdecl krnln_VariantGetDateTime (INT nArgCount,MDATA_INF ArgInf,...)
	{
		VARIANTARG vargSrc;
		MDATA_INF RetVal;
		if(E_GetVariantElement(&ArgInf,&vargSrc))
		{
			if(vargSrc.vt != VT_DATE)
			{
				VARIANTARG vargDest;
				memcpy(&vargDest,&vargSrc,sizeof(VARIANTARG));
				memset(&vargSrc,0,sizeof(VARIANTARG));
				HRESULT hr = VariantChangeType(&vargSrc,&vargDest,0,VT_DATE);
				if(FAILED(hr))
					vargSrc.date = -657434;//10011;
			}
			RetVal.m_date = vargSrc.date;
		}
		else
			RetVal.m_date = -657434;//10011;
		__asm
		{
			mov eax,RetVal.m_unit.m_dwFormID;
			mov edx,RetVal.m_unit.m_dwUnitID;
		}
	}
	/*
    øʽ  ȡ  Աݣ - ϵͳֿ֧->
    ӢƣGetObject
    رл򱾶ԱеCOMݣǰݵͲΪCOMͣؿCOM󡣱ΪԱ
    <1>ΪԱΪͣintԱʡԡǰΪݣڵijԱвڴ˲ֵֵָ 1 ʼ⣬ʡԱ
	*/
	void* _cdecl krnln_VariantGetObject (INT nArgCount,MDATA_INF ArgInf,...)
	{
		VARIANTARG vargSrc;
		PEYDISPATCH pdispRet = (PEYDISPATCH)E_MAlloc(sizeof(EYDISPATCH));

		if(E_GetVariantElement(&ArgInf,&vargSrc))
		{
			switch (vargSrc.vt)
			{
			case VT_DISPATCH:
				pdispRet->pDisp = vargSrc.pdispVal;
				if(pdispRet->pDisp)
					pdispRet->pDisp->AddRef();
				break;
			case VT_UNKNOWN:
				pdispRet->pDisp = (LPDISPATCH)vargSrc.punkVal;
				if(pdispRet->pDisp)
					pdispRet->pDisp->AddRef();
				break;
			case VT_DISPATCH|VT_BYREF:
				pdispRet->pDisp = *vargSrc.ppdispVal;
				if(pdispRet->pDisp)
					pdispRet->pDisp->AddRef();
				break;
			case VT_UNKNOWN|VT_BYREF:
				pdispRet->pDisp = *(LPDISPATCH*)vargSrc.ppunkVal;
				if(pdispRet->pDisp)
					pdispRet->pDisp->AddRef();
				break;
			}
		}
		return pdispRet;

	}

	/*
    øʽ ͡ ȡ  Աݣ - ϵͳֿ֧->
    ӢƣGetVariant
    رл򱾶ԱеıݣǰݵͲΪͣԶתΪԱ
    <1>ΪԱΪͣintԱʡԡǰΪݣڵijԱвڴ˲ֵֵָ 1 ʼ⣬ʡԱ
	*/
	void* _cdecl krnln_VariantGetVariant (INT nArgCount,MDATA_INF ArgInf,...)
	{
		VARIANTARG vargSrc;
		VARIANT* pVarRet = (VARIANT*)E_MAlloc(sizeof(VARIANT));

		if(E_GetVariantElement(&ArgInf,&vargSrc))
			VariantCopy(pVarRet,&vargSrc);
		return pVarRet;

	}
	/*
    øʽ ߼͡ 󣮸ֵ ͨ/ дݣݣ Աݣ - ϵͳֿ֧->
    Ӣƣset
    ñݣɹ棬ʧܷؼ١ΪԱ
    <1>ΪдݡΪͨͣallԱʡԣṩʱͬʱṩݡֵΪıֵ߼ֵʱֵCOMͻЩͼ͡ͱʽʡԣ򽫶ա
    <2>ΪԱΪͣintԱʡԡǰΪݣڵijԱвڴ˲ֵֵָ 1 ʼ⣬ʡԱ
	*/
	BOOL _cdecl krnln_Variantset (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		VARIANTARG * pvargDest = (VARIANTARG *)pArgInf[0].m_pCompoundData;
		if(pArgInf[1].m_dtDataType == _SDT_NULL)
		{
			VariantClear(pvargDest);
			VariantInit(pvargDest);
			return TRUE;
		}


		BOOL bRet;

		if((pArgInf[1].m_dtDataType & DT_IS_ARY) == DT_IS_ARY || pArgInf[1].m_dtDataType == SDT_BIN)
			bRet = EAryDataToVariant(pvargDest,&pArgInf[1]);
		else
		{
			if(V_ISARRAY(pvargDest))
			{
				SAFEARRAY* psa = pvargDest->parray;
				LONG lLb,lUb;
				UINT nDim = SafeArrayGetDim(psa);
				INT nCount=1;
				for(UINT i=1;i<=nDim;i++)
				{
					SafeArrayGetLBound(psa,i,&lLb);
					SafeArrayGetUBound(psa,i,&lUb);
					nCount*=(lUb - lLb +1);
					
				}
				if(pArgInf[2].m_int > nCount)
					return FALSE;

				VARIANTARG vargSrc;
				VariantInit(&vargSrc);
				
				if(EDataLetToVariant(&vargSrc,&pArgInf[1])==FALSE)
					return FALSE;
				


				//long lLbound = //psa->rgsabound[0].lLbound;
				long nIdx;//ܰ忪ʼֵ
				if(pArgInf[2].m_dtDataType == _SDT_NULL)
				{
					nIdx = 0;//lLbound;
					
				}else{
					nIdx = pArgInf[2].m_int-1;//+lLbound;
					if(nIdx < 0)
						nIdx = 0;//lLbound;
				}
				INT nVarType = ~VT_ARRAY & pvargDest->vt;
		
				HRESULT hr;


				if((VT_VARIANT & nVarType)==VT_VARIANT){
					//hr = SafeArrayPutElement(psa,&nIdx,&vargSrc);
					VARIANTARG *pBuf = NULL; 
					HRESULT hr = SafeArrayAccessData(psa,(void **)&pBuf);
					if(!FAILED(hr)){
						pBuf+=nIdx;
						VariantClear(pBuf);
						*pBuf=vargSrc;
					
						SafeArrayUnaccessData (psa);
					}
				}else{
					if(nVarType != vargSrc.vt)
					{
						VARIANTARG vargDest;
						memcpy(&vargDest,&vargSrc,sizeof(VARIANTARG));
						memset(&vargSrc,0,sizeof(VARIANTARG));
						hr = VariantChangeType(&vargSrc,&vargDest,0,nVarType);
						if(FAILED(hr))
						{
							VariantClear(&vargDest);
							return FALSE;
						}
					}
					//hr = SafeArrayPutElement(psa,&nIdx,&vargSrc.intVal);
					LPBYTE pBuf = NULL;
					HRESULT hr = SafeArrayAccessData(psa,(void **)&pBuf);
					if(!FAILED(hr)){
						DWORD dwSize = SafeArrayGetElemsize(psa);
						pBuf+=(nIdx*dwSize);
						if(nVarType==VT_BSTR)
							::SysFreeString (*(BSTR*)pBuf);
						memcpy(pBuf,&vargSrc.intVal,dwSize);
					
						SafeArrayUnaccessData (psa);
					}
				}

				if(FAILED(hr))
				{
					VariantClear(&vargSrc);
					return FALSE;
				}
				
				return TRUE;
				
			}else
				bRet = EDataLetToVariant(pvargDest,&pArgInf[1]);
		}

		return bRet;
	}
	/*
    øʽ ߼͡ 󣮴  Աͣ ԱĿ - ϵͳֿ֧->
    ӢƣCreateArray
    ָͺָԱĿհ飬еԭݽգɹ棬ʧܷؼ١ΪԱ
    <1>ΪԱ͡ΪͣintָԱͣΪֵ֮һ
	1: ֽͣ 2: ͣ 3: ͣ 4: Сͣ 5: ˫Сͣ 6: ıͣ 7: ߼ͣ 8: ͣ 9: ͣ 10: ͡
    <2>ΪԱĿΪͣintָԱĿ
	*/
	BOOL _cdecl krnln_VariantCreateArray (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		VARIANTARG * pvargDest = (VARIANTARG *)pArgInf[0].m_pCompoundData;
		VariantClear(pvargDest);
		VariantInit(pvargDest);

		INT nDataType = pArgInf[1].m_int;
		INT nDataSize,nVtype;
		switch(nDataType)
		{
		case 1://ֽ
			nVtype = VT_UI1;
			nDataSize = sizeof (BYTE);
			break;
		case 2://
			nVtype = VT_I2;
			nDataSize = sizeof (SHORT);
			break;
		case 3://
			nVtype = VT_I4;
			nDataSize = sizeof (INT);
			break;
		case 4://С
			nVtype = VT_R4;
			nDataSize = sizeof (FLOAT);
			break;
		case 5://˫С
			nVtype = VT_R8;
			nDataSize = sizeof (DOUBLE);
			break;
		case 7://߼
			nVtype = VT_BOOL;
			nDataSize = sizeof (BOOL);
			break;
		case 8://
			nVtype = VT_DATE;
			nDataSize = sizeof (DATE);
			break;
		case 6://ı
			nVtype = VT_BSTR;
			nDataSize = sizeof (DWORD);
			break;
		case 9://
			nVtype = VT_DISPATCH;
			nDataSize = sizeof (DWORD);
			break;
		case 10://
			nVtype = VT_VARIANT;
			nDataSize = sizeof (VARIANT);
			break;
		default:
			return FALSE;
			break;
		}

		

		SAFEARRAY* pArray=NULL;
		HRESULT hr=SafeArrayAllocDescriptor(1,&pArray);//SAFEARRAYṹĶ
		if(FAILED(hr))
			return FALSE;
		pArray->cbElements=nDataSize;
		pArray->rgsabound[0].cElements=pArgInf[2].m_int;
		pArray->rgsabound[0].lLbound=0;
		hr = SafeArrayAllocData(pArray);
		if(FAILED(hr))
		{
			SafeArrayDestroyDescriptor(pArray);
			return FALSE;
		}
		
		pvargDest->vt = nVtype | VT_ARRAY;
		pvargDest->parray = pArray;
		return TRUE;

	}
	/*
    øʽ ߼͡   õͣ - ϵͳֿ֧->
    ӢƣSetType
    ǰͶеԭݣıͣɹ棬ʧܷؼ١ΪԱ
    <1>Ϊõ͡ΪͣVariantTypeֵṩõı͡
    öٳֵ<2>ΪաӢΪEmptyֵΪ0
    öٳֵ<3>Ϊֵ͡ӢΪNumberֵΪ1
    öٳֵ<4>Ϊı͡ӢΪTextֵΪ2
    öٳֵ<5>Ϊ߼͡ӢΪBoolֵΪ3
    öٳֵ<6>Ϊ͡ӢΪDateֵΪ4
    öٳֵ<7>Ϊ͡ӢΪObjectֵΪ5
    öٳֵ<8>Ϊֵ͡ӢΪErrorֵΪ6
    öٳֵ<9>Ϊֵ顱ӢΪNumberArrayֵΪ7
    öٳֵ<10>Ϊı顱ӢΪTextArrayֵΪ8
    öٳֵ<11>Ϊ߼顱ӢΪBoolArrayֵΪ9
    öٳֵ<12>Ϊ顱ӢΪDateArrayֵΪ10
    öٳֵ<13>Ϊ顱ӢΪObjectArrayֵΪ11
    öٳֵ<14>Ϊֵ顱ӢΪErrorArrayֵΪ12
    öٳֵ<15>Ϊ顱ӢΪVariantArrayֵΪ13	
	*/
	BOOL _cdecl krnln_VariantSetType (INT nArgCount,MDATA_INF ArgInf,...)
	{
		PMDATA_INF pArgInf = &ArgInf;
		VARIANTARG * pvargDest = (VARIANTARG *)pArgInf[0].m_pCompoundData;
	

		INT nVtype;
		switch(pArgInf[1].m_int)
		{
		case 0:
			nVtype = VT_EMPTY;
			break;
		case 1:
			nVtype = VT_R8;
			break;
		case 2:
			nVtype = VT_BSTR;
			break;
		case 3:
			nVtype = VT_BOOL;
			break;
		case 4:
			nVtype = VT_DATE;
			break;
		case 5:
			nVtype = VT_DISPATCH;
			break;
		case 6:
			nVtype = VT_ERROR;
			break;
		case 7:
			nVtype = VT_R8|VT_ARRAY;
			break;
		case 8:
			nVtype = VT_BSTR|VT_ARRAY;
			break;
		case 9:
			nVtype = VT_BOOL|VT_ARRAY;
			break;
		case 10:
			nVtype = VT_DATE|VT_ARRAY;
			break;
		case 11:
			nVtype = VT_DISPATCH|VT_ARRAY;
			break;
		case 12:
			nVtype = VT_ERROR|VT_ARRAY;
			break;
		case 13:
			nVtype = VT_VARIANT|VT_ARRAY;
			break;
		default:
			VariantClear(pvargDest);
			VariantInit(pvargDest);
			return FALSE;
			break;
		}
		if(nVtype == VT_EMPTY)
		{
			VariantClear(pvargDest);
			VariantInit(pvargDest);
		}
		else
		{
			VARIANTARG vargDest;
			memset(&vargDest,0,sizeof(VARIANTARG));
			HRESULT hr = VariantChangeType(&vargDest,pvargDest,0,nVtype);
			VariantClear(pvargDest);
			if(FAILED(hr))
			{
				VariantInit(pvargDest);
				return FALSE;
			}
			memcpy(pvargDest,&vargDest,sizeof(VARIANTARG));


		}
		return TRUE;
	
	}
	/*
    øʽ ֽڼ ȡֽڼ  Աݣ - ϵͳֿ֧->
    ӢƣGetBin
    رл򱾶ԱеֽڼݣǰݵͲΪֽڼͣԶתתʧܽؿֽڼΪԱ
    <1>ΪԱΪͣintԱʡԡǰΪݣڵijԱвڴ˲ֵֵָ 1 ʼ⣬ʡԱ
	*/
	void* _cdecl krnln_VariantGetBin (INT nArgCount,MDATA_INF ArgInf,...)
	{
		
		LPBYTE pData = NULL;
		VARIANTARG vargSrc;
		BOOL bIsFromChg = FALSE;
		PMDATA_INF pArgInf = &ArgInf;
		SAFEARRAY* psa;
		VARIANTARG * pvargDest = (VARIANTARG *)pArgInf[0].m_pCompoundData;
		if(pvargDest->vt != (VT_ARRAY | VT_UI1) && pvargDest->vt != (VT_ARRAY | VT_I1))
		{
			
			if(E_GetVariantElement(&ArgInf,&vargSrc)==FALSE)
				return pData;
			VARIANTARG vargDest;
			memcpy(&vargDest,&vargSrc,sizeof(VARIANTARG));
			memset(&vargSrc,0,sizeof(VARIANTARG));
			HRESULT hr = VariantChangeType(&vargSrc,&vargDest,0,VT_ARRAY | VT_UI1);
			if(FAILED(hr))
				return pData;
			psa = vargSrc.parray;
			bIsFromChg = TRUE;

		}else
			psa = pvargDest->parray;

		LONG lLb,lUb;
		UINT nDim = SafeArrayGetDim(psa);
		INT nCount=1;
		for(UINT i=1;i<=nDim;i++)
		{
			SafeArrayGetLBound(psa,i,&lLb);
			SafeArrayGetUBound(psa,i,&lUb);
			nCount*=(lUb - lLb +1);
			
		}
		BYTE *pBuf = NULL; 
		SafeArrayAccessData(psa,(void **)&pBuf);
		pData = CloneBinData (pBuf, nCount);
		SafeArrayUnaccessData (psa);
		if(bIsFromChg)
			VariantClear(&vargSrc);
		return pData;

	}
}

================================================
FILE: krnln/krnln_WeekDay.cpp
================================================
#include "stdafx.h"

//ʱ - ȡڼ
/*
    øʽ ͡ ȡڼ ʱ ʱ䣩 - ϵͳֿ֧->ʱ
    ӢƣWeekDay
    һֵΪ 1  7 ֮ʾһеijһաΪ 1һΪ 2ơΪ
    <1>Ϊʱ䡱Ϊʱͣdate
*/
LIBAPI(int, krnln_WeekDay)
{
	return GetWeekDay(ArgInf.m_date);
}


================================================
FILE: krnln/krnln_WriteBin.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
#include "Myfunctions.h"
//ļд - дֽڼ
/*
    øʽ ߼͡ дֽڼ  дݵļţֽڼ дֽڼݣ...  - ϵͳֿ֧->ļд
    ӢƣWriteBin
    дһλֽڼݵļеǰдλôɹ棬ʧܷؼ١ΪһԱظӡ
    <1>ΪдݵļšΪͣintļɡļء
    <2>ΪдֽڼݡΪֽڼbin
*/
LIBAPI(BOOL, krnln_WriteBin)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return NULL;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return NULL;
	PMDATA_INF pArgInf = &ArgInf;

	BOOL bRet = FALSE;

	if(pFile->nType ==1)//ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		DWORD dwNumOfByteRead;
		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPBYTE pData = pArgInf[i].m_pBin + 2*sizeof(INT);
			INT nLen = pArgInf[i].m_pInt[1];

			if(WriteFile(hFile,pData,nLen,&dwNumOfByteRead,NULL)==FALSE)
			{
				bRet = FALSE;
				break;
			}
/*			if(FlushFileBuffers(hFile)==FALSE)
			{
				bRet = FALSE;
				break;
			}*/
		}
		

	}else if(pFile->nType ==2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*) pFile->FileHandle;
		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPBYTE pData = pArgInf[i].m_pBin + 2*sizeof(INT);
			INT nLen = pArgInf[i].m_pInt[1];
			pMemFile->Write(pData,nLen);
		}

	}else if (pFile->nType == 3) //ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		DWORD dwNumOfByteRead;
		LPBYTE pData = NULL;
		INT nMaxLen = 0;
		INT nLen, i, nPos;
		bRet = TRUE;
		for(i=1;i < nArgCount;i++)
		{
			nLen = pArgInf[i].m_pInt[1];
			if (nLen > 0)
				nMaxLen = max(nMaxLen, nLen);
		}
		if (nMaxLen > 0)
			pData = new unsigned char[nMaxLen];
		for(i=1;i < nArgCount;i++)
		{
			nLen = pArgInf[i].m_pInt[1];
			if (nLen > 0)
			{
				memcpy(pData, pArgInf[i].m_pBin + 2*sizeof(INT), nLen);

				nPos = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
				E_RC4_Calc(nPos, pData, nLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
				if(WriteFile(hFile,pData,nLen,&dwNumOfByteRead,NULL)==FALSE)
				{
					delete []pData;
					bRet = FALSE;
					break;
				}
			}
		}
		delete []pData;
	}
	return bRet;
}


================================================
FILE: krnln/krnln_WriteFile.cpp
================================================
#include "stdafx.h"

//̲ - дļ
/*
    øʽ ߼͡ дļ ı ļֽڼ дļݣ...  - ϵͳֿ֧->̲
    ӢƣWriteFile
    һֽڼ˳дָļУļԭݱǡɹ棬ʧܷؼ١ΪһԱظӡ
    <1>ΪļΪıͣtext
    <2>ΪдļݡΪֽڼbin
*/
LIBAPI(BOOL, krnln_WriteFile)
{
	PMDATA_INF pArgInf = &ArgInf;
	HANDLE hFile = CreateFile(ArgInf.m_pText,
		GENERIC_WRITE,
		0,
		NULL,
		CREATE_ALWAYS,
		FILE_ATTRIBUTE_ARCHIVE,
		0);
	
	BOOL bRet = FALSE;
	if(hFile != INVALID_HANDLE_VALUE)
	{

		DWORD dwNumOfByteRead;
		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPBYTE pData = pArgInf[i].m_pBin + 2*sizeof(INT);
			INT nLen = pArgInf[i].m_pInt[1];

			if(WriteFile(hFile,pData,nLen,&dwNumOfByteRead,NULL)==FALSE)
			{
				bRet = FALSE;
				break;
			}
/*			if(FlushFileBuffers(hFile)==FALSE)
			{
				bRet = FALSE;
				break;
			}*/
		}
		CloseHandle(hFile);
	}
	return bRet;
}


================================================
FILE: krnln/krnln_WriteLine.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
#include "Myfunctions.h"

//ļд - дı
/*
    øʽ ߼͡ дı  дıļţͨ дı...  - ϵͳֿ֧->ļд
    ӢƣWriteLine
    дһлıݵļеǰдλôÿеβԶϻسзɹ棬ʧܷؼ١ΪһԱظӡ
    <1>ΪдıļšΪͣintļɡļء
    <2>ΪдıΪͨͣallֵΪıݣԶת޷תΪֽڼӳָ롢ûԶͣдݡ
*/


LIBAPI(BOOL, krnln_WriteLine)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return NULL;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return NULL;
	PMDATA_INF pArgInf = &ArgInf;

	BOOL bRet = FALSE;

	if(pFile->nType ==1)//ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		DWORD dwNumOfByteRead;
		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPSTR pData;
			BOOL bNeedFree = FALSE;
			if(pArgInf[i].m_dtDataType == SDT_TEXT)
				pData = pArgInf[i].m_pText;
			else
			{
				pData = SDataToStr(&pArgInf[i]);
				if(pData == NULL)
				{
					WriteFile(hFile,"\r\n",2,&dwNumOfByteRead,NULL);
//					FlushFileBuffers(hFile);
					continue;
				}
				bNeedFree = TRUE;
			}

			INT nLen = mystrlen(pData);
			if(nLen>0)
			{
				if(WriteFile(hFile,pData,nLen,&dwNumOfByteRead,NULL))
				{
					WriteFile(hFile,"\r\n",2,&dwNumOfByteRead,NULL);
					//if(FlushFileBuffers(hFile)==FALSE)
						//bRet = FALSE;
				}
				else
					bRet = FALSE;
			}

			if(bNeedFree)
				free(pData);

			if(bRet == FALSE)
				break;
		}
	}else if(pFile->nType ==2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*) pFile->FileHandle;
		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPSTR pData;
			BOOL bNeedFree = FALSE;
			if(pArgInf[i].m_dtDataType == SDT_TEXT)
				pData = pArgInf[i].m_pText;
			else
			{
				pData = SDataToStr(&pArgInf[i]);
				if(pData == NULL)
					continue;
				bNeedFree = TRUE;
			}

			INT nLen = mystrlen(pData);
			if(nLen>0)
				pMemFile->Write(pData,nLen);
			pMemFile->Write("\r\n",2);

			if(bNeedFree)
				free(pData);
		}
	}else if(pFile->nType ==3) //ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		DWORD dwNumOfByteRead;
		unsigned char pszRN[2] = {2};
		int nPos = 0;
		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPSTR pData;
			BOOL bNeedFree = FALSE;
			if(pArgInf[i].m_dtDataType == SDT_TEXT)
				pData = pArgInf[i].m_pText;
			else
			{
				pData = SDataToStr(&pArgInf[i]);
				if(pData == NULL)
				{
					nPos = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
					pszRN[0] = '\r';
					pszRN[1] = '\n';
					E_RC4_Calc(nPos, pszRN, 2, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
					WriteFile(hFile, pszRN, 2, &dwNumOfByteRead, NULL);
					continue;
				}
				bNeedFree = TRUE;
			}
			
			INT nLen = mystrlen(pData);
			if(nLen>0)
			{
				nPos = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
				E_RC4_Calc(nPos, (unsigned char*)pData, nLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
				if(WriteFile(hFile, (unsigned char*)pData, nLen, &dwNumOfByteRead, NULL))
				{
					nPos = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
					pszRN[0] = '\r';
					pszRN[1] = '\n';
					E_RC4_Calc(nPos, pszRN, 2, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
					WriteFile(hFile, pszRN, 2, &dwNumOfByteRead, NULL);
				}
				else
					bRet = FALSE;
			}
			
			if(bNeedFree)
				free(pData);
			
			if(bRet == FALSE)
				break;
		}
	}
	return bRet;
}


================================================
FILE: krnln/krnln_WriteMem.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
// - дڴ
/*
   øʽ ޷ֵ дڴ ͨ/ дڴݣ ڴָ룬 ڴߴݣ - ϵͳֿ֧->
    ӢƣWriteMem
    дָڴעñǰһҪȷṩڴʵЧʹóϾԻصӳDLLӳݡΪ߼
    <1>ΪдڴݡΪͨͣallṩʱͬʱṩݡֵֻΪݻֽ顣
    <2>Ϊڴָ롱Ϊͣintṩдڴ׵ֵַָ
    <3>Ϊڴߴ硱ΪͣintԱʡԡṩڴЧߴ磬дݳ˳ߴֵԶгֵΪ -1 ʾڴߴ粻ơʡԣĬֵΪ -1
*/
LIBAPI(void, krnln_WriteMem)
{
	PMDATA_INF pArgInf = &ArgInf;
	LPBYTE pData;
	DWORD dwLen;
	if((pArgInf[0].m_dtDataType & DT_IS_ARY) == DT_IS_ARY)//
	{
		pArgInf[0].m_dtDataType &=~DT_IS_ARY; //ȥ־
		if(pArgInf[0].m_dtDataType == SDT_BYTE)//ֽ
		{
			pData = (LPBYTE)GetAryElementInf(pArgInf[0].m_pAryData,dwLen);
			if(dwLen==0)
				return;
		}else
			return;
	}
	else 
	{
		if(pArgInf[0].m_dtDataType==SDT_TEXT)
		{
			if(pArgInf[0].m_pText==NULL)
				return;
			
			dwLen = mystrlen(pArgInf[0].m_pText);
			if(dwLen==0)
				return;
			dwLen++;
			pData = (LPBYTE)pArgInf[0].m_pText;
			
		}else if(pArgInf[0].m_dtDataType==SDT_BIN)
		{
			if(pArgInf[0].m_pBin==NULL)
				return;

			LPINT p = (LPINT)pArgInf[0].m_pBin;
			dwLen = p[1];
			p+=2;
			pData = (LPBYTE)p;

			
		}else{
			
			dwLen = GetSysDataTypeDataSize(pArgInf[0].m_dtDataType);
			if(dwLen==0)//ֵ֧
				return;
			pData = (LPBYTE)&pArgInf[0].m_int;
		}

	}
	if(pArgInf[2].m_dtDataType != _SDT_NULL && pArgInf[2].m_int>0)
	{
		if(pArgInf[2].m_int<(INT)dwLen)
			dwLen = pArgInf[2].m_int;
	}
	memcpy(pArgInf[1].m_pCompoundData,pData,dwLen);
	


}


================================================
FILE: krnln/krnln_WriteText.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
#include "Myfunctions.h"

//ļд - дı
/*
    øʽ ߼͡ дı  дıļţͨ дı...  - ϵͳֿ֧->ļд
    ӢƣWriteText
    дһλıݵļеǰдλôɹ棬ʧܷؼ١ΪһԱظӡ
    <1>ΪдıļšΪͣintļɡļء
    <2>ΪдıΪͨͣallֵΪıݣԶת޷תΪֽڼӳָ롢ûԶͣдݡ
*/

LIBAPI(BOOL, krnln_WriteText)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return NULL;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return NULL;
	PMDATA_INF pArgInf = &ArgInf;

	BOOL bRet = FALSE;

	if(pFile->nType ==1)//ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		DWORD dwNumOfByteRead;
		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPSTR pData;
			BOOL bNeedFree = FALSE;
			if(pArgInf[i].m_dtDataType == SDT_TEXT)
				pData = pArgInf[i].m_pText;
			else
			{
				pData = SDataToStr(&pArgInf[i]);
				if(pData == NULL)
					continue;
				bNeedFree = TRUE;
			}

			INT nLen = mystrlen(pData);
			if(nLen>0)
			{
				if(WriteFile(hFile,pData,nLen,&dwNumOfByteRead,NULL))
				{
//					if(FlushFileBuffers(hFile)==FALSE)
//						bRet = FALSE;
				}
				else
					bRet = FALSE;
			}

			if(bNeedFree)
				free(pData);

			if(bRet == FALSE)
				break;
		}
	}else if(pFile->nType ==2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*) pFile->FileHandle;
		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPSTR pData;
			BOOL bNeedFree = FALSE;
			if(pArgInf[i].m_dtDataType == SDT_TEXT)
				pData = pArgInf[i].m_pText;
			else
			{
				pData = SDataToStr(&pArgInf[i]);
				if(pData == NULL)
					continue;
				bNeedFree = TRUE;
			}

			INT nLen = mystrlen(pData);
			if(nLen>0)
				pMemFile->Write(pData,nLen);

			if(bNeedFree)
				free(pData);
			
		}

	}else if(pFile->nType == 3)//ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		DWORD dwNumOfByteRead;
		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{
			LPSTR pData;
			BOOL bNeedFree = FALSE;
			if(pArgInf[i].m_dtDataType == SDT_TEXT)
				pData = pArgInf[i].m_pText;
			else
			{
				pData = SDataToStr(&pArgInf[i]);
				if(pData == NULL)
					continue;
				bNeedFree = TRUE;
			}
			
			INT nLen = mystrlen(pData);
			if(nLen>0)
			{
				INT nPos = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
				E_RC4_Calc(nPos, (unsigned char*)pData, nLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
				if(!WriteFile(hFile,pData,nLen,&dwNumOfByteRead,NULL))
					bRet = FALSE;
			}
			
			if(bNeedFree)
				free(pData);
			
			if(bRet == FALSE)
				break;
		}
	}
	return bRet;
}


================================================
FILE: krnln/krnln_ZeroAry.cpp
================================================
#include "stdafx.h"

/*
    øʽ ޷ֵ  ͨͱ ֵ - ϵͳֿ֧->
    ӢƣZeroAry
    ֵָڵгԱֵȫΪ㣬ӰάϢΪ
    <1>ΪֵΪͨͣallṩʱֻṩ顣
*/

LIBAPI(void, krnln_ZeroAry)
{
	// no data
	if(!ArgInf.m_ppAryData)
		return;

	// not supported data type
	if(ArgInf.m_dtDataType==SDT_TEXT || ArgInf.m_dtDataType==SDT_BIN)
		return;
	
	// get single element size
	// user defined struct is NOT supported, nLen will be zero
	DWORD dwElementSize = (DWORD)GetSysDataTypeDataSize(ArgInf.m_dtDataType);
	if(!dwElementSize)
		return;

	// get first element and array length
	DWORD dwArrayLen = 0;
	void* pFirstElement = GetAryElementInf(*ArgInf.m_ppAryData, dwArrayLen);
	if(!pFirstElement || !dwArrayLen)
		return;

	// zero all element
	memset(pFirstElement, 0, dwElementSize * dwArrayLen);	
}

================================================
FILE: krnln/krnln_abs.cpp
================================================
#include "stdafx.h"
#include <math.h>
// - ȡֵ
/*
    øʽ ˫С͡ ȡֵ ˫С ȡֵֵ - ϵͳֿ֧->
    Ӣƣabs
    ṩֵΪֱֽͣӷظֵΪ
    <1>ΪȡֵֵΪ˫Сͣdouble
*/
LIBAPI(void, krnln_abs)
{
	ArgInf.m_double = fabs(ArgInf.m_double);
	__asm
	{
		mov eax,ArgInf.m_unit.m_dwFormID;
		mov edx,ArgInf.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_asc.cpp
================================================
#include "stdafx.h"

//ı - ȡ
/*
    øʽ ͡ ȡ ı ȡַı ȡַλãݣ - ϵͳֿ֧->ı
    Ӣƣasc
    ıָλôַĴ롣ָλóıȣ0Ϊ
    <1>ΪȡַıΪıͣtext
    <2>ΪȡַλáΪͣintԱʡԡ1Ϊλã2Ϊ2λãơʡԣĬΪλá
*/
LIBAPI(int, krnln_asc)
{// ߺ 
	PMDATA_INF pArgInf = &ArgInf;
	INT nIdx;
	if(pArgInf[1].m_dtDataType == _SDT_NULL)
		nIdx = 0;
	else
		nIdx = pArgInf[1].m_int - 1;

	if (nIdx < 0) return 0;

	char* cp = pArgInf[0].m_pText;
	if (!cp) return 0;

	char* pStart = pArgInf[0].m_pText + nIdx;

	//ǷԽ磬Ҳñڴ档
	while (*cp && cp < pStart)
		cp++;

	return (int)*cp;
}
// { // ԭ
// 	PMDATA_INF pArgInf = &ArgInf;
// 	INT nLen = strlen(ArgInf.m_pText);
// 	if(nLen==0)return 0;
// 	INT nIdx;
// 	if(pArgInf[1].m_dtDataType == _SDT_NULL)
// 		nIdx = 1;
// 	else
// 		nIdx = pArgInf[1].m_int;
// 	if(nIdx <= 0 || nIdx > nLen)return 0;
// 
// 	return ArgInf.m_pText[nIdx-1];	
// }


================================================
FILE: krnln/krnln_atn.cpp
================================================
#include "stdafx.h"
#include <math.h>
// - 
/*
    øʽ ˫С͡  ˫С ䷴ֵֵ - ϵͳֿ֧->
    Ӣƣatn
    ָķֵΪ
    <1>Ϊ䷴ֵֵΪ˫Сͣdouble
*/
LIBAPI(void, krnln_atn)
{
	ArgInf.m_double = atan(ArgInf.m_double);
	__asm
	{
		mov eax,ArgInf.m_unit.m_dwFormID;
		mov edx,ArgInf.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_band.cpp
================================================
#include "stdafx.h"

//λ - λ
/*
    øʽ ͡ λ  λֵһ λֵ...  - ϵͳֿ֧->λ
    Ӣƣband
    ֵijͬλΪ1򷵻ֵĶӦλҲΪ1Ϊ0ؼĽΪмһԱظӡ
    <1>ΪλֵһΪͣint
    <2>ΪλֵΪͣint
*/
LIBAPI(int, krnln_band)
{
	PMDATA_INF pArg = &ArgInf;
	int n = pArg->m_int;
	for(int i=1;i< nArgCount;i++)
	{
		n &= pArg[i].m_int;
	}

	return n;

}


================================================
FILE: krnln/krnln_beep.cpp
================================================
#include "stdafx.h"

//ϵͳ - 
/*
    øʽ ޷ֵ   - ϵͳֿ֧->ϵͳ
    Ӣƣbeep
    ͨý豸ȷһΪ
*/
LIBAPI(void, krnln_beep)
{
	::MessageBeep(0xffffffff);
}


================================================
FILE: krnln/krnln_bin.cpp
================================================
#include "stdafx.h"

//ֽڼ - ȡظֽڼ
/*
    øʽ ֽڼ ȡظֽڼ  ظֽڼ ظֽڼ - ϵͳֿ֧->ֽڼ
    Ӣƣbin
    һֽڼаָֽڼظΪ
    <1>ΪظΪͣint
    <2>ΪظֽڼΪֽڼbinֽڼڽصֽڼΪգһֽڼ
*/
LIBAPI(void*, krnln_bin)
{
	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[0].m_int <=0 || pArgInf[1].m_pBin==NULL)
		return NULL;
	INT nLen = pArgInf[1].m_pInt[1];
	if(nLen==0)return NULL;

	LPBYTE pSrc = pArgInf[1].m_pBin + 2*sizeof(INT);
	INT nBuf = nLen * pArgInf[0].m_int;
	LPBYTE pData = (LPBYTE)E_MAlloc_Nzero(nBuf+2*sizeof(INT));
	LPBYTE pDest = pData;
	*(LPINT)pDest=1;
	pDest+=sizeof(INT);
	*(LPINT)pDest=nBuf;
	pDest+=sizeof(INT);
	for(INT i=0;i<pArgInf[0].m_int;i++)
	{
		memcpy(pDest,pSrc,nLen);
		pDest+=nLen;
	}
	return pData;
}


================================================
FILE: krnln/krnln_bnot.cpp
================================================
#include "stdafx.h"

//λ - λȡ
/*
    øʽ ͡ λȡ  ȡֵ - ϵͳֿ֧->λ
    Ӣƣbnot
    ֵָÿһλֵȡ󷵻ءΪм
    <1>ΪȡֵΪͣint
*/
LIBAPI(int, krnln_bnot)
{
	int n = ~ArgInf.m_int;
	return n;
}


================================================
FILE: krnln/krnln_bor.cpp
================================================
#include "stdafx.h"

//λ - λ
/*
    øʽ ͡ λ  λֵһ λֵ...  - ϵͳֿ֧->λ
    Ӣƣbor
    ֵһֵijһλΪ㣬򷵻ֵĶӦλΪ1Ϊ0ؼĽΪмһԱظӡ
    <1>ΪλֵһΪͣint
    <2>ΪλֵΪͣint
*/
LIBAPI(int, krnln_bor)
{
	PMDATA_INF pArg = &ArgInf;
	int n = pArg->m_int;
	for(int i=1;i< nArgCount;i++)
	{
		n |= pArg[i].m_int;
	}

	return n;
}


================================================
FILE: krnln/krnln_bxor.cpp
================================================
#include "stdafx.h"

//λ - λ
/*
    øʽ ͡ λ  λֵһ λֵ...  - ϵͳֿ֧->λ
    Ӣƣbxor
    ֵӦλֵȣ򷵻ֵĶӦλΪ1Ϊ0ؼĽΪмһԱظӡ
    <1>ΪλֵһΪͣint
    <2>ΪλֵΪͣint
*/
LIBAPI(int, krnln_bxor)
{
	PMDATA_INF pArg = &ArgInf;
	int n = pArg->m_int;
	for(int i=1;i< nArgCount;i++)
	{
		n ^= pArg[i].m_int;
	}

	return n;
}


================================================
FILE: krnln/krnln_chr.cpp
================================================
#include "stdafx.h"

//ı - ַ
/*
    øʽ ı͡ ַ ֽ ȡַַ룩 - ϵͳֿ֧->ı
    Ӣƣchr
    һıаַָصַΪ
    <1>Ϊȡַַ롱Ϊֽͣbyte
*/
LIBAPI(char*, krnln_chr)
{
	if(ArgInf.m_byte==0)return NULL;

	char *pText = (char*)E_MAlloc_Nzero(2);
	pText[0]=ArgInf.m_byte;
	pText[1]=0;
	return pText;	
}


================================================
FILE: krnln/krnln_close.cpp
================================================
#include "stdafx.h"

//ļд - رļ
/*
    øʽ ޷ֵ رļ  رյļţ - ϵͳֿ֧->ļд
    Ӣƣclose
    رձ򿪵ĸļΪ
    <1>ΪرյļšΪͣintֵָرյļţļɡļء
*/
LIBAPI(void, krnln_close)
{
	if(ArgInf.m_pCompoundData)
		CloseEfile((PFILEELEMENT)ArgInf.m_pCompoundData);
}


================================================
FILE: krnln/krnln_cos.cpp
================================================
#include "stdafx.h"
#include <math.h>
// - 
/*
    øʽ ˫С͡  ˫С мĽǣ - ϵͳֿ֧->
    Ӣƣcos
    ָǵֵΪ
    <1>ΪмĽǡΪ˫СͣdoubleʹõλΪȡΪ˽Ƕתɻȣ뽫Ƕȳ #pi / 180Ϊ˽תɽǶȣ뽫ȳ 180 / #piֵڵ 2  63 ηСڵ -2  63 η¼
*/
LIBAPI(void, krnln_cos)
{
	ArgInf.m_double = cos(ArgInf.m_double);
	__asm
	{
		mov eax,ArgInf.m_unit.m_dwFormID;
		mov edx,ArgInf.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_create.cpp
================================================
#include "stdafx.h"
#include"shlwapi.h"
#pragma comment(lib,"shlwapi.lib") 

#if (_MSC_VER <= 1600)
WINOLEAUTAPI VarDateFromUdateEx(UDATE* pudateIn, LCID lcid, ULONG dwFlags, DATE* pdateOut);
#endif

#pragma pack(push, 1)

/*©ӿ*/
typedef struct _ColumnInfo//ֶϢ
{
	const char* Name;
	int Type;
	int StrDataLenth;
}ColumnInfo, * lpColumInfo;

int  CreateEdb(const char* Filename, ColumnInfo* ColumnArry, int ColumnNum);
BOOL IsValidName(const char* text);
char* refilename(const char* Filename, const char* extensionname);

struct EDTDATA//EDT
{
	EDTDATA() {
		Typename = 'TDEW'; //ʶWEDT
		delimiter1 = 0x00010000;//ָ
		check = 0;//COleDateTime::GetTickCount()ÿδ򿪻ˢ£ԭEDB;;
		delimiter2 = 1;//ָ
		memset(data, 0, 492);
	}
	int Typename;//ʶWEDT
	int delimiter1;//ָ0010 65536 Ҳshortôд;
	double  check;//COleDateTime::GetTickCount()ÿδ򿪻ˢ£ԭEDB;;
	int delimiter2;//ָ0000 0;//ָ1000 1;
	BYTE data[492];
};
struct EDBDATA//EDB
{
	EDBDATA() {
		Typename = 'BDEW'; //ʶWEDB
		delimiter1 = 0x00010000;//ָ0010 65536 Ҳshortôд;
		check = 0;//COleDateTime::GetTickCount()ÿδ򿪻ˢ£ԭEDB;;
		delimiter2[0] = 0;//ָ0000 0;
		delimiter2[1] = 1;//ָ1000 1;
		TotalLength = 0;//ЧֶStorageLength4+ͳ* 4;;
		memset(blankBYTE, 0, 84);
		ValidColumnNum = 0;//112λ󴢴intЧֶ;
	}
	int Typename;//ʶWEDB
	int delimiter1;//ָ0010 65536 Ҳshortôд;
	double  check;//COleDateTime::GetTickCount()ÿδ򿪻ˢ£ԭEDB;;
	int delimiter2[2];//ָ0000 0;//ָ1000 1;
	int  TotalLength;//ЧֶStorageLength4+ͳ* 4;;
	BYTE  blankBYTE[84];//Ŀǰδ֪84հ׳ȣӦ;
	int ValidColumnNum;//112λ󴢴intЧֶ;
};

struct COLIMNDATA//ֶϢ
{
	COLIMNDATA() {
		memset(this, 0, sizeof(COLIMNDATA));
		DataLenth = 20;
	}
	char ColumnName[16];//16,߽
	BYTE delimiter[4];//ָ
	int ColumnType;
	int DataLenth;//ݳ;
	int strlenth;//ΪıҪ;
	BYTE Table[40];
};
#pragma pack(pop)

double  GetCOLeDateTime()//Ϊ¼ԭEDB,Уʱ䣬Ϊ˰EDT
{
    SYSTEMTIME time;
    GetLocalTime(&time);
    double pdateOut;
    UDATE pudateIn;
    pudateIn.st.wDayOfWeek = time.wDayOfWeek;
    pudateIn.st.wYear = time.wYear;
    pudateIn.st.wHour = time.wHour;
    pudateIn.st.wMinute = time.wMinute;
    pudateIn.st.wDay = time.wDay;
    pudateIn.st.wMonth = time.wMonth;
    pudateIn.st.wSecond = time.wSecond;
    VarDateFromUdateEx(&pudateIn, 0x409u, 0x80000000, &pdateOut);
    return pdateOut;

}//

int  CreateEdb(const char* Filename, ColumnInfo* ColumnArry, int ColumnNum)
{
	BYTE* Data = NULL;
	// int DataLenth = 0;
	int Index;//жֶظ
	int i;//ȫּƴ
	int ValidColumnNum = 0;//Чֶ
	int StorageLength;//洢;
	int  NowColumnType = 0;//ǰֶ
	bool HaveByteorRemark = false;//Ƿֽͻע;
	/**/
	int  TotalLength = 4;//οռ¼ֶ󳤶;
	int DataLenth = 4;//ʼֶݳ
	int strlenth = 0;//ıݳ
	int Nowstrlenth = 0;//ıݳ
	const char* NowColumnName = NULL;//ǰֶ;
	EDBDATA EdbData;//ṹ;
	double checktime = 0;//ļУ;
	HANDLE hFile = NULL;
	HANDLE hDataFile = NULL;

	//BYTE ColumnNameByte[16] = {  };//ҹ̶Ϊ16;
	//BYTE NowData[72];
	//lpReOpenBuff;//ԭʹ;

	if (!Filename) {
		return -3;
	}
	if (ColumnNum <= 0) {
		return -16;
	}
	for (i = 0; i < ColumnNum; i++) {
		//cout << ColumnArry[i].Name;
		if (!ColumnArry[i].Name)// ɨֶͣԺֶβɨ{
		{
			ColumnNum = ValidColumnNum;
			if (ValidColumnNum <= 0) {
				return -16;
			}
		}
		else {
			if (!IsValidName(ColumnArry[i].Name) || strlen(ColumnArry[i].Name) > 16) {
				return -18;
			}
			NowColumnType = ColumnArry[i].Type;
			StorageLength = 4;
			if (NowColumnType > 12) { // ʹ12
				return -17;
			}
			switch (NowColumnType)
			{
			case 1:
				StorageLength = 1;
				break;
			case 7:
				StorageLength = 1;
				break;
			case 2:
				StorageLength = 2;
				break;
			case 4:
				StorageLength = 8;
				break;
			case 6:
				StorageLength = 8;
				break;
			case 8:
				StorageLength = 8;
				break;
			case 10:
				StorageLength = 0;
				break;
			case 3:
				StorageLength = 4;
				break;
			case 5:
				StorageLength = 4;
				break;
			case 9:
				StorageLength = 4;
				break;
			case 11:
				StorageLength = 4;
				break;
			case 12:
				StorageLength = 4;
				break;
			default:
				return -17;//Чֶ
			}

			if (NowColumnType == 10) { // Ϊı
				StorageLength = ColumnArry[i].StrDataLenth;
				if (StorageLength < 1 || StorageLength>1024) {
					return -19;
				}
			}
			if (HaveByteorRemark == false && (NowColumnType == 12 || NowColumnType == 11)) {
				HaveByteorRemark = true;
			}
			TotalLength = TotalLength + StorageLength; // ܳȣԺÿչһ¿ռ¼Ϊһܳ;
			ValidColumnNum = ValidColumnNum + 1; // ȫԺЧֶԼ1Чֶνͣ;
		}
	}

	//жǷظֶ
	for (i = 0; i < ColumnNum; i++) {
		NowColumnName = ColumnArry[i].Name;
		for (Index = 0; Index < ColumnNum; ++Index) {
			if (Index != i) {
				if (0 == strcmp(NowColumnName, ColumnArry[Index].Name)) {
					return -20;
				}
			}
		}
	}
	; // ΪŴ汾Ӧôдģû⣬Ͼ벻˴Gڴ;
	; // hFile=OpenFile (refilename (Filename, ".edb"), lpReOpenBuff, λ (E_OF_SHARE_EXCLUSIVE, E_OF_CREATE, E_OF_WRITE));
	; // ִá;
	; // HANDLE hFile = CreateFileA(refilename(Filename, ".edb").c_str(), GENERIC_WRITE, 0, 0, OPEN_ALWAYS, FILE_ATTRIBUTE_ARCHIVE, 0);;
	char* infilename = refilename(Filename, ".edb");
	hFile = CreateFileA(infilename, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_ARCHIVE, 0);//CREATE_ALWAYSΪ"ʹļǿ"
	delete[]infilename;
	; //  (refilename (Filename, ".edb"));
	; // (hFile == INVALID_HANDLE_VALUE);
	; // (hFile == HFILE_ERROR);
	if (hFile == INVALID_HANDLE_VALUE) {
		CloseHandle(hFile);
		return -1;
	}
	; // memset (ȡݵַ (EdbData), 0, 160)  ; // EdbData={};
	checktime = GetCOLeDateTime();
	EdbData.check = checktime;
	EdbData.ValidColumnNum = ValidColumnNum;
	EdbData.TotalLength = TotalLength;
	// ṹ壬οﵽΪֹʹ;
	// Уʱ䣬ڼݺͰEDTļ;
	// ȫͬģֽڼ᷽һ㣬C++ýṹ;


	COLIMNDATA* AllColumnData = new COLIMNDATA[ColumnNum];

	for (i = 0; i < ColumnNum; i++) {
		//COLIMNDATA NowData;

		NowColumnType = ColumnArry[i].Type;
		memcpy(AllColumnData[i].ColumnName, ColumnArry[i].Name, strlen(ColumnArry[i].Name));
		AllColumnData[i].ColumnType = NowColumnType;
		if (NowColumnType == 10) { // Ϊıͳ{
			strlenth = ColumnArry[i].StrDataLenth;
		}
		else {
			strlenth = 0;
		}
		if (NowColumnType == 10) {
			Nowstrlenth = ColumnArry[i].StrDataLenth;
		}
		else {
			if (13 > NowColumnType && NowColumnType > 0) {
				switch (NowColumnType)
				{
				case 1:
					Nowstrlenth = 1;
					break;
				case 7:
					Nowstrlenth = 1;
					break;
				case 2:
					Nowstrlenth = 2;
					break;
				case 4:
					Nowstrlenth = 8;
					break;
				case 6:
					Nowstrlenth = 8;
					break;
				case 8:
					Nowstrlenth = 8;
					break;
				case 10:
					Nowstrlenth = 0;
					break;
				case 3:
					Nowstrlenth = 4;
					break;
				case 5:
					Nowstrlenth = 4;
					break;
				case 9:
					Nowstrlenth = 4;
					break;
				case 11:
					Nowstrlenth = 4;
					break;
				case 12:
					Nowstrlenth = 4;
					break;
				default:
					Nowstrlenth = -1;
					break;
				}
			}
			else {
				Nowstrlenth = -1;
			}
		}
		AllColumnData[i].DataLenth = DataLenth;
		DataLenth = DataLenth + Nowstrlenth; // ֶ󳤶;
		AllColumnData[i].strlenth = strlenth; // ıͳ;
	}

	DataLenth = sizeof(EdbData) + sizeof(COLIMNDATA) * ColumnNum;
	Data = new BYTE[DataLenth];
	memcpy(Data, &EdbData, sizeof(EdbData));
	memcpy(Data + sizeof(EdbData), AllColumnData, sizeof(COLIMNDATA) * ColumnNum);

	WriteFile(hFile, Data, DataLenth, 0, 0);

	delete[]AllColumnData;
	delete[]Data;
	CloseHandle(hFile);

	if (HaveByteorRemark == true) { // Ϊֽڼעͣ򴴽EDTļ{
		char* inedtname = refilename(Filename, ".EDT");
		hDataFile = CreateFileA(inedtname, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_ARCHIVE, 0);
		delete[]inedtname;
		; // hDataFile=OpenFile (refilename (Filename, ".edt"), lpReOpenBuff, 4113);
		if (hDataFile == INVALID_HANDLE_VALUE) {
			return -50;
		}
		EDTDATA EdTData;
		EdTData.check = checktime;
		if (WriteFile(hDataFile, &EdTData, sizeof(EDTDATA), 0, 0) == 0) {
			CloseHandle(hDataFile);
			return -50;
		}
		CloseHandle(hDataFile);
	}
	return 0;
}

char* refilename(const char* Filename, const char* extensionname) {
    char* NewPath = new char[MAX_PATH];
    char* suffix;
    strcpy(NewPath, Filename);
    suffix = PathFindExtensionA(extensionname);
    if (strlen(suffix) > 1)
    {
        if (PathRenameExtensionA(NewPath, suffix)) {
            return NewPath;
        };
        return NewPath;
    }
    return NewPath;
}

//ǷΪȫ
bool Isfullwidthnum(const char str, const char str2) {
    char str_[2] = { str2, str };
    short num = *(short*)((char*)str_);
    return num >= (short)0xA3C1u && num <= (short)0xA3DAu || num >= (short)0xA3E1u && num <= (short)0xA3FAu;;
};

//ǷΪȫĸ
bool Isfullwidthletter(const char str, const char str2) {
    char str_[2] = { str2, str };
    short letter = *(short*)((char*)str_);
    return letter >= (short)0xA3C1u && letter <= (short)0xA3DAu || letter >= (short)0xA3E1u && letter <= (short)0xA3FAu;;
};

BOOL Isvalidchar(const char* str) {
    char first = *str;
    BOOL result;
    if (first & 0x80)//ıΪ
    {
        char second = *(str + 1);
        if (((BYTE)first != 163 || (BYTE)second != 223) && !Isfullwidthnum(first, second) && !Isfullwidthletter(first, second) && ((BYTE)first < 0x81u || (BYTE)first > 0xA0u) && (BYTE)first < 0xAAu) {
            if (first == -87)//char[0]==-87ŶΣchar[1]==96Ϊ`Ϊ
            {
                if (second != 96) {
                    return -1;
                }
                return 1;
            }
            if (first == -92)//char[0]==-87ĶΣchar[1]>96Ϊ`Ϊ
            {
                if ((BYTE)second >= 0xA1u)
                {
                    if ((BYTE)second > 0xF3u) {
                        return -1;
                    }
                    return 1;
                }
                return -1;
            }
            if (first != -91 || (BYTE)second < 0xA1u || (BYTE)second > 0xF6u) {//Ƿַ{}
                return -1;
            }
        }
        return 1;
    };
    if (first == 95 || first >= 48 && first <= 57 || first >= 65 && first <= 90 || first >= 97 && first <= 122) {//Сдַ
        result = 0;
    }
    else {
        result = -1;
    }
    return result;
}

BOOL IsValidName(const char* text) {
    if (!text) {
        return 0;
    }
    BYTE NowChar = 0;
    int textlenth = strlen(text);

    if (*text >= 48 && *text <= 57 || *text == 46) {
        return false;
    }
    if (*text & 0x80 && Isfullwidthnum(text[0], text[1])) {
        return false;
    }

    for (int i = 0; i < textlenth; i++) {
        NowChar = text[i];

        if (!IsDBCSLeadByteEx(CP_ACP, NowChar)) {
            continue;
        };
        i++;
        BOOL isvalidchar = Isvalidchar(text);
        if (isvalidchar == -1)
        {
            return false;
        }
    }
    return 1;
}


LIBAPI(BOOL, krnln_create)
{
    PMDATA_INF pArgInf = &ArgInf;


    if (pArgInf[0].m_dtDataType != SDT_TEXT)
    {
        return FALSE;
    }

    const char* filename = pArgInf[0].m_pText;


    if (nArgCount != 2)
    {
        return FALSE;
    }

    DWORD nElementCount;
    lpColumInfo* pAryDataBegin = (lpColumInfo*)GetAryElementInf(pArgInf[1].m_pAryData, nElementCount);

    if (nElementCount < 1) {//涨Ϊ
        return FALSE;
    }
    ColumnInfo* InAryData = new ColumnInfo[nElementCount];
    if (!pAryDataBegin || !InAryData)
    {
        delete[]InAryData;
        return FALSE;
    }

    if (nElementCount > 0)
    {
        for (DWORD i = 0; i < nElementCount; i++) {
            InAryData[i].Name = pAryDataBegin[i]->Name;
            InAryData[i].StrDataLenth = pAryDataBegin[i]->StrDataLenth;
            InAryData[i].Type = pAryDataBegin[i]->Type;

        }

    }//memcppy
    BOOL ret = CreateEdb(filename, InAryData, nElementCount) == 0;
    delete[]InAryData;
    return ret;
}



================================================
FILE: krnln/krnln_day.cpp
================================================
#include "stdafx.h"
#include <math.h>
//ʱ - ȡ
/*
    øʽ ͡ ȡ ʱ ʱ䣩 - ϵͳֿ֧->ʱ
    Ӣƣday
    һֵΪ 1  31 ֮ʾһеijһաΪ
    <1>Ϊʱ䡱Ϊʱͣdate
*/
LIBAPI(int, krnln_day)
{
	INT nYear, nMonth, nDay;
	GetDatePart(ArgInf.m_date, nYear, nMonth, nDay);
	return nDay;
}


================================================
FILE: krnln/krnln_exp.cpp
================================================
#include "stdafx.h"
#include <math.h>
// - 󷴶
/*
    øʽ ˫С͡ 󷴶 ˫С ䷴ֵ - ϵͳֿ֧->
    Ӣƣexp
     eȻĵףijηΪ
    <1>Ϊ䷴ֵΪ˫Сͣdoubleֵ 709.782712893¼
*/
LIBAPI(void, krnln_exp) // ֱ޸eaxedxֵֵָ͡
{
	ArgInf.m_double = exp(ArgInf.m_double);
	__asm
	{
		mov eax,ArgInf.m_unit.m_dwFormID;
		mov edx,ArgInf.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_feof.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
#include "Myfunctions.h"
//ļд - Ƿļβ
/*
    øʽ ߼͡ Ƿļβ  ļţ߼ ǷΪжıѶݣ - ϵͳֿ֧->ļд
    Ӣƣfeof
    ָļĶдλѾڸļݵβ򷵻棬򷵻ؼ١Ϊ
    <1>ΪļšΪͣintֵָļţļűɡļء
    <2>ΪǷΪжıѶꡱΪ߼ͣboolԱʡԡֵΪһֽΪֵֽ 0  26 ıֹǷߵǰдλѴڸļݵβ档ʡԻΪ٣д˼顣

*/
LIBAPI(BOOL, krnln_feof)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return TRUE;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return TRUE;
	PMDATA_INF pArgInf = &ArgInf;
	INT nRet = TRUE;

	if(pFile->nType ==1 || pFile->nType == 3)//ļ ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		DWORD dwHi;
		UINT nLen = ::GetFileSize(hFile,&dwHi);
		UINT nLoc = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
		if(nLoc != HFILE_ERROR)
		{
			if(nLoc < nLen)
			{
				nRet = FALSE;
				
				if(pArgInf[1].m_dtDataType != _SDT_NULL && pArgInf[1].m_bool)
				{
					INT nData;
					LPSTR pStr = (LPSTR)&nData;
					DWORD dwByteTop;
					BOOL bRet = ReadFile(hFile, pStr, sizeof(BYTE), &dwByteTop, 0);
					SetFilePointer(hFile,nLoc,NULL,FILE_BEGIN);
					if (pFile->nType==3) //ļ
						E_RC4_Calc(nLoc, (unsigned char*)pStr, sizeof(BYTE), pFile->strTable, pFile->nCryptStart, pFile->strMD5);

					if(bRet && (*pStr==0 || *pStr == 26))
						nRet = TRUE;
				}
			}
		}
	}else if(pFile->nType ==2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*) pFile->FileHandle;
		UINT nLen = pMemFile->GetFileSize();
		UINT nLoc = pMemFile->GetPosition();
		if(nLoc < nLen)
		{
			nRet = FALSE;
			
			if(pArgInf[1].m_dtDataType != _SDT_NULL && pArgInf[1].m_bool)
			{
				INT nData;
				LPSTR pStr = (LPSTR)&nData;
				BOOL bRet = pMemFile->Read (pStr, sizeof(BYTE));
				pMemFile->Seek(nLoc,CMyMemFile::begin);
				if(bRet && (*pStr==0 || *pStr == 26))
					nRet = TRUE;
			}
		}
	}
	return nRet;
}


================================================
FILE: krnln/krnln_fgets.cpp
================================================
#include "stdafx.h"
#include <conio.h>
//̨ - ׼
/*
    øʽ ı͡ ׼ ߼ Ƿԣݣ - ϵͳֿ֧->̨
    Ӣƣfgets
    ڱ׼豸2048ַһıûݡעⱾֻڿ̨ʹáΪ
    <1>ΪǷԡΪ߼ͣboolԱʡԡʱǷʾַΪٲʾΪʾʡԣĬֵΪ棬ԡͨΪϢ
*/
LIBAPI(char*, krnln_fgets)
{
	if(ArgInf.m_dtDataType == _SDT_NULL || ArgInf.m_bool){

		HANDLE hCon = GetStdHandle(STD_INPUT_HANDLE);
		if(hCon==NULL)
			return NULL;
		char Buff[2048];
		DWORD dwSize;
		LPSTR pText = NULL;
		if(ReadConsole(hCon,Buff,2048,&dwSize,NULL))
		//if(ReadFile(hCon,Buff,2048,&dwSize,NULL))
		{
			
			
			if(dwSize>2)
			{
				for(INT i=0;i<(INT)dwSize;i++)
				{
					if(Buff[i]==0)
						break;
					else if(Buff[i]=='\r')
					{
						Buff[i]=0;
						break;
					} else if(Buff[i]=='\n')
					{
						Buff[i]=0;
						break;
					}
					
				}
			}
			pText = CloneTextData(Buff,dwSize);
			
		}
		return pText ;
	}else{
		char Buff[2049];
		INT nIdx = 0;
		Buff[2048]=0;
		do
		{
#if _MSC_VER > 1200
			INT nChr = _getch();
#else
			INT nChr = getch();
#endif
			Buff[nIdx] = (char)nChr;
			if ( nChr == 13 )
				break;
			++nIdx;
		}
		while ( nIdx < 2048 );
		return CloneTextData(Buff,nIdx);
	}
}


================================================
FILE: krnln/krnln_fix.cpp
================================================
#include "stdafx.h"
#include <math.h>
// - ȡ
/*
    øʽ ͡ ȡ ˫С ȡС - ϵͳֿ֧->
    Ӣƣfix
    һС֡롰ȡ֮ͬΪ
СΪشڻڸСĵһȡ᷵СڻڸСĵһ磬 -7.8 ת -7ȡ -7.8 ת -8Ϊ
    <1>ΪȡСΪ˫Сͣdouble
*/
double __cdecl ProcessDouble2(double a1)
{
  double v1; // st7@1
  double result; // st7@6
  double v3; // [sp+0h] [bp-8h]@1
  signed int v4; // [sp+Ch] [bp+4h]@4

  v1 = modf(a1, &v3);
  if ( v1 < 0.0 )
    v1 = -v1;
  if ( v1 <= 0.999999999999 )
  {
    result = a1;
  }
  else
  {
    v4 = -1;
    if ( v3 >= 0.0 )
      v4 = 1;
    result = (double)v4 + v3;
  }
  return result;
}

LIBAPI(int, krnln_fix)
{
	INT nRet;
/*	if(0<ArgInf.m_double)
		nRet = floor(ArgInf.m_double);
	else
		nRet = ceil(ArgInf.m_double);*/
	double v5;
	modf(ProcessDouble2(ArgInf.m_double), &v5);
	nRet = (INT)v5;
	return nRet;
}


================================================
FILE: krnln/krnln_fputs.cpp
================================================
#include "stdafx.h"
#include <stdio.h>
#include "Myfunctions.h"
//̨ - ׼
/*
    øʽ ޷ֵ ׼  ݣͨ ݣ...  - ϵͳֿ֧->̨
    Ӣƣfputs
    ڱ׼豸׼豸ָݣעⱾֻڿ̨ʹáΪһԱظӡ
    <1>Ϊ򡱣ΪͣintԱʡԡṩ豸Ϊ³ֵ֮һ 1#׼豸 2#׼豸ʡԱĬΪ#׼豸
    <2>ΪݡΪͨͣallֻΪıֵ߼ֵʱ䡣ΪıҰУڸ֮ûس (ַ (13))з (ַ (10)) سз (ַ (13) + ַ (10)) ָ
*/
LIBAPI(void, krnln_fputs)
{
	PMDATA_INF pArgInf = &ArgInf;
	
	DWORD dwSdt = STD_OUTPUT_HANDLE;
	if(pArgInf[0].m_dtDataType != _SDT_NULL && pArgInf[0].m_int==2)
		dwSdt = STD_ERROR_HANDLE;
	HANDLE hCon = GetStdHandle(dwSdt);
	if(hCon==NULL)
			return;
/*	 _iobuf* hCon = stdout;
	if(pArgInf[0].m_dtDataType != _SDT_NULL && pArgInf[0].m_int==2)
		hCon = stderr;*/

	for(INT i=1;i < nArgCount;i++)
	{
		LPSTR pData;
		BOOL bNeedFree = FALSE;
		if(pArgInf[i].m_dtDataType == SDT_TEXT)
			pData = pArgInf[i].m_pText;
		else
		{
			pData = SDataToStr(&pArgInf[i]);
			if(pData == NULL)
				continue;
			bNeedFree = TRUE;
		}
		
		UINT nLen = mystrlen(pData);
		//char text[50];
		//itoa(nLen,text,10);
		//MessageBox(NULL,text,NULL,MB_OK);
		if(nLen>0)
		{
			LPSTR pStr = pData;
			while(nLen>0){
				DWORD dwSize=0;
				UINT nSize = 1024;
				if(nLen<1024)
					nSize = nLen;
				WriteFile(hCon,pStr,nSize,&dwSize,NULL);
				nLen-=dwSize;
				pStr+=dwSize;
			}
			
			//WriteConsole(hCon,pData,nLen,&dwSize,NULL);
			

			//fprintf(hCon, "%s",pData); 
		}
		
		if(bNeedFree)
			free(pData);

	}
	

}


================================================
FILE: krnln/krnln_hex.cpp
================================================
#include "stdafx.h"
#include <stdio.h>
//ֵת - ȡʮı
/*
    øʽ ı͡ ȡʮı  ȡıֵ - ϵͳֿ֧->ֵת
    Ӣƣhex
    һıֵָʮʽΪ
    <1>ΪȡıֵΪͣint
*/
LIBAPI(char*, krnln_hex)
{
	char *pText = (char*)E_MAlloc_Nzero(16);
	sprintf(pText,"%X",ArgInf.m_int);
	return pText;
}


================================================
FILE: krnln/krnln_hour.cpp
================================================
#include "stdafx.h"
#include <math.h>
//ʱ - ȡСʱ
/*
    øʽ ͡ ȡСʱ ʱ ʱ䣩 - ϵͳֿ֧->ʱ
    Ӣƣhour
    һֵΪ 0  23 ֮ʾһеijһСʱΪ
    <1>Ϊʱ䡱Ϊʱͣdate
*/
LIBAPI(int, krnln_hour)
{
	INT nHour, nMinute, nSecond;
	GetTimePart(ArgInf.m_date, nHour, nMinute, nSecond);
	return nHour;
}


================================================
FILE: krnln/krnln_int.cpp
================================================
#include "stdafx.h"
#include <math.h>
// - ȡ
/*
    øʽ ͡ ȡ ˫С ȡС - ϵͳֿ֧->
    Ӣƣint
    һС֡롰ȡ֮ͬΪ
СΪСڻڸСĵһȡ᷵شڻڸСĵһ磬 -7.8 ת -8ȡ -7.8 ת -7Ϊ
    <1>ΪȡСΪ˫Сͣdouble
*/
double __cdecl ProcessDouble(double a1)
{
  double v1; // st7@1
  double result; // st7@6
  double v3; // [sp+0h] [bp-8h]@1
  signed int v4; // [sp+Ch] [bp+4h]@4

  v1 = modf(a1, &v3);
  if ( v1 < 0.0 )
    v1 = -v1;
  if ( v1 <= 0.999999999999 )
  {
    result = a1;
  }
  else
  {
    v4 = -1;
    if ( v3 >= 0.0 )
      v4 = 1;
    result = (double)v4 + v3;
  }
  return result;
}

LIBAPI(int, krnln_int)
{
	return (int)floor(ProcessDouble(ArgInf.m_double));
}


================================================
FILE: krnln/krnln_kill.cpp
================================================
#include "stdafx.h"

//̲ - ɾļ
/*
    øʽ ߼͡ ɾļ ı ɾļ - ϵͳֿ֧->̲
    Ӣƣkill
    ɹ棬ʧܷؼ١Ϊ
    <1>ΪɾļΪıͣtext
*/
LIBAPI(BOOL, krnln_kill)
{
	return DeleteFile(ArgInf.m_pText);
}


================================================
FILE: krnln/krnln_left.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
//ı - ȡı
/*
    øʽ ı͡ ȡı ı ȡ䲿ֵı ȡַĿ - ϵͳֿ֧->ı
    Ӣƣleft
    һıаָıдַָΪ
    <1>Ϊȡ䲿ֵıΪıͣtext
    <2>ΪȡַĿΪͣint
*/
LIBAPI(char*, krnln_left)
{
	PMDATA_INF pArgInf = &ArgInf;
	INT nLen = mystrlen(ArgInf.m_pText);
	if(nLen==0 || pArgInf[1].m_int <=0)return NULL;

	if(pArgInf[1].m_int < nLen)
		nLen = pArgInf[1].m_int;

	char *pText = (char*)E_MAlloc_Nzero(nLen+1);
	memcpy(pText,ArgInf.m_pText,nLen);
	pText[nLen]=0;
	return pText;	

}


================================================
FILE: krnln/krnln_len.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"

//ı - ȡı
/*
    øʽ ͡ ȡı ı ıݣ - ϵͳֿ֧->ı
    Ӣƣlen
    ȡıݵijȣ0Ϊ
    <1>ΪıݡΪıͣtextֵָ䳤ȵıݡ
*/
LIBAPI(int, krnln_len)
{
	return mystrlen(ArgInf.m_pText);
}


================================================
FILE: krnln/krnln_like.cpp
================================================
#include "stdafx.h"

//߼Ƚ - Ƶ
/*
    øʽ ߼͡ Ƶ ı Ƚıı Ƚı - ϵͳֿ֧->߼Ƚ
    Ӣƣlike
    ȽıڱȽıײʱ棬򷵻ؼ٣Ϊ?=򡰡֡Ϊ
    <1>ΪȽıΪıͣtext
    <2>ΪȽıΪıͣtext
*/
LIBAPI(BOOL, krnln_like)
{// ߺ 
	PMDATA_INF pArgInf = &ArgInf;
	register char *str1 = pArgInf[0].m_pText;
	register char *str2 = pArgInf[1].m_pText;
	if (!str1 || !str2 || !*str1 || !*str2) return FALSE; //ıֱӷ

	while ( *str1 && *str2 && *str1==*str2 )
		str1++, str2++;

	return *str2==0;
}
// {// ԭ
// /*	PMDATA_INF pArgInf =&ArgInf;
// 	INT nLen = strlen(pArgInf[1].m_pText);
// 	if(strlen(pArgInf[0].m_pText) < nLen)
// 		return FALSE;
// 	if(memcmp(pArgInf[0].m_pText,pArgInf[1].m_pText,nLen)==0)
// 		return TRUE;
// 	return FALSE;*/
//   BOOL result; // eax@1
//   char *v4; // edx@1
//   size_t v5; // ebx@1
//   char *v6; // esi@1
//   char *v7; // edi@1
//   PMDATA_INF pArgInf =&ArgInf;
// 
//   v4 = pArgInf->m_pText;
//   v6 = pArgInf[1].m_pText;
//   v7 = pArgInf[1].m_pText;
//   result = FALSE;
//   v5 = strlen(v7);
//   if ( v5 <= strlen(v4) )
//   {
//     result = strncmp(v6, v4, v5) == 0;
//   }
//   return result;
// }


================================================
FILE: krnln/krnln_loc.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
//ļд - ȡдλ
/*
    øʽ ͡ ȡдλ  ļţ - ϵͳֿ֧->ļд
    Ӣƣloc
    ָļĵǰ/дλãλֵ 0 ʼļЧʧܣ -1 Ϊ
    <1>ΪļšΪͣintֵָļţļűɡļء
*/
LIBAPI(int, krnln_loc)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return -1;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return -1;
	INT nRet = HFILE_ERROR;

	if(pFile->nType == 1 || pFile->nType == 3)//ļ ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		nRet = SetFilePointer(hFile,0,NULL,FILE_CURRENT);

	}else if(pFile->nType ==2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*) pFile->FileHandle;
		nRet = pMemFile->GetPosition();
	}
	return nRet;
}


================================================
FILE: krnln/krnln_lock.cpp
================================================
#include "stdafx.h"

//ļд - סļ
/*
    øʽ ߼͡ סļ  ļţ λã ijȣ ʱݣ - ϵͳֿ֧->ļд
    Ӣƣlock
    ɸ̷ͬһļĻУʹñܾûԱļеijждʡɹ棬ʧܷؼ١Ϊ
    <1>ΪļšΪͣintļɡļء
    <2>ΪλáΪͣintλֵ 0 ʼ
    <3>ΪijȡΪͣint
    <4>Ϊʱ䡱ΪͣintԱʡԡָʧܺ󷴸ԵĺʡԣĬΪ 0 һʧءֵṩΪ -1 򷴸ԣֱɹΪֹ

*/
LIBAPI(BOOL, krnln_lock)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return FALSE;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return FALSE;
	if(pFile->nType !=1)//ڴļ
		return TRUE;
	HANDLE hFile = (HANDLE)pFile->FileHandle;
	PMDATA_INF pArgInf = &ArgInf;
	OVERLAPPED Overlapped;
	memset(&Overlapped,0,sizeof(OVERLAPPED));
	Overlapped.Offset = pArgInf[1].m_int;
	DWORD dwFlags = LOCKFILE_FAIL_IMMEDIATELY;
	if(pArgInf[3].m_dtDataType != _SDT_NULL)
	{
		if(pArgInf[3].m_int== -1)
			dwFlags = 0;
		else if(pArgInf[3].m_int > 0)
		{	
			DWORD dwStart = ::GetTickCount();
			BOOL bRet;
			INT nVal;
			do
			{
				bRet = LockFileEx(hFile,LOCKFILE_FAIL_IMMEDIATELY,0,pArgInf[2].m_int,0,&Overlapped);
				nVal = GetTickCount() - dwStart;
			}while(bRet == FALSE && nVal <= pArgInf[3].m_int);

			return bRet;
		}

	}

	return LockFileEx(hFile,
		dwFlags,
		0,
		pArgInf[2].m_int,
		0,
		&Overlapped);

}


================================================
FILE: krnln/krnln_lof.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
//ļд - ȡļ
/*
    øʽ ͡ ȡļ  ļţ - ϵͳֿ֧->ļд
    Ӣƣlof
    ָļijߴ磬óߴֽΪλļЧʧܣ -1 Ϊ
    <1>ΪļšΪͣintֵָļţļűɡļء
*/
LIBAPI(int, krnln_lof)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return -1;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return -1;
	INT nRet = -1;

	if(pFile->nType ==1 || pFile->nType == 3)//ļ ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		DWORD dwHi;
		nRet = ::GetFileSize(hFile,&dwHi);


	}else if(pFile->nType ==2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*) pFile->FileHandle;
		nRet = pMemFile->GetFileSize();
	}
	return nRet;
}


================================================
FILE: krnln/krnln_log.cpp
================================================
#include "stdafx.h"
#include <math.h>
// - Ȼ
/*
    øʽ ˫С͡ Ȼ ˫С Ȼֵ - ϵͳֿ֧->
    Ӣƣlog
    ָȻֵȻ e Ϊ׵Ķ #e ֵԼ 2.718282Ϊ
    <1>ΪȻֵΪ˫Сͣdouble
*/
LIBAPI(void, krnln_log)
{
	ArgInf.m_double = log(ArgInf.m_double);
	__asm
	{
		mov eax,ArgInf.m_unit.m_dwFormID;
		mov edx,ArgInf.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_mid.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
//ı - ȡıм
/*
    øʽ ı͡ ȡıм ı ȡ䲿ֵı ʼȡλã ȡַĿ - ϵͳֿ֧->ı
    Ӣƣmid
    һıаָıдָλַָΪ
    <1>Ϊȡ䲿ֵıΪıͣtext
    <2>ΪʼȡλáΪͣint1Ϊλã2Ϊ2λãơ
    <3>ΪȡַĿΪͣint
*/
LIBAPI(char*, krnln_mid)
{
	PMDATA_INF pArgInf = &ArgInf;
	if (pArgInf[1].m_int <=0 || pArgInf[2].m_int <= 0 ) return NULL;
	INT nLen = mystrlen(ArgInf.m_pText);
	if(nLen == 0) return NULL;
	//if(pArgInf[1].m_int <=0)
	//	pArgInf[1].m_int = 1;
	if(pArgInf[1].m_int > nLen)//ʼλòı
		return NULL;

	INT nSubLen = pArgInf[1].m_int+pArgInf[2].m_int;
	if(nSubLen > nLen)
		nSubLen = nLen - pArgInf[1].m_int+1;
	else
		nSubLen = pArgInf[2].m_int;

	char* pSrc = ArgInf.m_pText + pArgInf[1].m_int - 1;

	char *pText = (char*)E_MAlloc_Nzero(nSubLen+1);
	memcpy(pText,pSrc,nSubLen);
	pText[nSubLen]=0;
	return pText;	

}


================================================
FILE: krnln/krnln_minute.cpp
================================================
#include "stdafx.h"
#include <math.h>
//ʱ - ȡ
/*
    øʽ ͡ ȡ ʱ ʱ䣩 - ϵͳֿ֧->ʱ
    Ӣƣminute
    һֵΪ 0  59 ֮ʾһСʱеijһӡΪ
    <1>Ϊʱ䡱Ϊʱͣdate
*/
LIBAPI(int, krnln_minute)
{
	INT nHour, nMinute, nSecond;
	GetTimePart(ArgInf.m_date, nHour, nMinute, nSecond);
	return nMinute;
}


================================================
FILE: krnln/krnln_mod.cpp
================================================
#include "stdafx.h"
#include <math.h>
// - 
/*
    øʽ ˫С͡  ˫С ˫С ...  - ϵͳֿ֧->
    Ӣƣmod
    ֵ̣֣Ϊ%ModΪһԱظӡ
    <1>ΪΪ˫Сͣdouble
    <2>ΪΪ˫Сͣdouble
*/
LIBAPI(void, krnln_mod)
{

	PMDATA_INF pArg = &ArgInf;

	for(int i=1;i< nArgCount;i++)
	{
		ArgInf.m_double = fmod(ArgInf.m_double, pArg[i].m_double);
	}

	__asm
	{
		mov eax,ArgInf.m_unit.m_dwFormID;
		mov edx,ArgInf.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_month.cpp
================================================
#include "stdafx.h"
#include <math.h>
//ʱ - ȡ·
/*
    øʽ ͡ ȡ· ʱ ʱ䣩 - ϵͳֿ֧->ʱ
    Ӣƣmonth
    һֵΪ 1  12 ֮ʾָʱе·ݡΪ
    <1>Ϊʱ䡱Ϊʱͣdate

*/
LIBAPI(int, krnln_month)
{
	INT nYear, nMonth, nDay;
	GetDatePart(ArgInf.m_date, nYear, nMonth, nDay);
	return nMonth;
}


================================================
FILE: krnln/krnln_name.cpp
================================================
#include "stdafx.h"

//̲ - ļ
/*
    øʽ ߼͡ ļ ı ԭļĿ¼ı ΪļĿ¼ - ϵͳֿ֧->̲
    Ӣƣname
    һļĿ¼ɹ棬ʧܷؼ١Ϊ
    <1>ΪԭļĿ¼Ϊıͣtext
    <2>ΪΪļĿ¼Ϊıͣtext
*/
LIBAPI(BOOL, krnln_name)
{
	PMDATA_INF pArgInf = &ArgInf;
	return MoveFile(pArgInf[0].m_pText,pArgInf[1].m_pText);
}


================================================
FILE: krnln/krnln_now.cpp
================================================
#include "stdafx.h"

//ʱ - ȡʱ
/*
    øʽ ʱ͡ ȡʱ  - ϵͳֿ֧->ʱ
    Ӣƣnow
    صǰϵͳڼʱ䡣Ϊ
*/
LIBAPI(void, krnln_now)
{
	SYSTEMTIME now;
	MDATA_INF ArgInf2;
	GetLocalTime(&now);
	ArgInf2.m_double = GetSpecDateTime(now.wYear, now.wMonth, now.wDay, now.wHour, now.wMinute, now.wSecond);
	__asm{
		mov eax, ArgInf2.m_unit.m_dwFormID;
		mov edx, ArgInf2.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_oct.cpp
================================================
#include "stdafx.h"
#include <stdio.h>
//ֵת - ȡ˽ı
/*
    øʽ ı͡ ȡ˽ı  ȡıֵ - ϵͳֿ֧->ֵת
    Ӣƣoct
    һıֵָİ˽ʽΪ
    <1>ΪȡıֵΪͣint
*/
LIBAPI(char*, krnln_oct)
{
	char *pText = (char*)E_MAlloc_Nzero(256);
	sprintf(pText,"%o",ArgInf.m_int);
	return pText;
}


================================================
FILE: krnln/krnln_open.cpp
================================================
#include "stdafx.h"

//ļд - ļ
/*
    øʽ ͡ ļ ı 򿪵ļƣ 򿪷ʽݣ ʽݣ - ϵͳֿ֧->ļд
    Ӣƣopen
    һͨļԶļɹرļļţʧܷ 0Ϊ
    <1>Ϊ򿪵ļơΪıͣtext
    <2>Ϊ򿪷ʽΪͣintԱʡԡֵ˵ļIJʽʡԱĬΪ#дʽֵΪ³֮һ
  1#룺ָļݣļʧܣ
  2#ддݵָļļʧܣ
  3#дļжݻдݵļļʧܣ
  4#ддݵָļļȴһļѾھеݣ
  5#ддݵָļļ򴴽һļѾھֱӴ򿪣
  6#Ķļжݻдݵļļ򴴽һļѾھֱӴ򿪡
    <3>ΪʽΪͣintԱʡԡֵָ̲ļķʽʡԱĬΪ#ơʽֵΪ³֮һ
  1#ƣдļ
  2#̶ֹֹļ
  3#ֹдֹдļ
  4#ֹд̶ֹдļ
*/
LIBAPI(void*, krnln_open)
{
	PMDATA_INF pArgInf = &ArgInf;
	DWORD dwDesiredAccess,dwShareMode,dwCreationDisposition;

	if(pArgInf[1].m_dtDataType == _SDT_NULL)
	{//#д
		dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
		dwCreationDisposition = OPEN_EXISTING;
	}
	else
	{
		switch (pArgInf[1].m_int)
		{
		case 1://#
			dwDesiredAccess = GENERIC_READ;
			dwCreationDisposition = OPEN_EXISTING;
			break;
		case 2://#д
			dwDesiredAccess = GENERIC_WRITE;
			dwCreationDisposition = OPEN_EXISTING;
			break;
		case 4://#д
			dwDesiredAccess = GENERIC_WRITE;
			dwCreationDisposition = CREATE_ALWAYS;
			break;
		case 5://#д
			dwDesiredAccess = GENERIC_WRITE;
			dwCreationDisposition = OPEN_ALWAYS;
			break;
		case 6://#Ķ
			dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
			dwCreationDisposition = OPEN_ALWAYS;
			break;
		default://#д
			dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
			dwCreationDisposition = OPEN_EXISTING;
			break;
		}
	}

	if(pArgInf[2].m_dtDataType == _SDT_NULL)
		dwShareMode = (FILE_SHARE_READ | FILE_SHARE_WRITE );
	else
	{
		if(pArgInf[2].m_int ==2)
			dwShareMode = FILE_SHARE_WRITE ;
		else if(pArgInf[2].m_int ==3)
			dwShareMode = FILE_SHARE_READ ;
		else if(pArgInf[2].m_int ==4)
			dwShareMode = 0;
		else
			dwShareMode = (FILE_SHARE_READ | FILE_SHARE_WRITE );
	}

	HANDLE hFile = CreateFile(ArgInf.m_pText,
		dwDesiredAccess,
		dwShareMode,
		NULL,
		dwCreationDisposition,
		FILE_ATTRIBUTE_ARCHIVE,
		0);
	

	if(hFile != INVALID_HANDLE_VALUE)
	{
		PFILEELEMENT pFile = new FILEELEMENT;
		pFile->nType = 1;
		pFile->FileHandle = hFile;
		AddFileMangerList(pFile);
		return pFile;
	}
	return NULL;
}



================================================
FILE: krnln/krnln_p2double.cpp
================================================
#include "stdafx.h"
/*
	øʽ ˫Сָ͡뵽˫С ( ڴָ)
	Ӣƣp2double
	ָڴַָָһ˫С(DOUBLE)עñǰһҪȷṩڴַʵЧ
	<1>Ϊڴָ롱Ϊ͡ṩָһڴֵַָ
*/
LIBAPI(void, krnln_p2double)
{
	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[0].m_int!=0)
	{
		ArgInf.m_double = *(DOUBLE*)pArgInf [0].m_int;
	}else{
		ArgInf.m_double =0.0;
	}
	__asm
	{
		mov eax,ArgInf.m_unit.m_dwFormID;
		mov edx,ArgInf.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_p2float.cpp
================================================
#include "stdafx.h"
/*
	øʽ Сָ͡뵽С ( ڴָ)
	Ӣƣp2float
	ָڴַָָһС(FLOAT)עñǰһҪȷṩڴַʵЧ
	<1>Ϊڴָ롱Ϊ͡ṩָһڴֵַָ
*/
LIBAPI(void, krnln_p2float)
{
	float fRet=0.0f;
	PMDATA_INF pArgInf = &ArgInf;
	if(pArgInf[0].m_int!=0)
	{
		fRet=*((float*)pArgInf [0].m_int);
	}
	_asm mov eax, fRet;
}


================================================
FILE: krnln/krnln_p2int.cpp
================================================
#include "stdafx.h"
/*
	øʽ ָ͡뵽 ( ڴָ)
	Ӣƣp2int
	ָڴַָָһ(INT)עñǰһҪȷṩڴַʵЧ
	<1>Ϊڴָ롱Ϊ͡ṩָһڴֵַָ
*/	
LIBAPI(int, krnln_p2int)
{
	PMDATA_INF pArgInf = &ArgInf;
	//if(!IsBadReadPtr((LPVOID)pArgInf[0].m_int,sizeof(int)))
	if(pArgInf[0].m_int!=0)
	{
		return *((int*)pArgInf [0].m_int);
	}
	return 0;
}


================================================
FILE: krnln/krnln_pbin.cpp
================================================
#include "stdafx.h"

//ֽڼ - ָ뵽ֽڼ
/*
    øʽ ֽڼ ָ뵽ֽڼ  ڴָ룬 ڴݳȣ - ϵͳֿ֧->ֽڼ
    Ӣƣpbin
    ָڴַָָһݣעñǰһҪȷṩڴַʵЧʹóϾԻصӳDLLӳȡⲿݡΪ߼
    <1>Ϊڴָ롱Ϊͣintṩָһڴֵַָ
    <2>ΪڴݳȡΪͣintṩڴַȡݳȡ
*/
LIBAPI(void*, krnln_pbin)
{
	PMDATA_INF pArgInf = &ArgInf;
	if (!pArgInf[0].m_pCompoundData) return NULL;
	INT nLen = pArgInf[1].m_int;
	if(nLen<=0) return NULL; // || IsBadReadPtr(pArgInf[0].m_pCompoundData,nLen)

	LPINT pText = (LPINT)E_MAlloc_Nzero(nLen+2*sizeof(INT));
	pText[0]=1;
	pText[1]=nLen;
	memcpy(pText+2,pArgInf[0].m_pCompoundData,nLen);

	return pText;
}


================================================
FILE: krnln/krnln_ping.cpp
================================================
#include "stdafx.h"
#pragma comment(lib,"WS2_32.LIB")
#pragma comment(lib,"icmp.lib")

//ͨ - ͨŲ
/*
    øʽ ͡ ͨŲ ı ַ ȴʱݣ - ϵͳֿ֧->ͨ
    Ӣƣping
    ָǷܹͨѶرͨѶӦʱ䡣޷ͨѶ߲ʧܣ -1Ϊ
    <1>ΪַΪıͣtextΪIPַȡ
    <2>Ϊȴʱ䡱ΪͣintԱʡԡָȴӦʱ䣬λΪ롣ʱ伴Ϊ޷뱻ͨѶʡԱĬΪ 10 * 1000 룬 10 롣
*/
#pragma pack (push, old_value)   // VC++ṹֽ
#pragma pack (1)    // Ϊһֽڶ롣

typedef struct tagIPINFO 
{ 
u_char Ttl; // TTL 
u_char Tos; //  
u_char IPFlags; // IP־ 
u_char OptSize; // ѡݴС 
u_char *Options; // ѡbuffer 
} IPINFO, *PIPINFO; 

typedef struct tagICMPECHO 
{ 
u_long Source; // Դַ 
u_long Status; // IP״̬ 
u_long RTTime; // RTT 
u_short DataSize; // ظݴС 
u_short Reserved; //  
void *pData; // ظbuffer 
IPINFO ipInfo; // ظIPѡ 
char Data [250];
} ICMPECHO, *PICMPECHO; 

#pragma pack (pop, old_value)    // ָVC++ṹֽ

extern "C"
{
HANDLE _cdecl IcmpCreateFile(void);//򿪸ICMP Echoʹõľ 
BOOL _cdecl IcmpCloseHandle(HANDLE IcmpHandle);//رողŴ򿪵ľ 
DWORD _cdecl IcmpSendEcho(HANDLE,DWORD,LPVOID,WORD,PIPINFO,LPVOID,DWORD,DWORD);//Echo󲢵
}

DWORD BMGetIPbyname(char *HostName)
{
	hostent* heDestHost;
	DWORD retIP = inet_addr(HostName);
	if(retIP==0xFFFFFFFF)
	{
		heDestHost=gethostbyname (HostName);
		if(heDestHost)
			retIP=*(DWORD *)*heDestHost->h_addr_list;
	}

	return retIP;
}

LIBAPI(int, krnln_ping)
{
	PMDATA_INF pArgInf = &ArgInf;
	WSAData wsaData;
	INT nRet = -1;
	if(WSAStartup(MAKEWORD(2,2),&wsaData)==0)
	{
		DWORD dwAddress = BMGetIPbyname(pArgInf[0].m_pText);
		if(dwAddress != 0xFFFFFFFF)
		{
			DWORD dwPingTimeOut = 10000;
			if(pArgInf[1].m_dtDataType != _SDT_NULL)
				dwPingTimeOut = pArgInf[1].m_int;

			FARPROC (__stdcall *IcmpCreateFilefun)(void);
			*(FARPROC *)&IcmpCreateFilefun = (FARPROC)IcmpCreateFile;

			HANDLE hICmp = IcmpCreateFilefun();
			if(hICmp)
			{
				ICMPECHO icmp;
				FARPROC (__stdcall *IcmpSendEchofun)(HANDLE,DWORD,LPVOID,WORD,PIPINFO,LPVOID,DWORD,DWORD);
				*(FARPROC *)&IcmpSendEchofun = (FARPROC)IcmpSendEcho;

				if(IcmpSendEchofun (hICmp,
					dwAddress,
					(LPSTR)"BlackMoonPing",
					13,
					0,
					&icmp,
					sizeof(icmp),
					dwPingTimeOut))
				{
					nRet = icmp.RTTime;
				}
				FARPROC (__stdcall *IcmpCloseHandlefun)(HANDLE);
				*(FARPROC *)&IcmpCloseHandlefun = (FARPROC)IcmpCloseHandle;
				IcmpCloseHandlefun(hICmp);
			}

		}

		WSACleanup ();
	}
	return nRet;
}


================================================
FILE: krnln/krnln_pow.cpp
================================================
#include "stdafx.h"
#include <math.h>
// - η
/*
    øʽ ˫С͡ η ˫С ηֵ˫С η - ϵͳֿ֧->
    Ӣƣpow
    ֵָָηΪ
    <1>ΪηֵΪ˫Сͣdoubleֵָijηֵ
    <2>ΪηΪ˫Сͣdoubleֵָηֵָ
*/
LIBAPI(void, krnln_pow)
{
	PMDATA_INF pArg = &ArgInf;

	ArgInf.m_double = pow(ArgInf.m_double,pArg[1].m_double);

	__asm
	{
		mov eax,ArgInf.m_unit.m_dwFormID;
		mov edx,ArgInf.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_pstr.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
//ı - ָ뵽ı
/*
    øʽ ı͡ ָ뵽ı  ڴıָ룩 - ϵͳֿ֧->ı
    Ӣƣpstr
    ָڴַָָıעñǰһҪȷṩڴָʵЧָһַıʹóϾԻصӳDLLӳȡⲿݡΪ߼
    <1>Ϊڴıָ롱Ϊͣintṩָһַıڴֵָ
*/
LIBAPI(char*, krnln_pstr)
{
	if (!ArgInf.m_pText || !*(ArgInf.m_pText)) return NULL;
	int nLen = mystrlen(ArgInf.m_pText);
	if(nLen==0)	return NULL;

	char *pText = (char*)E_MAlloc_Nzero(nLen+1);
	
	memcpy(pText, ArgInf.m_pText, nLen);
	pText[nLen] = '\0';
	return pText;
}


================================================
FILE: krnln/krnln_randomize.cpp
================================================
#include "stdafx.h"
#include <math.h>
// - 
/*
    øʽ ޷ֵ   ֵݣ - ϵͳֿ֧->
    Ӣƣrandomize
    Ϊʼһֵֵͬ¡ȡزͬϵСΪ
    <1>ΪֵΪͣintԱʡԡʡԱĬʹõǰϵͳʱֵ
*/
LIBAPI(void, krnln_randomize)
{
	UINT unSeed;
	if(ArgInf.m_dtDataType==_SDT_NULL)
		unSeed = ::GetTickCount();
	else
		unSeed  = ArgInf.m_dwSubCodeAdr;
	srand(unSeed);

}


================================================
FILE: krnln/krnln_read.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
#include "Myfunctions.h"
#include <vector>

using namespace std;

//ļд - 
/*
	øʽ ߼͡   ݵļţͨͱ/ ݵı...  - ϵͳֿ֧->ļд
	Ӣƣread
	Ӧ롰дʹãļеǰдλöȡʽݵָһϵбСɹ棬ʧܷؼ١ΪмһԱظӡ
	<1>ΪݵļšΪͣintļɡļء
	<2>ΪݵıΪͨͣallṩʱֻṩ顣ΪûԶⶨͣʧܡ
*/
BOOL ReadFileTextData(HANDLE hFile, LPSTR& pStr, BOOL& bRet)
{
	char szBuff[4096];
	DWORD dwNumTop = 0;
	pStr = NULL;

	do
	{
		INT orgLoc = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
		if (orgLoc == HFILE_ERROR)
		{
			bRet = FALSE;
			return TRUE;
		}
		DWORD dwNumOfByteRead;
		if (ReadFile(hFile, szBuff, 4096, &dwNumOfByteRead, NULL) == FALSE)
		{
			bRet = FALSE;
			return TRUE;
		}
		INT nPos = 0;
		LPSTR pTemp = szBuff;
		BOOL bFind = FALSE;
		while (nPos < (INT)dwNumOfByteRead)
		{
			if (*pTemp == 0)
			{
				nPos++;
				bFind = TRUE;
				break;
			}
			pTemp++;
			nPos++;
		}
		INT nLoc = dwNumTop;
		dwNumTop += nPos;
		if (pStr)
			pStr = (LPSTR)E_MRealloc(pStr, dwNumTop + 1);
		else
			pStr = (LPSTR)E_MAlloc(dwNumTop + 1);
		pTemp = pStr + nLoc;
		strncpy(pTemp, szBuff, nPos);
		pTemp[nPos] = 0;

		if (bFind)//β
		{
			orgLoc += nPos;
			SetFilePointer(hFile, orgLoc, NULL, FILE_BEGIN);
			bRet = TRUE;
			return FALSE;
		}

		if (dwNumOfByteRead < 4096)
		{
			bRet = TRUE;
			break;
		}

	} while (1);

	return TRUE;

}

BOOL ReadFileBinData(HANDLE hFile, LPBYTE& pByte, BOOL& bRet)
{
	pByte = NULL;
	DWORD dwSize;
	DWORD dwNumOfByteRead;
	if (ReadFile(hFile, &dwSize, sizeof(INT), &dwNumOfByteRead, NULL))
	{
		if (dwNumOfByteRead < sizeof(INT))return TRUE;
		pByte = (LPBYTE)E_MAlloc(dwSize + 2 * sizeof(INT));

		if (ReadFile(hFile, pByte + 2 * sizeof(INT), dwSize, &dwNumOfByteRead, NULL))
		{
			LPINT p = (LPINT)pByte;
			p[0] = 1;
			p[1] = dwNumOfByteRead;
			if (dwNumOfByteRead == dwSize)
				return FALSE;
		}
		else
		{
			E_MFree(pByte);
			pByte = NULL;
		}
	}
	return TRUE;
}

BOOL ReadMemFileTextData(CMyMemFile* pMemFile, LPSTR& pStr)
{
	INT orgLoc = pMemFile->GetPosition();

	DWORD dwNumOfByteRead;
	INT nLen = -1;
	LPSTR pBufStart, pBufMax;

	dwNumOfByteRead = pMemFile->GetBufferPtr(CMyMemFile::bufferRead, nLen, (void**)&pBufStart, (void**)&pBufMax);

	pStr = pBufStart;
	nLen = 0;
	while (nLen < (INT)dwNumOfByteRead)
	{
		if (*pStr == 0)
		{
			orgLoc++;
			break;
		}
		nLen++;
		pStr++;
	}
	pStr = (LPSTR)E_MAlloc(nLen + 1);
	orgLoc += nLen;
	pMemFile->Seek(orgLoc, CMyMemFile::begin);
	strncpy(pStr, pBufStart, nLen);
	pStr[nLen] = 0;
	if (nLen == (INT)dwNumOfByteRead)
		return TRUE;
	return FALSE;
}

BOOL ReadMemFileBinData(CMyMemFile* pMemFile, LPBYTE& pByte)
{

	pByte = NULL;
	DWORD dwSize;
	DWORD dwNumOfByteRead = pMemFile->Read(&dwSize, sizeof(INT));
	if (dwNumOfByteRead < sizeof(INT))
		return TRUE;
	pByte = (LPBYTE)E_MAlloc(dwSize + 2 * sizeof(INT));
	dwNumOfByteRead = pMemFile->Read(pByte + 2 * sizeof(INT), dwSize);
	if (dwNumOfByteRead == 0)
	{
		E_MFree(pByte);
		pByte = NULL;
	}
	else
	{
		LPINT p = (LPINT)pByte;
		p[0] = 1;
		p[1] = dwNumOfByteRead;
		if (dwNumOfByteRead == dwSize)
			return FALSE;
	}

	return TRUE;

}
BOOL ReadFileTextData_Crypt(PFILEELEMENT pFile, LPSTR& pStr, BOOL& bRet)
{
	pStr = NULL;
	void* hFile = pFile->FileHandle;
	INT orgLoc = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
	if (orgLoc == HFILE_ERROR)
	{
		bRet = FALSE;
		return TRUE;
	}
	DWORD dwNumOfByteRead;
	INT nLen = GetFileSize(hFile, NULL) - orgLoc;
	vector<MEMSP> vecMEMSP;
	INT nTLen = 0;
	for (INT i = 0; i < nLen; i += 4096)
	{
		MEMSP tmpMEMSP;
		tmpMEMSP.pData = (char*)malloc(4096);
		INT nPos = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
		INT nRet = ReadFile(hFile, tmpMEMSP.pData, min(nLen - i, 4096), &dwNumOfByteRead, 0);
		if (nRet == FALSE)
		{
			SetFilePointer(hFile, 0, NULL, FILE_END);
			free(tmpMEMSP.pData);
			bRet = FALSE;
			break;
		}
		BOOL bFind = FALSE;
		E_RC4_Calc(nPos, (unsigned char*)tmpMEMSP.pData, dwNumOfByteRead, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
		for (DWORD j = 0; j < dwNumOfByteRead; j++)
		{
			if (tmpMEMSP.pData[j] == 0)
			{
				dwNumOfByteRead = j;
				orgLoc++;// ֽ
				bFind = TRUE;
				break;
			}
		}
		tmpMEMSP.nLen = dwNumOfByteRead;
		nTLen += dwNumOfByteRead;
		vecMEMSP.push_back(tmpMEMSP);
		if (bFind || dwNumOfByteRead != 4096)
			break;
	}
	if (nTLen > 0)
	{
		bRet = TRUE;
		pStr = (LPSTR)E_MAlloc_Nzero(nTLen + 1);
		orgLoc += nTLen;
		SetFilePointer(hFile, orgLoc, NULL, FILE_BEGIN);

		LPSTR pszRetold = pStr;
		vector<MEMSP>::iterator iterMEMSP;
		for (iterMEMSP = vecMEMSP.begin(); iterMEMSP != vecMEMSP.end(); iterMEMSP++)
		{
			memcpy(pszRetold, iterMEMSP->pData, iterMEMSP->nLen);
			pszRetold += iterMEMSP->nLen;
			free(iterMEMSP->pData);
		}
		pStr[nTLen] = 0;
	}
	else
		bRet = FALSE;

	vecMEMSP.clear();
	return !bRet;
}

BOOL ReadFileBinData_Crypt(PFILEELEMENT pFile, LPBYTE& pByte, BOOL& bRet)
{
	pByte = NULL;
	DWORD dwSize;
	DWORD dwNumOfByteRead;
	void* hFile = pFile->FileHandle;
	INT nPos = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
	if (ReadFile(hFile, &dwSize, sizeof(INT), &dwNumOfByteRead, NULL))
	{
		E_RC4_Calc(nPos, (unsigned char*)&dwSize, sizeof(INT), pFile->strTable, pFile->nCryptStart, pFile->strMD5);
		if (dwNumOfByteRead < sizeof(INT))
			return TRUE;

		pByte = (LPBYTE)E_MAlloc(dwSize + 2 * sizeof(INT));
		nPos = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);

		if (ReadFile(hFile, pByte + 2 * sizeof(INT), dwSize, &dwNumOfByteRead, NULL))
		{
			LPINT p = (LPINT)pByte;
			p[0] = 1;
			p[1] = dwNumOfByteRead;
			E_RC4_Calc(nPos, (unsigned char*)(pByte + 2 * sizeof(INT)), dwNumOfByteRead, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
			if (dwNumOfByteRead == dwSize)
				return FALSE;
		}
		else
		{
			E_MFree(pByte);
			pByte = NULL;
		}
	}
	return TRUE;
}

LIBAPI(BOOL, krnln_read)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if (pFile == NULL)
		return NULL;
	if (IsInFileMangerList(pFile) == FALSE)//Ϸ
		return NULL;
	PMDATA_INF pArgInf = &ArgInf;

	BOOL bRet = FALSE;
	BOOL bEof = FALSE;

	if (pFile->nType == 1 || pFile->nType == 3)//ļ ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		DWORD dwNumOfByteRead;
		bRet = TRUE;
		INT nPos;
		for (INT i = 1; i < nArgCount; i++)
		{
			if (bRet == FALSE)
				break;
			if ((pArgInf[i].m_dtDataType & DT_IS_ARY) == DT_IS_ARY)//
			{
				pArgInf[i].m_dtDataType &= ~DT_IS_ARY; //ȥ־

				if (pArgInf[i].m_ppAryData == NULL)//
					continue;

				if (pArgInf[i].m_dtDataType == SDT_TEXT)
				{
					DWORD dwSize;
					LPSTR* pAryData = (LPSTR*)GetAryElementInf(*pArgInf[i].m_ppAryData, dwSize);

					for (UINT n = 0; n < dwSize; n++)
					{
						if (pAryData[n])
							E_MFree(pAryData[n]);

						LPSTR pStr = NULL;
						if (bEof == FALSE)
						{
							if (pFile->nType == 3) //ļ
								bEof = ReadFileTextData_Crypt(pFile, pStr, bRet);
							else
								bEof = ReadFileTextData(hFile, pStr, bRet);
						}
						pAryData[n] = pStr;
						if (bRet == FALSE)
							break;
					}
				}
				else if (pArgInf[i].m_dtDataType == SDT_BIN)
				{
					DWORD dwSize;
					LPBYTE* pAryData = (LPBYTE*)GetAryElementInf(*pArgInf[i].m_ppAryData, dwSize);
					INT nData = 0;
					for (UINT n = 0; n < dwSize; n++)
					{
						if (pAryData[n])
							E_MFree(pAryData[n]);
						LPBYTE pByte = NULL;
						if (bEof == FALSE)
						{
							if (pFile->nType == 3) //ļ
								bEof = ReadFileBinData_Crypt(pFile, pByte, bRet);
							else
								bEof = ReadFileBinData(hFile, pByte, bRet);
						}
						pAryData[n] = pByte;

						if (bRet == FALSE)
							break;
					}
				}
				else {
					INT nLen = GetSysDataTypeDataSize(pArgInf[i].m_dtDataType);
					if (nLen == 0)//ֵ֧
						continue;
					DWORD dwSize;
					void* pData = GetAryElementInf(*pArgInf[i].m_ppAryData, dwSize);
					nLen *= dwSize;
					memset(pData, 0, nLen);

					if (bEof == FALSE)
					{
						nPos = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
						if (ReadFile(hFile, pData, nLen, &dwNumOfByteRead, NULL))
						{
							if (pFile->nType == 3) //ļ
								E_RC4_Calc(nPos, (unsigned char*)pData, dwNumOfByteRead, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
							if ((INT)dwNumOfByteRead < nLen)//β
								bEof = TRUE;
						}
						else
						{
							bRet = FALSE;
							break;
						}
					}
				}
			}
			else
			{//
				INT nLen;
				void* pData;
				INT nData = 0;
				if (pArgInf[i].m_dtDataType == SDT_TEXT)
				{
					if (pArgInf[i].m_ppText)
						E_MFree(*pArgInf[i].m_ppText);
					LPSTR pStr = NULL;
					if (bEof == FALSE)
					{
						if (pFile->nType == 3) // ļ
							bEof = ReadFileTextData_Crypt(pFile, pStr, bRet);
						else
							bEof = ReadFileTextData(hFile, pStr, bRet);
					}
					*pArgInf[i].m_ppText = pStr;

				}
				else if (pArgInf[i].m_dtDataType == SDT_BIN)
				{
					if (pArgInf[i].m_ppBin)
						E_MFree(*pArgInf[i].m_ppBin);
					LPBYTE pByte = NULL;
					if (bEof == FALSE)
					{
						if (pFile->nType == 3) // ļ
							bEof = ReadFileBinData_Crypt(pFile, pByte, bRet);
						else
							bEof = ReadFileBinData(hFile, pByte, bRet);
					}
					*pArgInf[i].m_ppBin = pByte;

				}
				else {
					nLen = GetSysDataTypeDataSize(pArgInf[i].m_dtDataType);
					if (nLen == 0)//ֵ֧
						continue;
					pData = pArgInf[i].m_pCompoundData;
					memset(pData, 0, nLen);
					if (bEof == FALSE)
					{
						DWORD dwByteTop;
						nPos = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
						if (ReadFile(hFile, pData, nLen, &dwByteTop, NULL))
						{
							if (pFile->nType == 3) //ļ
								E_RC4_Calc(nPos, (unsigned char*)pData, dwByteTop, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
							if (nLen > (INT)dwByteTop)//Ѿβ
								bEof = TRUE;
						}
						else
						{
							bRet = FALSE;
							break;
						}
					}
				}
			}
		}
	}
	else if (pFile->nType == 2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*)pFile->FileHandle;
		bRet = TRUE;
		for (INT i = 1; i < nArgCount; i++)
		{

			if ((pArgInf[i].m_dtDataType & DT_IS_ARY) == DT_IS_ARY)//
			{
				pArgInf[i].m_dtDataType &= ~DT_IS_ARY; //ȥ־

				if (pArgInf[i].m_ppAryData == NULL)//
					continue;

				if (pArgInf[i].m_dtDataType == SDT_TEXT)
				{
					DWORD dwSize;
					LPSTR* pAryData = (LPSTR*)GetAryElementInf(*pArgInf[i].m_ppAryData, dwSize);

					for (UINT n = 0; n < dwSize; n++)
					{
						if (pAryData[n])
							E_MFree(pAryData[n]);

						LPSTR pStr = NULL;
						if (bEof == FALSE)
							bEof = ReadMemFileTextData(pMemFile, pStr);
						pAryData[n] = pStr;
					}
				}
				else if (pArgInf[i].m_dtDataType == SDT_BIN)
				{
					DWORD dwSize;
					LPBYTE* pAryData = (LPBYTE*)GetAryElementInf(*pArgInf[i].m_ppAryData, dwSize);
					INT nData = 0;
					for (UINT n = 0; n < dwSize; n++)
					{
						if (pAryData[n])
							E_MFree(pAryData[n]);
						LPBYTE pByte = NULL;
						if (bEof == FALSE)
							bEof = ReadMemFileBinData(pMemFile, pByte);
						pAryData[n] = pByte;
					}
				}
				else {
					INT nLen = GetSysDataTypeDataSize(pArgInf[i].m_dtDataType);
					if (nLen == 0)//ֵ֧
						continue;
					DWORD dwSize;
					void* pData = GetAryElementInf(*pArgInf[i].m_ppAryData, dwSize);
					nLen *= dwSize;
					memset(pData, 0, nLen);

					if (bEof == FALSE)
					{
						DWORD dwByteTop = pMemFile->Read(pData, nLen);
						if (nLen > (INT)dwByteTop)//Ѿβ
							bEof = TRUE;
					}
				}
			}
			else
			{//
				INT nLen;
				void* pData;
				INT nData = 0;
				if (pArgInf[i].m_dtDataType == SDT_TEXT)
				{
					if (pArgInf[i].m_ppText)
						E_MFree(*pArgInf[i].m_ppText);
					LPSTR pStr = NULL;
					if (bEof == FALSE)
						bEof = ReadMemFileTextData(pMemFile, pStr);
					*pArgInf[i].m_ppText = pStr;

				}
				else if (pArgInf[i].m_dtDataType == SDT_BIN)
				{
					if (pArgInf[i].m_ppBin)
						E_MFree(*pArgInf[i].m_ppBin);
					LPBYTE pByte = NULL;
					if (bEof == FALSE)
						bEof = ReadMemFileBinData(pMemFile, pByte);
					*pArgInf[i].m_ppBin = pByte;

				}
				else {

					nLen = GetSysDataTypeDataSize(pArgInf[i].m_dtDataType);
					if (nLen == 0)//ֵ֧
						continue;
					pData = pArgInf[i].m_pCompoundData;
					memset(pData, 0, nLen);
					if (bEof == FALSE)
					{
						DWORD dwByteTop = pMemFile->Read(pData, nLen);
						if (nLen > (INT)dwByteTop)//Ѿβ
							bEof = TRUE;
					}
				}
			}
		}
	}
	else if (pFile->nType == 3) //ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		DWORD dwNumOfByteRead;
		bRet = TRUE;
		for (INT i = 1; i < nArgCount; i++)
		{
			if (bRet == FALSE)
				break;
			if ((pArgInf[i].m_dtDataType & DT_IS_ARY) == DT_IS_ARY)//
			{
				pArgInf[i].m_dtDataType &= ~DT_IS_ARY; //ȥ־

				if (pArgInf[i].m_ppAryData == NULL)//
					continue;

				if (pArgInf[i].m_dtDataType == SDT_TEXT)
				{
					DWORD dwSize;
					LPSTR* pAryData = (LPSTR*)GetAryElementInf(*pArgInf[i].m_ppAryData, dwSize);

					for (UINT n = 0; n < dwSize; n++)
					{
						if (pAryData[n])
							E_MFree(pAryData[n]);

						LPSTR pStr = NULL;
						if (bEof == FALSE)
							bEof = ReadFileTextData(hFile, pStr, bRet);
						pAryData[n] = pStr;
						if (bRet == FALSE)
							break;
					}
				}
				else if (pArgInf[i].m_dtDataType == SDT_BIN)
				{
					DWORD dwSize;
					LPBYTE* pAryData = (LPBYTE*)GetAryElementInf(pArgInf[i].m_pAryData, dwSize);
					INT nData = 0;
					for (UINT n = 0; n < dwSize; n++)
					{
						if (pAryData[n])
							E_MFree(pAryData[n]);
						LPBYTE pByte = NULL;
						if (bEof == FALSE)
							bEof = ReadFileBinData(hFile, pByte, bRet);
						pAryData[n] = pByte;

						if (bRet == FALSE)
							break;
					}
				}
				else {
					INT nLen = GetSysDataTypeDataSize(pArgInf[i].m_dtDataType);
					if (nLen == 0)//ֵ֧
						continue;
					DWORD dwSize;
					void* pData = GetAryElementInf(*pArgInf[i].m_ppAryData, dwSize);
					nLen *= dwSize;
					memset(pData, 0, nLen);

					if (bEof == FALSE)
					{
						if (ReadFile(hFile, pData, nLen, &dwNumOfByteRead, NULL))
						{
							if ((INT)dwNumOfByteRead < nLen)//β
								bEof = TRUE;
						}
						else
						{
							bRet = FALSE;
							break;
						}
					}
				}
			}
			else
			{//
				INT nLen;
				void* pData;
				INT nData = 0;
				if (pArgInf[i].m_dtDataType == SDT_TEXT)
				{
					if (pArgInf[i].m_ppText)
						E_MFree(*pArgInf[i].m_ppText);
					LPSTR pStr = NULL;
					if (bEof == FALSE)
						bEof = ReadFileTextData(hFile, pStr, bRet);
					*pArgInf[i].m_ppText = pStr;

				}
				else if (pArgInf[i].m_dtDataType == SDT_BIN)
				{
					if (pArgInf[i].m_ppBin)
						E_MFree(*pArgInf[i].m_ppBin);
					LPBYTE pByte = NULL;
					if (bEof == FALSE)
						bEof = ReadFileBinData(hFile, pByte, bRet);
					*pArgInf[i].m_ppBin = pByte;

				}
				else {
					nLen = GetSysDataTypeDataSize(pArgInf[i].m_dtDataType);
					if (nLen == 0)//ֵ֧
						continue;
					pData = pArgInf[i].m_pCompoundData;
					memset(pData, 0, nLen);
					if (bEof == FALSE)
					{
						DWORD dwByteTop;
						if (ReadFile(hFile, pData, nLen, &dwByteTop, NULL))
						{
							if (nLen > (INT)dwByteTop)//Ѿβ
								bEof = TRUE;
						}
						else
						{
							bRet = FALSE;
							break;
						}
					}
				}
			}
		}
	}
	return bRet;
}


================================================
FILE: krnln/krnln_reset.cpp
================================================
#include "stdafx.h"

//ļд - رļ
/*
    øʽ ޷ֵ رļ  - ϵͳֿ֧->ļд
    Ӣƣreset
    رб򿪵ļΪ
*/
extern PFILEELEMENT pFileList;

LIBAPI(void, krnln_reset)
{
	if(pFileList)
		ResetFileIO();
}


================================================
FILE: krnln/krnln_rgb.cpp
================================================
#include "stdafx.h"

// - ȡɫֵ
/*
    øʽ ͡ ȡɫֵ  ɫ ɫ ɫ - ϵͳֿ֧->
    Ӣƣrgb
    һʾһɫֵΪ
    <1>ΪɫΪͣintֵΧ 0  255ʾɫеĺɫɷݡ
    <2>ΪɫΪͣintֵΧ 0  255ʾɫеɫɷݡ
    <3>ΪɫΪͣintֵΧ 0  255ʾɫеɫɷݡ
*/
LIBAPI(int, krnln_rgb)
{
	PMDATA_INF pArgInf = &ArgInf;

	return RGB(pArgInf[0].m_int,pArgInf[1].m_int,pArgInf[2].m_int);
}


================================================
FILE: krnln/krnln_right.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
//ı - ȡıұ
/*
    øʽ ı͡ ȡıұ ı ȡ䲿ֵı ȡַĿ - ϵͳֿ֧->ı
    Ӣƣright
    һıаָıдұַָΪ
    <1>Ϊȡ䲿ֵıΪıͣtext
    <2>ΪȡַĿΪͣint
*/
LIBAPI(char*, krnln_right)
{// ߺ 
	PMDATA_INF pArgInf = &ArgInf;
	INT nSubLen = pArgInf[1].m_int;
	if (nSubLen <= 0) 
		return NULL;
	INT nLen = mystrlen(ArgInf.m_pText);
	if (nLen == 0) 
		return NULL;
	if (nSubLen > nLen)
		nSubLen = nLen;
	char* pText = (char*)E_MAlloc_Nzero(nSubLen + 1);
	memcpy(pText, ArgInf.m_pText + (nLen - nSubLen), nSubLen + 1);
	return pText;
}
// {ԭ
// 	PMDATA_INF pArgInf = &ArgInf;
// 	UINT nLen = strlen(ArgInf.m_pText);
// 	if(nLen==0 || pArgInf[1].m_int <=0)return NULL;
// 
// 	INT nOffset = nLen - pArgInf[1].m_int;
// 	if(nOffset < 0)
// 		nOffset = 0;
// 	char* pSrc = ArgInf.m_pText + nOffset;
// 	nLen = strlen(pSrc);
// 
// 	char *pText = (char*)E_MAlloc(nLen+1);
// 	strcpy(pText,pSrc);
// 	return pText;	
// }


================================================
FILE: krnln/krnln_rnd.cpp
================================================
#include "stdafx.h"
#include "limits.h"
#define XCHG(x, y) {x = x^y; y = x^y; x = x^y;}

// - ȡ
/*
    øʽ ͡ ȡ  ȡСֵݣ ȡֵݣ - ϵͳֿ֧->
    Ӣƣrnd
    һָΧڵֵʹñȡһϵе֮ǰӦʹáӡΪʼһֵΪ
    <1>ΪȡСֵΪͣintԱʡԡڻ㡣ʡԣĬΪ 0 
    <2>ΪȡֵΪͣintԱʡԡڻ㡣ʡԣĬΪޡ
*/
LIBAPI(int, krnln_rnd)
{
	PMDATA_INF pArg = &ArgInf;

	register int nMin;
	register int nMax;

	// check for min value
	if (pArg[0].m_dtDataType != _SDT_NULL)
		nMin = pArg[0].m_int < 0 ? 0 : pArg[0].m_int;
	else nMin = 0;

	// check for max value
	if (pArg[1].m_dtDataType != _SDT_NULL)
		nMax = pArg[1].m_int < 0 ? 0 : pArg[1].m_int;
	else nMax = INT_MAX;

	// if min bigger than max
	// xchg them
	if(nMin > nMax)
		XCHG(nMin, nMax);
	
	return nMin + (rand() % (nMax - nMin + 1));

}


================================================
FILE: krnln/krnln_round.cpp
================================================
#include "stdafx.h"
#include <math.h>
//#include <stdio.h>
// - 
/*
    øʽ ˫С͡  ˫С ֵ λãݣ - ϵͳֿ֧->
    Ӣƣround
    ذָķʽĽֵΪ
    <1>ΪֵΪ˫Сͣdouble
    <2>ΪλáΪͣintԱʡԡ0ʾСұӦλ0ʾ뵽С0ʾС뵽λá磺 (1056.65, 1)  1056.7  (1056.65, 0)  1057  (1056.65, -1)  1060ʡԱĬΪ0
*/

double round(double x)
{
	return floor(x+0.5);
}

LIBAPI(void, krnln_round)
{
	PMDATA_INF pArg = &ArgInf;

	INT n;
	if(pArg[1].m_dtDataType == _SDT_NULL)
		n = 0;
	else
		n = pArg[1].m_int;
	if(n==0)
		ArgInf.m_double = round(ArgInf.m_double);
	else if(n>0)
	{
		double dbNum = pow((double)10.0, n);
		ArgInf.m_double = ArgInf.m_double * dbNum;

		ArgInf.m_double = round(ArgInf.m_double)/dbNum;

	}else
	{
		n = abs(n);
		double dbNum = pow((double)10.0, n);
		ArgInf.m_double = ArgInf.m_double / dbNum;
		ArgInf.m_double = round(ArgInf.m_double)* dbNum;
	}
	/*
		char str [100];

			sprintf(str,"%lf",(ArgInf.m_double));
MessageBox(NULL,str,NULL,MB_OK);
*/

	__asm
	{
		mov eax,ArgInf.m_unit.m_dwFormID;
		mov edx,ArgInf.m_unit.m_dwUnitID;
	}

}


================================================
FILE: krnln/krnln_run.cpp
================================================
#include "stdafx.h"

//ϵͳ - 
/*
    øʽ ߼͡  ı еУ߼ Ƿȴϣ г򴰿ʾʽݣ - ϵͳֿ֧->ϵͳ
    Ӣƣrun
    ָĿִļⲿɹ棬򷵻ؼ١Ϊ
    <1>ΪеСΪıͣtext
    <2>ΪǷȴϡΪ߼ͣboolʼֵΪ١
    <3>Ϊг򴰿ʾʽΪͣintԱʡԡֵΪ³֮һ
	1#شڣ 2#ͨ 3#С 4#󻯼 5#ͨ 6#СʡԱĬΪͨʽ
*/
LIBAPI(BOOL, krnln_run)
{
	PMDATA_INF pArgInf = &ArgInf;

	STARTUPINFO startupinfo;
	PROCESS_INFORMATION pinfo;

	startupinfo.cb=sizeof(STARTUPINFO);
	GetStartupInfo(&startupinfo);
	startupinfo.hStdOutput=NULL;
	startupinfo.hStdError=NULL;
	startupinfo.dwFlags=STARTF_USESHOWWINDOW;

	if(pArgInf[2].m_dtDataType != _SDT_NULL)
	{

		switch(pArgInf[2].m_int)
		{
		case 1:
			startupinfo.wShowWindow=SW_HIDE;
			break;
		case 3:
			startupinfo.wShowWindow = SW_SHOWMINIMIZED;
			break;
		case 4:
			startupinfo.wShowWindow = SW_SHOWMAXIMIZED;
			break;	
		case 5:
			startupinfo.wShowWindow = SW_SHOWNOACTIVATE;
			break;	
		case 6:
			startupinfo.wShowWindow = SW_SHOWMINNOACTIVE;
			break;		
		default:
			startupinfo.wShowWindow = SW_SHOW;
			
		}
	}
	else
		startupinfo.wShowWindow = SW_SHOW;

	
	// Create process
	BOOL bRet = CreateProcess(NULL,pArgInf->m_pText,NULL,NULL,TRUE,NULL,NULL,NULL,&startupinfo,&pinfo);
	if(bRet)
	{
		if(pArgInf[1].m_bool)
			WaitForSingleObject(pinfo.hProcess, INFINITE);
		CloseHandle(pinfo.hProcess);
		CloseHandle(pinfo.hThread);
	}

	return bRet;
}


================================================
FILE: krnln/krnln_second.cpp
================================================
#include "stdafx.h"
#include <math.h>
//ʱ - ȡ
/*
    øʽ ͡ ȡ ʱ ʱ䣩 - ϵͳֿ֧->ʱ
    Ӣƣsecond
    һֵΪ 0  59 ֮ʾһеijһ롣Ϊ
    <1>Ϊʱ䡱Ϊʱͣdate
*/
LIBAPI(int, krnln_second)
{
	INT nHour, nMinute, nSecond;
	GetTimePart(ArgInf.m_date ,nHour, nMinute, nSecond);
	return nSecond;
}


================================================
FILE: krnln/krnln_sgn.cpp
================================================
#include "stdafx.h"

// - ȡ
/*
    øʽ ͡ ȡ ˫С ȡŵֵ - ϵͳֿ֧->
    Ӣƣsgn
    һС㣬ֵΪ㣬ֵΪ㣻㣬ֵΪΪ
    <1>ΪȡŵֵΪ˫Сͣdouble
*/
LIBAPI(int, krnln_sgn)
{
	int n = 0;
	if(ArgInf.m_double>0)
		n = 1;
	else if(ArgInf.m_double<0)
		n = -1;
	return n;
}


================================================
FILE: krnln/krnln_shl.cpp
================================================
#include "stdafx.h"

//λ - 
/*
    øʽ ͡   ƶ ƶλ - ϵͳֿ֧->λ
    Ӣƣshl
    ijλָλƶĽΪм
    <1>ΪƶΪͣint
    <2>ΪƶλΪͣint
*/
LIBAPI(int, krnln_shl)
{
	PMDATA_INF pArg = &ArgInf;
	int n = pArg->m_int << pArg[1].m_int;

	return n;
}


================================================
FILE: krnln/krnln_shr.cpp
================================================
#include "stdafx.h"

//λ - 
/*
    øʽ ͡   ƶ ƶλ - ϵͳֿ֧->λ
    Ӣƣshr
    ijλָλƶĽΪм
    <1>ΪƶΪͣint
    <2>ΪƶλΪͣint
*/
LIBAPI(int, krnln_shr)
{
	PMDATA_INF pArg = &ArgInf;
	int n = pArg->m_int >> pArg[1].m_int;

	return n;
}


================================================
FILE: krnln/krnln_sin.cpp
================================================
#include "stdafx.h"
#include <math.h>

// - 
/*
    øʽ ˫С͡  ˫С мĽǣ - ϵͳֿ֧->
    Ӣƣsin
    ָǵֵΪ
    <1>ΪмĽǡΪ˫СͣdoubleʹõλΪȡΪ˽Ƕתɻȣ뽫Ƕȳ #pi / 180Ϊ˽תɽǶȣ뽫ȳ 180 / #piֵڵ 2  63 ηСڵ -2  63 η¼
*/
LIBAPI(void, krnln_sin)
{

	ArgInf.m_double = sin(ArgInf.m_double);
	__asm
	{
		mov eax,ArgInf.m_unit.m_dwFormID;
		mov edx,ArgInf.m_unit.m_dwUnitID;
	}

}


================================================
FILE: krnln/krnln_sleep.cpp
================================================
#include "stdafx.h"

//ϵͳ - ʱ
/*
    øʽ ޷ֵ ʱ  ȴʱ䣩 - ϵͳֿ֧->ϵͳ
    Ӣƣsleep
    ͣǰвȴָʱ䡣Ϊ
    <1>Ϊȴʱ䡱Ϊͣintִָͣеʱ䣬λΪ롣
*/
LIBAPI(void, krnln_sleep)
{
	if (ArgInf.m_int <= 0)
		return;
	
	Sleep(ArgInf.m_int);
}


================================================
FILE: krnln/krnln_space.cpp
================================================
#include "stdafx.h"

//ı - ȡհı
/*
    øʽ ı͡ ȡհı  ظ - ϵͳֿ֧->ı
    Ӣƣspace
    ؾָĿǿոıΪ
    <1>ΪظΪͣint
*/
LIBAPI(char*, krnln_space)
{
	if(ArgInf.m_int<= 0) return NULL;
	char *pText = (char*)E_MAlloc_Nzero(ArgInf.m_int+1);
	memset(pText,32,ArgInf.m_int);
	pText[ArgInf.m_int]=0;
	return pText;	
}


================================================
FILE: krnln/krnln_split.cpp
================================================
#include "stdafx.h"
#include "mem.h"
#include "Myfunctions.h"


//ı - ָı
/*
    øʽ ı页 ָı ı ָıı ָıݣ ҪصıĿݣ - ϵͳֿ֧->ı
    Ӣƣsplit
    ָıзָطָһάı顣Ϊ
    <1>ΪָıΪıͣtextֵһΪı򷵻һ飬ûκγԱ顣
    <2>ΪָıΪıͣtextԱʡԡֵڱʶı߽硣ʡԣĬʹðǶַΪָһΪı򷵻صһԱġָı
    <3>ΪҪصıĿΪͣintԱʡԡʡԣĬϷеı

*/
#define IS_CC(p) p<0

LIBAPI(void*, krnln_split)
{// ߺ 
	PMDATA_INF pArgInf = &ArgInf;
	INT nCount = pArgInf [2].m_dtDataType == _SDT_NULL ? 0x7FFFFFFF : pArgInf [2].m_int;
	LPBYTE p;
	if (nCount <= 0) 
		return E_NULLARRAY();

	char* pSub = pArgInf [1].m_dtDataType == _SDT_NULL ? (LPSTR)"," : pArgInf [1].m_pText;
	INT nSubLen = mystrlen(pSub);

	char* pSrc = pArgInf[0].m_pText;
	if (!pSrc || !*pSrc)
		return E_NULLARRAY();

	if (nSubLen==0)
		nCount = -1;//һԱ

	// ʼ
	TBR tbr;
	INT nPos;
	char* pFirst = pSrc;
	char* cp = pSrc;
	for (; nCount > 0; nCount--)
	{
		nPos = mystrstr((char*)cp, (char*)pSub);
		if (nPos == -1)
			break;
		cp += nPos;
		tbr.add(pFirst, cp - pFirst);
		cp += nSubLen;
		pFirst = cp;
	}
	
	INT nSlen = mystrlen(cp) + cp - pSrc;
	char* pLast = pSrc + nSlen;
	if (pLast - pFirst > 0 && nCount != 0)
		tbr.add(pFirst, pLast - pFirst);

	// ݡ
	nCount = tbr.m_nCount;
	INT nSize = nCount * sizeof (DWORD);
	p = (LPBYTE)E_MAlloc_Nzero (sizeof (INT) * 2 + nSize);
	*(LPINT)p = 1;  // ά
	*(LPINT)(p + sizeof (INT)) = nCount;
	LPINT pp = (LPINT)(p + 2*sizeof(INT));
	for (int i=0; i < nCount; i++)
	{
		*pp = (INT)CloneTextData((char*)(tbr.m_data[i].addr), tbr.m_data[i].len);
		pp++;
	}
	return p;  // 顣
}



================================================
FILE: krnln/krnln_sqr.cpp
================================================
#include "stdafx.h"
#include <math.h>
// - ƽ
/*
    øʽ ˫С͡ ƽ ˫С ƽֵ - ϵͳֿ֧->
    Ӣƣsqr
    ָƽΪ
    <1>ΪƽֵΪ˫СͣdoubleֵС㽫¼
*/
LIBAPI(void, krnln_sqr)
{
	PMDATA_INF pArg = &ArgInf;

	ArgInf.m_double = sqrt(ArgInf.m_double);

	__asm
	{
		mov eax,ArgInf.m_unit.m_dwFormID;
		mov edx,ArgInf.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_str.cpp
================================================
#include "stdafx.h"
#include <stdio.h>
#include "LTrimZeroChr.h"
#include "Myfunctions.h"

//#pragma comment(lib,"oleaut32.lib") 

//ı - ı
/*
    øʽ ı͡ ı ͨ/ תݣ - ϵͳֿ֧->ı
    Ӣƣstr
    һıֵָ߼ֵʱ䱻תĽΪıݣֱӷءΪ
    <1>ΪתݡΪͨͣallṩʱͬʱṩݡֵֻΪֵ߼ֵֽڼʱֵ顣
*/
char * ArryToString(void* pArry,DWORD szData)
{
	DWORD dwSize;
	char* pText = (char*)GetAryElementInf(pArry,dwSize);
	if(dwSize==0)
		return NULL;
	INT nMax = dwSize * szData;
	INT i;
	for(i=0;i<nMax;i++)
	{
		if(pText[i]==0)
			break;
	}
	UINT nLen = i;

	if(nLen==0)return NULL;
	char* pNewText = (char*)E_MAlloc_Nzero(nLen+1);
	memcpy(pNewText,pText,nLen);
	pNewText[nLen] = 0;
	return pNewText;

}

LIBAPI(char*, krnln_str)
{

	char * pText = NULL;
	if((ArgInf.m_dtDataType & DT_IS_ARY) == DT_IS_ARY)//
	{
		ArgInf.m_dtDataType &=~DT_IS_ARY; //ȥ־
		DWORD szData = 0;
		switch(ArgInf.m_dtDataType)
		{
		case SDT_BYTE:
			szData = sizeof(BYTE);
			break;
		case SDT_SHORT:
			szData = sizeof(SHORT);
			break;
		case SDT_INT64:
			szData = sizeof(INT64);
			break;
		case SDT_INT:
		case SDT_SUB_PTR:
			szData = sizeof(DWORD);
			break;
		}
		if(szData)
			pText = ArryToString(ArgInf.m_pAryData,szData);
	}
	else
	{
		char str [MAX_PATH];
		int nLen = 0;
		char* pSrc = NULL;

		switch(ArgInf.m_dtDataType)
		{
		case SDT_TEXT:
			nLen = mystrlen(ArgInf.m_pText);
			if(nLen)
				pSrc = ArgInf.m_pText;
			break;
		case SDT_BYTE:
			{
				INT nVal = ArgInf.m_byte;
				sprintf(str,"%d",nVal);
				nLen = mystrlen(str);
				pSrc = str;
			}
			break;
		case SDT_SHORT:
			{
				INT nVal = ArgInf.m_short;
				sprintf(str,"%d",nVal);
				nLen = mystrlen(str);
				pSrc = str;
			}
			break;
		case SDT_INT:
		case SDT_SUB_PTR:
			sprintf(str,"%d",ArgInf.m_int);
			nLen = mystrlen(str);
			pSrc = str;
			break;
		case SDT_INT64:
			sprintf(str,"%I64d",ArgInf.m_int64);
			nLen = mystrlen(str);
			pSrc = str;
			break;
		case SDT_FLOAT:
			sprintf(str,"%f",ArgInf.m_float);
			LTrimZeroChr(str);
			nLen = mystrlen(str);
			pSrc = str;
			break;
		case SDT_DOUBLE:
			sprintf(str,"%.13g",ArgInf.m_double);
			LTrimZeroChr(str);
			nLen = mystrlen(str);
			pSrc = str;
			break;
		case SDT_BOOL:
			if(ArgInf.m_bool)
				strcpy(str,"");
			else
				strcpy(str,"");
			nLen = mystrlen(str);
			pSrc = str;
			break;
		case SDT_BIN:
			pText = ArryToString(ArgInf.m_pBin,sizeof(BYTE));
			break;
		case SDT_DATE_TIME:
			DateTimeFormat(str,ArgInf.m_double);
			nLen = mystrlen(str);
			if(nLen)
				pSrc = str;
			break;
		}
		if(pSrc && nLen)
		{
			pText = (char*)E_MAlloc_Nzero(nLen+1);
			strcpy(pText,pSrc);
		}

	}
	return pText;
}


================================================
FILE: krnln/krnln_string.cpp
================================================
#include "stdafx.h"
#include "Myfunctions.h"
//ı - ȡظı
/*
    øʽ ı͡ ȡظı  ظı ظı - ϵͳֿ֧->ı
    Ӣƣstring
    һıаָıظΪ
    <1>ΪظΪͣint
    <2>ΪظıΪıͣtextıڽصıΪգһı
*/
LIBAPI(char*, krnln_string)
{
	PMDATA_INF pArgInf = &ArgInf;
	INT nLen = mystrlen(pArgInf[1].m_pText);
	if(nLen == 0 || ArgInf.m_int <=0 ) return NULL;

	INT nBuf = nLen * ArgInf.m_int;
	char *pText = (char*)E_MAlloc_Nzero(nBuf+1);
	char* pDest = pText;
	for(INT i=0;i< ArgInf.m_int;i++)
	{
		strncpy(pDest,pArgInf[1].m_pText,nLen);
		pDest+=nLen;
	}
	*pDest = 0;
	return pText;
}


================================================
FILE: krnln/krnln_tan.cpp
================================================
#include "stdafx.h"
#include <math.h>
// - 
/*
    øʽ ˫С͡  ˫С мĽǣ - ϵͳֿ֧->
    Ӣƣtan
    ָǵֵΪ
    <1>ΪмĽǡΪ˫СͣdoubleʹõλΪȡΪ˽Ƕתɻȣ뽫Ƕȳ #pi / 180Ϊ˽תɽǶȣ뽫ȳ 180 / #piֵڵ 2  63 ηСڵ -2  63 η¼
*/
LIBAPI(void, krnln_tan)
{
	ArgInf.m_double = tan(ArgInf.m_double);
	__asm
	{
		mov eax,ArgInf.m_unit.m_dwFormID;
		mov edx,ArgInf.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_trim.cpp
================================================
#include "stdafx.h"

//ı - ɾβ
/*
    øʽ ı͡ ɾβ ı ɾոı - ϵͳֿ֧->ı
    Ӣƣtrim
    һıаɾײβȫǻǿոָıΪ
    <1>ΪɾոıΪıͣtext
*/
LIBAPI(char*, krnln_trim)
{
	PMDATA_INF pArgInf = &ArgInf;
	char* pSrc = pArgInf[0].m_pText;
	register char *str1 = pSrc;

	//׿
	while ( *str1 )
	{
		if (*str1 == ' ')
			str1++;
		else if (*((unsigned short*)str1) == 0xA1A1)
			str1+=2;
		else
			break;
	}
	if (!*str1) return NULL; //ıֱӷ
	pSrc = str1;
	//β
	register char* pLastNS = NULL;
	while ( *str1 )
	{
		if (*((unsigned short*)str1) == 0xA1A1)
			str1++;
		else
		{
			if (*str1 != ' ')
			{
				if (*str1 < 0)
				{	
					pLastNS = str1 + 1;
					str1++;
				}else{
					pLastNS = str1;
				}
			}
		}
		str1++;
	}
	if (!pLastNS) return NULL; //ıֱӷ

	INT nLen = pLastNS - pSrc + 1;
	char *pText = (char*)E_MAlloc_Nzero(nLen+1);
	memcpy(pText, pSrc, nLen);
	pText[nLen] = '\0';
	return pText;
}
// {
// 	char *pText = krnln_LTrim(1,ArgInf);
// 	if(pText==NULL)return NULL;
// 
// 	INT nLen = strlen(pText);
// 
// 	char* pSrc = pText + nLen - 1;
// 	while(pSrc >= pText)
// 	{
// 		if(*pSrc == ' ' || (*pSrc == -95 && *(pSrc-1) == -95))
// 		{
// 			if(*pSrc< 0)
// 			{
// 				pSrc-=2;
// 			}
// 			else
// 			{
// 				pSrc--;
// 			}
// 		}
// 		else
// 		{
// 			pSrc++;
// 			*pSrc = 0;
// 
// 			break;
// 		}
// 
// 	}
// 	nLen = strlen(pText);
// 	if(nLen == 0)
// 	{
// 		E_MFree(pText);
// 		pText = NULL;
// 	}
// 	return pText;
// }


================================================
FILE: krnln/krnln_val.cpp
================================================
#include "stdafx.h"

//ֵת - ֵ
/*
    øʽ ˫С͡ ֵ ͨ תıֵ - ϵͳֿ֧->ֵת
    Ӣƣval
    ذıڵֵıһʵ͵ֵ֧ȫдʽҲ͵תΪ˫СΪ
    <1>ΪתıֵΪͨͣall
*/
LIBAPI(void, krnln_val)
{
	switch(ArgInf.m_dtDataType)
	{
	case SDT_BYTE:
		{
			INT nVal = ArgInf.m_byte;
			ArgInf.m_double = nVal;
		}
		break;
	case SDT_SHORT:
		{
			INT nVal = ArgInf.m_short;
			ArgInf.m_double = nVal;
		}
		break;
	case SDT_TEXT:
		{
			char* pStr = krnln_BJCase(1,ArgInf);
			if(pStr)
			{
				ArgInf.m_double = strtod(pStr,NULL);
				E_MFree(pStr);
			}
			else
				ArgInf.m_double = 0;
			//ArgInf.m_double = strtod(ArgInf.m_pText,NULL);
		}
		break;
	case SDT_DATE_TIME:
	case SDT_DOUBLE:
		break;
	case SDT_FLOAT:
		{
			FLOAT floatval = ArgInf.m_float;
			ArgInf.m_double = floatval;
		}
		break;
	case SDT_INT64:
		{
			INT64 int64 = ArgInf.m_int64;
			ArgInf.m_double = (DOUBLE)int64;
		}
		break;
	default:
		{
			INT nVal = ArgInf.m_int;
			ArgInf.m_double = nVal;//10011
		}
	}
	__asm{
		mov eax, ArgInf.m_unit.m_dwFormID;
		mov edx, ArgInf.m_unit.m_dwUnitID;
	}
}


================================================
FILE: krnln/krnln_write.cpp
================================================
#include "stdafx.h"
#include "MyMemFile.h"
#include "Myfunctions.h"

//ļд - д
/*
    øʽ ߼͡ д  дݵļţͨ/ дݣ...  - ϵͳֿ֧->ļд
    Ӣƣwrite
    Ӧ롰롱ʹãдһϵбĸʽݵļеǰдλôɹ棬ʧܷؼ١
ݵдʽΪ
  1ֵ͡߼͡ʱ͡ӳָͣ ΪӦʵݣ
  2ıͣ   Ϊı + ֽ 0 
  3ֽڼͣ Ϊֽڼݳȣ + ֽڼʵݣ
  4ϸ͵ݣ Ϊݸʽ˳СΪмһԱظӡ
    <1>ΪдݵļšΪͣintļɡļء
    <2>ΪдݡΪͨͣallṩʱͬʱṩݡдݵΪûԶⶨͣʧܡ
*/
LIBAPI(BOOL, krnln_write)
{
	PFILEELEMENT pFile = (PFILEELEMENT)ArgInf.m_pCompoundData;
	if(pFile==NULL)
		return NULL;
	if(IsInFileMangerList(pFile)==FALSE)//Ϸ
		return NULL;
	PMDATA_INF pArgInf = &ArgInf;

	BOOL bRet = FALSE;

	if(pFile->nType ==1 || pFile->nType == 3)//ļ ļ
	{
		HANDLE hFile = (HANDLE)pFile->FileHandle;
		DWORD dwNumOfByteRead;
		bRet = TRUE;
		INT nPos;
		for(INT i=1;i < nArgCount;i++)
		{
			if(bRet == FALSE)
				break;
			if((pArgInf[i].m_dtDataType & DT_IS_ARY) == DT_IS_ARY)//
			{
				pArgInf[i].m_dtDataType &=~DT_IS_ARY; //ȥ־
				if(pArgInf[i].m_dtDataType==SDT_TEXT)
				{
					DWORD dwSize;
					LPSTR* pAryData = (LPSTR*)GetAryElementInf(pArgInf[i].m_pAryData,dwSize);
					INT nData = 0;
					for(UINT n=0;n<dwSize;n++)
					{
						INT nLen;
						void* pData;
						if(pAryData[n]==NULL)
						{
							nLen = 1;
							pData = &nData;
						}
						else
						{
							nLen = mystrlen(pAryData[n])+1;
							pData = pAryData[n];
						}
						void *pTMP = NULL;
						if (pFile->nType == 3) //ļ
						{
							pTMP = malloc(nLen);
							memcpy(pTMP, pData, nLen);
							nPos = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
							E_RC4_Calc(nPos, (unsigned char*)pTMP, nLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
							pData = pTMP;
						}
						if(WriteFile(hFile,pData,nLen,&dwNumOfByteRead,NULL))
						{
//							if(FlushFileBuffers(hFile)==FALSE)
//								bRet = FALSE;
						}
						else
							bRet = FALSE;
						
						if (pTMP)
						{
							free(pTMP);
							pTMP = NULL;
						}

						if(bRet == FALSE)
							break;
					}


				}else if(pArgInf[i].m_dtDataType==SDT_BIN)
				{
					DWORD dwSize;
					LPINT* pAryData = (LPINT*)GetAryElementInf(pArgInf[i].m_pAryData,dwSize);
					INT nData = 0;
					for(UINT n=0;n<dwSize;n++)
					{
						void* pData;
						INT nLen;
						if(pAryData[n]==NULL)
						{
							pData = &nData;
							nLen = sizeof(INT);
						}
						else
						{
							LPINT p = pAryData[n];
							nLen = p[1]+sizeof(INT);
							p++;
							pData = p;
						}
						void *pTMP = NULL;
						if (pFile->nType == 3) //ļ
						{
							pTMP = malloc(nLen);
							memcpy(pTMP, pData, nLen);
							nPos = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
							E_RC4_Calc(nPos, (unsigned char*)pTMP, nLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
							pData = pTMP;
						}
						if(WriteFile(hFile,pData,nLen,&dwNumOfByteRead,NULL))
						{
//							if(FlushFileBuffers(hFile)==FALSE)
//								bRet = FALSE;
						}
						else
							bRet = FALSE;

						if (pTMP)
						{
							free(pTMP);
							pTMP = NULL;
						}

						if(bRet == FALSE)
							break;
					}

				}else{

					INT nLen = GetSysDataTypeDataSize(pArgInf[i].m_dtDataType);
					if(nLen==0)//ֵ֧
						continue;
					DWORD dwSize;
					void* pData = GetAryElementInf(pArgInf[i].m_pAryData,dwSize);
					nLen *= dwSize;

					void *pTMP = NULL;
					if (pFile->nType == 3) //ļ
					{
						pTMP = malloc(nLen);
						memcpy(pTMP, pData, nLen);
						nPos = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
						E_RC4_Calc(nPos, (unsigned char*)pTMP, nLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
						pData = pTMP;
					}
					if(WriteFile(hFile,pData,nLen,&dwNumOfByteRead,NULL))
					{
//						if(FlushFileBuffers(hFile)==FALSE)
//							bRet = FALSE;
					}
					else
						bRet = FALSE;

					if (pTMP)
					{
						free(pTMP);
						pTMP = NULL;
					}

					if(bRet == FALSE)
						break;
				}
			}
			else
			{//
				INT nLen;
				void* pData;
				INT nData = 0;
				if(pArgInf[i].m_dtDataType==SDT_TEXT)
				{
					if(pArgInf[i].m_pText==NULL)
					{
						nLen = 1;
						pData = &nData;

					}
					else
					{
						nLen = mystrlen(pArgInf[i].m_pText)+1;
						pData = pArgInf[i].m_pText;
					}

				}else if(pArgInf[i].m_dtDataType==SDT_BIN)
				{
					if(pArgInf[i].m_pBin==NULL)
					{
						nLen = sizeof(INT);
						pData = &nData;
					}
					else
					{
						LPINT p = (LPINT)pArgInf[i].m_pBin;
						nLen = p[1]+sizeof(INT);
						p++;
						pData = p;
					}

				}else{

					nLen = GetSysDataTypeDataSize(pArgInf[i].m_dtDataType);
					if(nLen==0)//ֵ֧
						continue;
					pData = &pArgInf[i].m_int;
				}
				void *pTMP = NULL;
				if (pFile->nType == 3) //ļ
				{
					pTMP = malloc(nLen);
					memcpy(pTMP, pData, nLen);
					nPos = SetFilePointer(hFile,0,NULL,FILE_CURRENT);
					E_RC4_Calc(nPos, (unsigned char*)pTMP, nLen, pFile->strTable, pFile->nCryptStart, pFile->strMD5);
					pData = pTMP;
				}
				if(WriteFile(hFile,pData,nLen,&dwNumOfByteRead,NULL))
				{
//					if(FlushFileBuffers(hFile)==FALSE)
//						bRet = FALSE;
				}
				else
					bRet = FALSE;

				if (pTMP)
				{
					free(pTMP);
					pTMP = NULL;
				}

				if(bRet == FALSE)
					break;
			}
		}
		

	}else if(pFile->nType ==2)//ڴļ
	{
		CMyMemFile* pMemFile = (CMyMemFile*) pFile->FileHandle;
		bRet = TRUE;
		for(INT i=1;i < nArgCount;i++)
		{

			if((pArgInf[i].m_dtDataType & DT_IS_ARY) == DT_IS_ARY)//
			{
				pArgInf[i].m_dtDataType &=~DT_IS_ARY; //ȥ־
				if(pArgInf[i].m_dtDataType==SDT_TEXT)
				{
					DWORD dwSize;
					LPSTR* pAryData = (LPSTR*)GetAryElementInf(pArgInf[i].m_pAryData,dwSize);
					INT nData = 0;
					for(UINT n=0;n<dwSize;n++)
					{
						INT nLen;
						void* pData;
						if(pAryData[n]==NULL)
						{
							nLen = 1;
							pData = &nData;
						}
						else
						{
							nLen = mystrlen(pAryData[n])+1;
							pData = pAryData[n];
						}
						pMemFile->Write(pData,nLen);

					}


				}else if(pArgInf[i].m_dtDataType==SDT_BIN)
				{
					DWORD dwSize;
					LPINT* pAryData = (LPINT*)GetAryElementInf(pArgInf[i].m_pAryData,dwSize);
					INT nData = 0;
					for(UINT n=0;n<dwSize;n++)
					{
						void* pData;
						INT nLen;
						if(pAryData[n]==NULL)
						{
							pData = &nData;
							nLen = sizeof(INT);
						}
						else
						{
							LPINT p = pAryData[n];
							nLen = p[1]+sizeof(INT);
							p++;
							pData = p;
						}
						pMemFile->Write(pData,nLen);

					}

				}else{

					INT nLen = GetSysDataTypeDataSize(pArgInf[i].m_dtDataType);
					if(nLen==0)//ֵ֧
						continue;
					DWORD dwSize;
					void* pData = GetAryElementInf(pArgInf[i].m_pAryData,dwSize);
					nLen *= dwSize;
					pMemFile->Write(pData,nLen);

				}
			}
			else
			{//
				INT nLen;
				void* pData;
				INT nData = 0;
				if(pArgInf[i].m_dtDataType==SDT_TEXT)
				{
					if(pArgInf[i].m_pText==NULL)
					{
						nLen = 1;
						pData = &nData;

					}
					else
					{
						nLen = mystrlen(pArgInf[i].m_pText)+1;
						pData = pArgInf[i].m_pText;
					}

				}else if(pArgInf[i].m_dtDataType==SDT_BIN)
				{
					if(pArgInf[i].m_pBin==NULL)
					{
						nLen = sizeof(INT);
						pData = &nData;
					}
					else
					{
						LPINT p = (LPINT)pArgInf[i].m_pBin;
						nLen = p[1]+sizeof(INT);
						p++;
						pData = p;
					}

				}else{

					nLen = GetSysDataTypeDataSize(pArgInf[i].m_dtDataType);
					if(nLen==0)//ֵ֧
						continue;
					pData = &pArgInf[i].m_int;
				}

				pMemFile->Write(pData,nLen);

			}
		}


	}
	return bRet;
}


================================================
FILE: krnln/krnln_year.cpp
================================================
#include "stdafx.h"
#include <math.h>
//ʱ - ȡ
/*
    øʽ ͡ ȡ ʱ ʱ䣩 - ϵͳֿ֧->ʱ
    Ӣƣyear
    һֵΪ 100  9999 ֮ʾָʱеݡΪ
    <1>Ϊʱ䡱Ϊʱͣdate
*/
LIBAPI(int, krnln_year)
{
	INT nYear, nMonth, nDay;
	GetDatePart(ArgInf.m_date, nYear, nMonth, nDay);
	return nYear;
}


================================================
FILE: krnln/lib.h
================================================

#ifndef __LIB_H
#define __LIB_H

/*
    Ȩ
    ļȨΪУȨֿ֧⣬ֹκγϡ
*/

// ϵͳĻͣٸġ

#define		_SDT_NULL		0           // հ
#define		_SDT_ALL		MAKELONG (MAKEWORD (0, 0), 0x8000)		// ͨ
	/*  ֿ֧򷵻ֵͣڶʱ
	_SDT_ALLƥͣͱҪ󣩡*/
#define		SDT_BYTE		MAKELONG (MAKEWORD (1, 1), 0x8000)		// ֽ
#define		SDT_SHORT		MAKELONG (MAKEWORD (1, 2), 0x8000)		// 
#define		SDT_INT			MAKELONG (MAKEWORD (1, 3), 0x8000)		// 
#define		SDT_INT64		MAKELONG (MAKEWORD (1, 4), 0x8000)		// 
#define		SDT_FLOAT		MAKELONG (MAKEWORD (1, 5), 0x8000)		// С
#define		SDT_DOUBLE		MAKELONG (MAKEWORD (1, 6), 0x8000)		// ˫С
#define		SDT_BOOL		MAKELONG (MAKEWORD (2, 0), 0x8000)		// ߼
#define		SDT_DATE_TIME	MAKELONG (MAKEWORD (3, 0), 0x8000)		// ʱ
#define		SDT_TEXT		MAKELONG (MAKEWORD (4, 0), 0x8000)		// ı
#define		SDT_BIN			MAKELONG (MAKEWORD (5, 0), 0x8000)		// ֽڼ
#define		SDT_SUB_PTR		MAKELONG (MAKEWORD (6, 0), 0x8000)		// ¼ûӳĴַ

// ͵
#define	DTM_SYS_DATA_TYPE_MASK		0x80000000
#define	DTM_USER_DATA_TYPE_MASK		0x40000000
#define	DTM_LIB_DATA_TYPE_MASK		0x00000000

// е־ijֵλ1ʾΪ͵顣
// ־ʱΪAS_RECEIVE_VAR_OR_ARRAYAS_RECEIVE_ALL_TYPE_DATA
// ־Ŀ˵ΪǷΪݣϾδʹáط
// ԺԱ־
#define	DT_IS_ARY					0x20000000

typedef DWORD DATA_TYPE;
typedef DATA_TYPE* PDATA_TYPE;

typedef struct
{
	LPTSTR		m_szName;				// 
	LPTSTR		m_szExplain;			// ϸ
	SHORT		m_shtBitmapIndex;		// μ CMD_INFO еͬԱ
	SHORT		m_shtBitmapCount;		// μ CMD_INFO еͬԱ

	DATA_TYPE	m_dtDataType;           // 

	INT			m_nDefault;
		// ϵͳͲĬֵָڱʱԶ
		//     1ֱֵͣΪֵΪСָֻ֣
		//		  ΪָֻINTֵIJ֣
		//     2߼ͣ1棬0ڼ٣
		//     3ıͣԱʱΪLPTSTRָ룬ָĬı
		//     4ͲһĬֵָ

	#define		AS_HAS_DEFAULT_VALUE				(1 << 0)
			// ĬֵĬֵm_nDefault˵±־⡣
	#define		AS_DEFAULT_VALUE_IS_EMPTY			(1 << 1)
			// ĬֵĬֵΪգϱ־⡣
    // ־ͬʱֻһλ
	#define		AS_RECEIVE_VAR					    (1 << 2)
			// Ϊṩʱṩ
	#define		AS_RECEIVE_VAR_ARRAY				(1 << 3)
			// Ϊṩʱṩ
	#define		AS_RECEIVE_VAR_OR_ARRAY			    (1 << 4)
			// Ϊṩʱṩ
	#define		AS_RECEIVE_ARRAY_DATA			    (1 << 5)
			// Ϊṩʱṩݡ
	#define		AS_RECEIVE_ALL_TYPE_DATA            (1 << 6)
			// Ϊṩʱṩݡ
	DWORD		m_dwState;
}
ARG_INFO, *PARG_INFO;

struct CMD_INFO
{
	LPTSTR		m_szName;			// 
	LPTSTR		m_szEGName;			// ӢƣΪջNULL

	LPTSTR		m_szExplain;		// ϸ
	SHORT		m_shtCategory;		// ȫ𣬴1ʼһֵΪָLIB_INFO
                                    // m_szzCategoryԱṩijַ
                                    // ԱĴֵΪ-1

	#define		CT_IS_HIDED					(1 << 2)
		//   ǷΪҪûֱѭ򱻷
	    // Ϊ˱ּҪڵ
	#define		CT_IS_ERROR					(1 << 3)
		// ڱвʹãд˱־һҪڲͬ԰汾ͬʹã
		// AA԰汾пҪʵֲʹãB԰汾пܾͲҪ
		// ʹ˾д˱־ָֻ֧óͱ룬֧С
		// д˱־Բʵֱִв֡
	#define		CT_DISABLED_IN_RELEASE_VER	(1 << 4)
		// б־ϵͳRELEASE׳ʱ޷ֵ
	#define		CT_ALLOW_APPEND_NEW_ARG		(1 << 5)
		//   ڱIJĩβǷµIJ²ͬڲеһ
	#define		CT_RETURN_ARRAY_DATA		(1 << 6)
		// ˵m_dtRetType˵ǷΪݡ
	WORD		m_wState;

	/*  !!!!! ǧע⣺ֵͶΪ _SDT_ALL Բܷ(CT_RETURN_ARRAY_DATA
		λ)򸴺͵(ûԶ͵ڻ˵Ԫ)
		Ϊû޷ԶɾĶռ(ıͻֽڼͳԱ) */
	DATA_TYPE	m_dtRetType;    // ֵ͡

	WORD		m_wReserved;    // Ϊ0

    // ꣬ΪûṩѧϰѶ˵
    #define	LVL_SIMPLE			1		// 
    #define	LVL_SECONDARY		2		// м
    #define	LVL_HIGH			3		// ߼
	SHORT		m_shtUserLevel;	// û𣬱ԱֵΪļꡣ

	SHORT		m_shtBitmapIndex;	// ָͼ1ʼ0ʾޡһֵΪָֿ֧Ϊ
                                    // "LIB_BITMAP"BITMAPԴijһ16X13λͼ
	SHORT		m_shtBitmapCount;	// ͼĿ(ΪIDEṩͼƬ).

	INT			m_nArgCount;		// IJĿ
	PARG_INFO	m_pBeginArgInfo;    // ָIJϢ
};
typedef CMD_INFO* PCMD_INFO;

struct LIB_DATA_TYPE_ELEMENT
{
	DATA_TYPE m_dtDataType; // ݳԱ͡

	LPBYTE m_pArySpec;  // ԱΪ飬򱾳ԱṩֵָΪNULL
        // ָĸʽΪΪһBYTE¼άΪ0ʾΪ飬ֵΪ0x7f
        // ȻΪӦĿINTֵ˳¼ӦάԪĿ

	LPTSTR m_szName;    // ݳԱƣݳԱֻһݳԱֵӦΪNULL
	LPTSTR m_szEGName;  // ݳԱӢƣΪջNULL
	LPTSTR m_szExplain; // ݳԱϸ˵

	#define LES_HAS_DEFAULT_VALUE  (1 << 0)    // ݳԱĬֵĬֵm_nDefault˵
	DWORD m_dwState;

    //  m_dwState  LES_HAS_DEFAULT_VALUE ־ҷʱЧ
	INT m_nDefault;
		// ݳԱĬֵָ
		//     1ֱֵͣΪֵΪСָֻ֣
		//		  ΪָֻINTֵIJ֣
		//     2߼ͣ1棬0ڼ٣
		//     3ıͣʱΪLPTSTRָ룬ָĬı
		//     4ͲһĬֵָ
};
typedef LIB_DATA_TYPE_ELEMENT* PLIB_DATA_TYPE_ELEMENT;

// ̶ԵĿ
#define	FIXED_WIN_UNIT_PROPERTY_COUNT	8

// ÿ̶Զ
#define	FIXED_WIN_UNIT_PROPERTY	\
	{	_WT(""), _WT("left"),	NULL,	UD_INT,	NULL,	NULL	},	\
	{	_WT(""), _WT("top"),	NULL,	UD_INT,	NULL,	NULL	},	\
	{	_WT(""), _WT("width"),	NULL,	UD_INT,	NULL,	NULL	},	\
	{	_WT("߶"), _WT("height"),	NULL,	UD_INT,	NULL,	NULL	},	\
	{	_WT(""), _WT("tag"),	NULL,	UD_TEXT,	NULL,	NULL	},	\
	{	_WT(""), _WT("visible"),	NULL,	UD_BOOL,	NULL,	NULL	},	\
	{	_WT("ֹ"), _WT("disable"),	NULL,	UD_BOOL,	NULL,	NULL	},	\
	{	_WT("ָ"), _WT("MousePointer"),	NULL,	UD_CURSOR,	NULL,	NULL	}

// 崰ڵԪԡ
struct UNIT_PROPERTY
{
	LPTSTR m_szName;    // ƣעΪԱͬʱöԣͬԵһ¡
	LPTSTR m_szEGName;  // Ӣơ
	LPTSTR m_szExplain; // Խ͡

	#define		UD_INT			    1001	// ΪINTֵ
	#define		UD_DOUBLE		    1002	// ΪDOUBLEֵ
	#define		UD_BOOL			    1003	// ΪBOOLֵ
	#define		UD_DATE_TIME	    1004	// ΪDATEֵ
	#define		UD_TEXT			    1005	// Ϊַ
	#define		UD_PICK_INT			1006	// ΪINTֵûֻѡ񣬲ܱ༭
	#define		UD_PICK_TEXT		1007	// Ϊѡַûֻѡ񣬲ܱ༭
	#define		UD_EDIT_PICK_TEXT	1008	// ΪѡַûԱ༭
	#define		UD_PIC			    1009	// ΪͼƬļ
	#define		UD_ICON			    1010	// Ϊͼļ
	#define		UD_CURSOR		    1011
		//   һINT¼ֵָͣ Windows API  LoadCursor 
        // Ϊ-1ΪԶָ룬ʱӦȵָļݡ
	#define		UD_MUSIC		    1012	// Ϊļ
	#define		UD_FONT			    1013    // ΪһLOGFONTݽṹٸġ
	#define		UD_COLOR		    1014    // ΪCOLORREFֵ
	#define		UD_COLOR_TRANS	    1015
		//   ΪCOLORREFֵ͸ɫ(CLR_DEFAULTCLR_DEFAULT
        // VC++COMMCTRL.Hͷļж)
	#define		UD_FILE_NAME	    1016
		//   Ϊļַʱm_szzPickStrеΪ
		// Ի + "\0" + ļ + "\0" + ĬϺ׺ + "\0" +
		// "1"ȡļ"0"ȡļ + "\0"
	#define		UD_COLOR_BACK	    1017
		// ΪCOLORREFֵϵͳĬϱɫ(CLR_DEFAULT)
	#define		UD_ODBC_CONNECT_STR	1021
		// ODBCı
	#define		UD_ODBC_SELECT_STR	1022
		// ODBCݲѯSQLı
	#define		UD_IMAGE_LIST		1023
		// ͼƬ飬ݽṹΪ
		#define	IMAGE_LIST_DATA_MARK	(MAKELONG ('IM', 'LT'))
		/*
		DWORD: ־ݣΪ IMAGE_LIST_DATA_MARK
		COLORREF: ͸ɫΪCLR_DEFAULT
		ΪͼƬݣCImageList::ReadCImageList::Writeд
		*/
	#define		UD_CUSTOMIZE		1024    // Զ

	SHORT m_shtType;	// ԵͣΪĺֵ

	#define	UW_HAS_INDENT		(1 << 0)	// ԱʾʱһΣһԡ
	#define	UW_GROUP_LINE		(1 << 1)	// Աбʾ׷ߡ
	#define	UW_ONLY_READ		(1 << 2)    // ֻԣʱãʱд
	#define	UW_CANNOT_INIT		(1 << 3)    // ʱãʱдϱ־⡣
	WORD m_wState;

	LPTSTR m_szzPickStr;
		// m_nTypeΪUP_PICK_INTUP_PICK_TEXTUD_EDIT_PICK_TEXTUD_FILE_NAMEʱΪNULL
		// ˳¼"\0"ָбѡıUD_FILE_NAMEΪ˵ʽһ"\0"
};
typedef UNIT_PROPERTY* PUNIT_PROPERTY;

typedef struct
{
	LPTSTR		m_szName;       // 
	LPTSTR		m_szExplain;    // ϸ

	#define EAS_IS_BOOL_ARG     (1 << 0)	// Ϊ߼Ͳ޴˱־ΪͲ
	DWORD		m_dwState;
}
EVENT_ARG_INFO, *PEVENT_ARG_INFO;

struct EVENT_INFO
{
	LPTSTR		m_szName;			// ¼
	LPTSTR		m_szExplain;		// ¼ϸ

	#define		EV_IS_HIDED			(1 << 0)
    	// ¼ǷΪ¼ܱһûʹû򱻷Ϊ˱ּҪڵ¼
	#define		EV_RETURN_INT		(1 << 3)
        // ¼ĴӳҪһ
	#define		EV_RETURN_BOOL		(1 << 4)
        // ¼ĴӳҪһ߼ֵϱ־⡣
	DWORD		m_dwState;

	INT				m_nArgCount;		// ¼IJĿ
	PEVENT_ARG_INFO	m_pEventArgInfo;	// ¼
};
typedef EVENT_INFO* PEVENT_INFO;

////////////////////////////////////

typedef DWORD  HUNIT;

// ͨýӿָ롣
typedef void (WINAPI *PFN_INTERFACE) ();

// ڵԪӿID
#define	ITF_CREATE_UNIT					1	// Ԫ
// ӿڽڿӻƴڽʱʹá
#define	ITF_PROPERTY_UPDATE_UI			2	// ˵Ŀǰɷ޸
#define	ITF_DLG_INIT_CUSTOMIZE_DATA		3	// ʹöԻԶ
#define	ITF_NOTIFY_PROPERTY_CHANGED		4	// ֪ͨijݱ޸
#define	ITF_GET_ALL_PROPERTY_DATA		5	// ȡȫ
#define	ITF_GET_PROPERTY_DATA			6	// ȡij
#define	ITF_IS_NEED_THIS_KEY			8	//   ѯʵԪǷҪָİϢڵԪ
                                        	// ػĬΪʱİTAB
                                            // SHIFT+TABUPDOWNȡ

typedef PFN_INTERFACE (WINAPI *PFN_GET_INTERFACE) (INT nInterfaceNO);

//////////////////////////////////// ӿڣ

// ԪɹʱHUNITʧܷNULL
typedef HUNIT (WINAPI *PFN_CREATE_UNIT) (
        LPBYTE pAllPropertyData,            //   ָ򱾴ڵԪݣɱڵԪ
                                            // ITF_GET_PROPERTY_DATAӿڲûΪNULL
        INT nAllPropertyDataSize,           //   ṩpAllPropertyDataָݵijߴ磬ûΪ0
		DWORD dwStyle,                      //   ԤõĴڷ
        HWND hParentWnd,                    //   ھ
        UINT uID,                           //   ڸеID
        HMENU hMenu,                        //   δʹá
        INT x, INT y, INT cx, INT cy,       //   ָλüߴ硣
		DWORD dwWinFormID, DWORD dwUnitID,  //   ڵԪڴڼID֪ͨϵͳ
		HWND hDesignWnd = 0,                //   blInDesignModeΪ棬hDesignWndṩƴڵĴھ
        BOOL blInDesignMode = FALSE);       //   ˵ǷIDEԽпӻƣʱΪ١

// ָĿǰԱ棬򷵻ؼ١
typedef BOOL (WINAPI *PFN_PROPERTY_UPDATE_UI) (
        HUNIT hUnit,            // PFN_CREATE_UNITصѴڵԪľͬ
        INT nPropertyIndex);    // ҪѯԵֵͬ

// ΪUD_CUSTOMIZEĵԪԡ
// Ҫ´õԪ޸ĵԪΣ뷵档
typedef BOOL (WINAPI *PFN_DLG_INIT_CUSTOMIZE_DATA) (
        HUNIT hUnit,
        INT nPropertyIndex,
		BOOL* pblModified = NULL,   //   pblModifiedΪNULLзǷ
                                    // û޸ģIDEUNDO¼
        LPVOID pReserved = NULL);   // δá

// ¼ijԵľֵ
union UNIT_PROPERTY_VALUE
{
	INT			m_int;			// ӦUD_INTUD_PICK_INTͬ
	DOUBLE		m_double;		// UD_DOUBLE
	BOOL		m_bool;			// UD_BOOL
	DATE		m_dtDateTime;	// UD_DATE_TIME
	COLORREF	m_clr;			// UD_COLORUD_COLOR_TRANSUD_COLOR_BACK

	LPTSTR		m_szText;		//   UD_TEXTUD_PICK_TEXTUD_EDIT_PICK_TEXT
			                    // UD_ODBC_CONNECT_STRUD_ODBC_SELECT_STR

	LPTSTR		m_szFileName;	// UD_FILE_NAME

    // UD_PICUD_ICONUD_CURSORUD_MUSICUD_FONTUD_CUSTOMIZEUD_IMAGE_LIST
	struct
	{
		LPBYTE  m_pData;
		INT     m_nDataSize;
	} m_data;

	UNIT_PROPERTY_VALUE ()
	{
		memset ((LPBYTE)this, 0, sizeof (UNIT_PROPERTY_VALUE));
	}
};
typedef UNIT_PROPERTY_VALUE* PUNIT_PROPERTY_VALUE;

//   ֪ͨijԣUD_CUSTOMIZEԣݱû޸ģҪݸ޸Ӧ
// ڲݼΣȷʵҪ´޸ĵԪΣ뷵档
//   ע⣺ֵĺϷУ顣
typedef BOOL (WINAPI *PFN_NOTIFY_PROPERTY_CHANGED) (
        HUNIT hUnit,
        INT nPropertyIndex,
		PUNIT_PROPERTY_VALUE pPropertyValue,    // ޸ĵӦݡ
        LPTSTR* ppszTipText = NULL);    // Ŀǰδʹá

// ȡijݵpPropertyValueУɹ棬򷵻ؼ١
/*  ע⣺ʱɵPFN_CREATE_UNITʱblInDesignMode
pPropertyValue뷵洢ֵʱblInDesignModeΪ٣
ʵʵĵǰʵʱֵ
    ˵༭򴰿ڵԪġݡԣʱ뷵ڲֵ
ʱͱ GetWindowText ȥʵʱȡ */
typedef BOOL (WINAPI *PFN_GET_PROPERTY_DATA) (
        HUNIT hUnit,
        INT nPropertyIndex,
		PUNIT_PROPERTY_VALUE pPropertyValue);   // ȡԵݡ

//   رڵԪȫݣɸôڵԪʵִƸʽ
// ϵһ𡣴˴ڵԪPFN_CREATE_UNITӿڱܹȷ
// ݡ
typedef HGLOBAL (WINAPI *PFN_GET_ALL_PROPERTY_DATA) (HUNIT hUnit);

// ѯʵԪǷҪָİϢҪ棬򷵻ؼ١
typedef BOOL (WINAPI *PFN_IS_NEED_THIS_KEY) (
        HUNIT hUnit,
        WORD wKey);

////////////////////////////////////

#define	UNIT_BMP_SIZE			24		// Ԫ־λͼĿȺ͸߶ȡ
#define	UNIT_BMP_BACK_COLOR		(RGB (192, 192, 192))	// Ԫ־λͼıɫ

struct LIB_DATA_TYPE_INFO  // ⶨͽṹ
{
	LPTSTR m_szName;    // 
	LPTSTR m_szEGName;  // ӢƣΪջNULL
	LPTSTR m_szExplain; // ϸͣΪNULL

	INT m_nCmdCount;        // ͳԱĿΪ0
	LPINT m_pnCmdsIndex;	// ˳¼гԱֿ֧еֵΪNULL

    //   ǷΪͣûֱͣ类
    // Ϊ˱ּҪڵͣ
	#define		LDT_IS_HIDED				(1 << 0)
    // ڱвʹãд˱־һ
    // ʹд˱־͵Ҳ塣
	#define		LDT_IS_ERROR				(1 << 1)
    // ǷΪڵԪ˱־λm_nElementCountΪ0
	#define		LDT_WIN_UNIT				(1 << 6)
    // ǷΪʹڵԪд˱־LDT_WIN_UNITλ
	#define		LDT_IS_CONTAINER			(1 << 7)
    // ǷΪṩܵĴڵԪʱӣ˱־λLDT_WIN_UNITλ
    // д˱־ĵԪʱ޿Ρ
	#define		LDT_IS_FUNCTION_PROVIDER	(1 << 15)
    // ڵԪ˱־λʾ˵Ԫܽ뽹㣬TABͣ
	#define		LDT_CANNOT_GET_FOCUS		(1 << 16)
    // ڵԪ˱־λʾ˵ԪԽ뽹㣬ĬϲͣTAB
    // ־ϱ־⡣
	#define		LDT_DEFAULT_NO_TABSTOP		(1 << 17)
    // ǷΪҪԵλûߴ״ڵԪ繤״̬ȣھд˱־ĵԪ
    // ڴڳߴıʱԶ͸WU_SIZE_CHANGEDϢ
    // ע⣺״ڵԪҪԶ CCS_TOP ڷҪԶײ
    //  CCS_BOTTOM ڷ
	#define		LDT_BAR_SHAPE				(1 << 20)
	DWORD   m_dwState;

    ////////////////////////////////////////////
    // ³ԱֻΪڵԪ˵ʱЧ

	DWORD m_dwUnitBmpID;		// ָֿ֧еĵԪͼԴIDעⲻͬͼ0Ϊޡ
                                // ߴΪ 24 X 24 ɫΪ RGB (192, 192, 192) 

	INT m_nEventCount;  // Ԫ¼Ŀ
	PEVENT_INFO m_pEventBegin;	// 屾Ԫ¼

	INT m_nPropertyCount;
	PUNIT_PROPERTY m_pPropertyBegin;

    // ṩڵԪнӿڡ
	PFN_GET_INTERFACE m_pfnGetInterface;

    ////////////////////////////////////////////
    // ³ԱֻڲΪڵԪ˵ʱЧ

	// ӳԱĿΪ0Ϊڡ˵Ԫ˱ֵΪ0
	INT	m_nElementCount;
	PLIB_DATA_TYPE_ELEMENT m_pElementBegin;  // ָӳԱ׵ַ
};
typedef LIB_DATA_TYPE_INFO* PLIB_DATA_TYPE_INFO;

/*////////////////////////////////////////////*/

struct LIB_CONST_INFO  // ⳣݽṹ
{
	LPTSTR	m_szName;
	LPTSTR	m_szEGName;
	LPTSTR	m_szExplain;

	SHORT	m_shtReserved;  // Ϊ 1 

	#define	CT_NULL			0
	#define	CT_NUM			1	// sample: 3.1415926
	#define	CT_BOOL			2	// sample: 1
	#define	CT_TEXT			3	// sample: "abc"
	SHORT	m_shtType;

	LPTSTR	m_szText;		// CT_TEXT
	DOUBLE	m_dbValue;		// CT_NUMCT_BOOL
};
typedef LIB_CONST_INFO* PLIB_CONST_INFO;

//////////////////////////////////////////// ݽṹ

typedef struct
{
    DWORD m_dwFormID;
    DWORD m_dwUnitID;
}
MUNIT, *PMUNIT;

#pragma pack (push, old_value)   // VC++ṹֽ
#pragma pack (1)    // Ϊһֽڶ롣

struct MDATA_INF
{
    union
    {
        // ע⵱ӦAS_RECEIVE_VARAS_RECEIVE_VAR_ARRAYAS_RECEIVE_VAR_OR_ARRAY
        // ־ʱʹĵڶ֡

        // һ֡
	    BYTE	      m_byte;         // SDT_BYTE ͵ݣͬ
	    SHORT	      m_short;        // SDT_SHORT
	    INT		      m_int;          // SDT_INT
	    INT64	      m_int64;        // SDT_INT64
	    FLOAT	      m_float;        // SDT_FLOAT
	    DOUBLE	      m_double;       // SDT_DOUBLE
        DATE          m_date;         // SDT_DATE_TIME
        BOOL          m_bool;         // SDT_BOOL

        char*         m_pText;        // SDT_TEXTϵͳԤʹǿıֵָҲΪNULLԱڴ
                                      // ָָݵĸʽǰ
                                      // !!!Ϊ˱޸ĵ(m_pTextпָܻ׳)
                                      // ݣֻɶȡɸеݣͬ

        LPBYTE        m_pBin;         // SDT_BINϵͳԤʹǿֽڼֵָҲΪNULLԱڴ
                                      // ָָݵĸʽǰ
                                      // !!!ֻɶȡɸеݡ

        DWORD         m_dwSubCodeAdr; // SDT_SUB_PTRΪӳַָ롣
        MUNIT         m_unit;         // ڵԪ˵͵ݡ

        void*         m_pCompoundData;// ָ룬ָָݵĸʽǰ
                                      // !!! ֻɶȡɸеݡ

        void*         m_pAryData;     // ָ룬ָָݵĸʽǰ
                                      // עΪıֽڼ飬ԱָΪNULL
                                      // !!! ֻɶȡɸеݡ

        // ڶ֡
        // Ϊַָָ룬AS_RECEIVE_VARAS_RECEIVE_VAR_ARRAY
        // AS_RECEIVE_VAR_OR_ARRAY־ʱűʹá
        BYTE*	m_pByte;            // SDT_BYTE ͱĵַͬ
	    SHORT*	m_pShort;           // SDT_SHORT
	    INT*	m_pInt;             // SDT_INT
	    INT64*	m_pInt64;           // SDT_INT64
	    FLOAT*	m_pFloat;           // SDT_FLOAT
	    DOUBLE*	m_pDouble;          // SDT_DOUBLE
        DATE*   m_pDate;            // SDT_DATE_TIME
        BOOL*   m_pBool;            // SDT_BOOL

        char**  m_ppText;           // SDT_TEXTע*m_ppTextΪNULLı
                                    // дֵ֮ǰͷǰֵ䣺NotifySys (NRS_MFREE, (DWORD)*m_ppText)
                                    // !!!ֱӸ*m_ppTextָݣֻͷԭָNULLı
                                    // ʹNRS_MALLOC֪ͨڴַָ루ͬ

        LPBYTE* m_ppBin;            // SDT_BINע*m_ppBinΪNULLֽڼ
                                    // дֵ֮ǰͷǰֵ䣺NotifySys (NRS_MFREE, (DWORD)*m_ppBin)
                                    // !!!ֱӸ*m_ppBinָݣֻͷԭָNULLֽڼ
                                    // ָ롣

        DWORD*  m_pdwSubCodeAdr;    // SDT_SUB_PTRӳַַ
        PMUNIT  m_pUnit;            // ڵԪ˵ͱַ

        void**  m_ppCompoundData;   // ͱַ
                                    // !!!עдֵ֮ǰʹNRS_MFREE֪ͨһͷгԱSDT_TEXT
                                    // SDT_BINͳԱԭַָ롣
                                    // !!!ֱӸ*m_ppCompoundDataָݣֻͷԭָָ롣

        void**  m_ppAryData;        // ݱַע⣺
                                    // 1дֵ֮ǰͷԭֵ䣺NotifySys (NRS_FREE_ARY,
                                    //    m_dtDataType, (DWORD)*m_ppAryData)ע⣺ֻ
                                    //    m_dtDataTypeΪϵͳʱΪͣ
                                    //    䶨Ϣһͷš
                                    // 2Ϊıֽڼ飬гԱָΪNULL
                                    // !!!ֱӸ*m_ppAryDataָݣֻͷԭָָ롣
    };

    // 1ݲʱò AS_RECEIVE_VAR_OR_ARRAY 
    //    AS_RECEIVE_ALL_TYPE_DATA ־Ϊݣ־ DT_IS_ARY 
    //    Ҳ DT_IS_ARY ־Ψһʹóϡ
    //    DT_IS_ARY ĶΪ
    //      #define	DT_IS_ARY   0x20000000
    // 2ݲʱΪհݣΪ _SDT_NULL 
    DATA_TYPE m_dtDataType;
};
typedef MDATA_INF* PMDATA_INF;
// !!! ASSERT (sizeof (MDATA_INF) == sizeof (DWORD) * 3);
// ߴ sizeof (DWORD) * 3 

#pragma pack (pop, old_value)    // ָVC++ṹֽ

//////////////////////////////////////////// ֪ͨݽṹ

/*/////////////*/
// ֿ֧֪ͨױ༭(IDE)л(RUNTIME)ֵ

struct MDATA
{
	MDATA ()
	{
		m_pData = NULL;
		m_nDataSize = 0;
	}

	LPBYTE	m_pData;
	INT		m_nDataSize;
};
typedef MDATA* PMDATA;

struct EVENT_NOTIFY
{
	// ¼¼Դ
	DWORD	m_dwFormID;		// ITF_CREATE_UNITӿݹIDdwWinFormID
	DWORD	m_dwUnitID;		// ITF_CREATE_UNITӿݹĴڵԪIDdwUnitID
	INT		m_nEventIndex;	//   ¼ڴڵԪϢLIB_DATA_TYPE_INFOm_pPropertyBegin
                            // Աеλã

	INT		m_nArgCount;		// ¼ݵIJĿ 5 
	INT		m_nArgValue [5];	// ¼ֵSDT_BOOL ͲֵΪ 1  0

    //!!! עԱûж巵ֵ¼ЧֵΪֵ
	BOOL	m_blHasReturnValue; // û¼ӳ¼Ƿṩ˷ֵ
	INT		m_nReturnValue; // û¼ӳ¼ķֵ߼ֵֵ 0٣  1棩 ء

    /////////////////////////////////////

	EVENT_NOTIFY (DWORD dwFormID, DWORD dwUnitID, INT nEventIndex)
	{
		m_dwFormID = dwFormID;
		m_dwUnitID = dwUnitID;
		m_nEventIndex = nEventIndex;

		m_nArgCount = 0;
		m_blHasReturnValue = FALSE;
		m_nReturnValue = 0;
	}
};
typedef EVENT_NOTIFY* PEVENT_NOTIFY;

/*///////////////////////*/

// NES_ Ϊױ༭(IDE)֪ͨ
#define NES_GET_MAIN_HWND			        1
	// ȡױ༭ڵľֿ֧AddInʹá
#define	NES_RUN_FUNC				        2
	// ֪ͨױ༭ָĹܣһBOOLֵ
	// dwParam1Ϊܺš
	// dwParam2Ϊһ˫DWORDָ,ֱṩܲ12

// NAS_ Ϊȱױ༭ֱл֪ͨ
#define NAS_GET_LIB_DATA_TYPE_INFO          1002
    // ָⶨ͵PLIB_DATA_TYPE_INFOϢָ롣
    // dwParam1ΪȡϢDATA_TYPE
    // Ч߲Ϊⶨͣ򷵻NULL򷵻PLIB_DATA_TYPE_INFOָ롣

// NRS_ Ϊܱл֪ͨ
#define NRS_UNIT_DESTROIED			        2000
	// ֪ͨϵͳָĵԪѾ١
	// dwParam1ΪdwFormID
	// dwParam2ΪdwUnitID
#define NRS_CONVERT_NUM_TO_INT              2001
	// תֵʽ
	// dwParam1Ϊ PMDATA_INF ָ룬 m_dtDataType Ϊֵ͡
    // תֵ
#define NRS_GET_CMD_LINE_STR			    2002
	// ȡǰı
	// ıָ룬пΪմ
#define NRS_GET_EXE_PATH_STR                2003
	// ȡǰִļĿ¼
	// صǰִļĿ¼ıָ롣
#define NRS_GET_EXE_NAME				    2004
	// ȡǰִļ
	// صǰִļıָ롣
#define NRS_GET_UNIT_PTR				    2006
	// ȡԪָ
	// dwParam1ΪWinFormID
	// dwParam2ΪWinUnitID
	// ɹЧĵԪCWnd*ָ룬ʧܷNULL
#define NRS_GET_AND_CHECK_UNIT_PTR			2007
	// ȡԪָ
	// dwParam1ΪWinFormID
	// dwParam2ΪWinUnitID
	// ɹЧĵԪCWnd*ָ룬ʧԶʱ˳
#define NRS_EVENT_NOTIFY				    2008
	// ֪ͨϵͳ¼
	// dwParam1ΪPEVENT_NOTIFYָ롣
	//    0 ʾ¼ѱϵͳʾϵͳѾɹݴ¼û
	// ¼ӳ
#define NRS_STOP_PROCESS_EVENT_NOTIFY	    2009
	// ֪ͨϵͳͣ¼֪ͨ
#define NRS_CONTINUE_PROCESS_EVENT_NOTIFY	2010
	// ֪ͨϵͳ¼֪ͨ
#define	NRS_DO_EVENTS			            2018
	// ֪ͨWindowsϵͳ¼
#define NRS_GET_UNIT_DATA_TYPE              2022
	// dwParam1ΪWinFormID
	// dwParam2ΪWinUnitID
	// ɹЧ DATA_TYPE ʧܷ 0 
#define NRS_FREE_ARY                        2023
    // ͷָݡ
    // dwParam1ΪݵDATA_TYPEֻΪϵͳ͡
    // dwParam2Ϊָݵָ롣
#define NRS_MALLOC                          2024
    // ָռڴ棬׳򽻻ڴ涼ʹñ֪ͨ䡣
    //   dwParam1Ϊڴֽ
    //   dwParam2Ϊ0ʧܾԶʱ˳
    // 粻Ϊ0ʧܾͷNULL
    //   ڴ׵ַ
#define NRS_MFREE                           2025
    // ͷѷָڴ档
    // dwParam1Ϊͷڴ׵ַ
#define NRS_MREALLOC                        2026
    // ·ڴ档
    //   dwParam1Ϊ·ڴߴ׵ַ
    //   dwParam2Ϊ·ڴֽ
    // ·ڴ׵ַʧԶʱ˳
#define	NRS_RUNTIME_ERR			            2027
	// ֪ͨϵͳѾʱ
	// dwParam1Ϊchar*ָ룬˵ı
#define	NRS_EXIT_PROGRAM                    2028
	// ֪ͨϵͳ˳û
	// dwParam1Ϊ˳룬ô뽫صϵͳ
#define NRS_GET_PRG_TYPE                    2030
    // صǰûͣΪ2԰棩3棩

/*///////////////////////////////////////////////////////////////////*/
// ױ༭(IDE)л(RUNTIME)ֵֿ֪֧ͨ
#define	NL_SYS_NOTIFY_FUNCTION		1
	//   ֿ֪֧֪ͨϵͳõĺָ룬װֿ֧ǰ֪ͨжΣ
	// ֵ֪ͨӦøǰֵ֪ͨԷֵ
	//   ɽ˺ָ¼ԱҪʱʹ֪ͨϢϵͳ
	//   dwParam1: (PFN_NOTIFY_SYS)
#define NL_FREE_LIB_DATA                6
    // ֿ֪֧ͨͷԴ׼˳ͷָĸݡ

/*///////////////////////////////////////////////////////////////////*/

#define NR_OK		0
#define NR_ERR		-1
typedef INT (WINAPI *PFN_NOTIFY_LIB) (INT nMsg, DWORD dwParam1 = 0, DWORD dwParam2 = 0);
	// ˺ױ༭(IDE)л(RUNTIME)ֿ֪֧ͨй¼
typedef INT (WINAPI *PFN_NOTIFY_SYS) (INT nMsg, DWORD dwParam1 = 0, DWORD dwParam2 = 0);
	// ˺֪ͨױ༭(IDE)л(RUNTIME)й¼

/* ͷʵֺԭ͡
   1 CDECL ÷ʽ
   2pRetData ݣ
   3!!!ָͲΪ _SDT_ALL 
       pRetData->m_dtDataTypeΪ _SDT_ALL д
   4pArgInf ṩݱָ MDATA_INF ¼ÿĿͬ nArgCount */
typedef void (*PFN_EXECUTE_CMD) (PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf);
// ֿ֧ADDINܵĺ
typedef INT (WINAPI *PFN_RUN_ADDIN_FN) (INT nAddInFnIndex);
// ṩijģĺ
typedef INT (WINAPI *PFN_SUPER_TEMPLATE) (INT nTemplateIndex);

////////////////////////////////////////////////////

#define		LIB_FORMAT_VER		20000101	// ʽ

/*	!!! ע⣺ֿ֧ļĺ׺̶Ϊ.FNxxΪһĸĿǰĺ׺У
	1.fne	༭Ϣִֿ֧֧⣻
	2.fnl	༭Ϣִֿ֧֧⣻
	3.fnr	༭Ϣִֿ֧֧⣻
*/

typedef struct
{
	DWORD				m_dwLibFormatVer;
		// ʽţӦõLIB_FORMAT_VER

	LPTSTR				m_szGuid;
		// ӦڱΨһGUIDΪNULLգͬк汾˴Ӧͬ
        // ע GUID ıʹרù(汾ĵguidgen.exe)ɣԷֹظ

	INT					m_nMajorVersion;	// 汾ţ0
	INT					m_nMinorVersion;	// Ĵΰ汾š

	INT					m_nBuildNumber;
		// 汾š
		//   汾Žͬʽ汾ŵϵͳƩ޸˼ BUG
		// ֵʽ汾ϵͳκιûʹõİ汾乹汾
		// ŶӦòһ
		//   ֵʱӦ˳

	INT					m_nRqSysMajorVer;		// Ҫϵͳ汾ţĿǰӦΪ 3 
	INT					m_nRqSysMinorVer;		// ҪϵͳĴΰ汾ţĿǰӦΪ 0 
	INT					m_nRqSysKrnlLibMajorVer;	// Ҫϵͳֿ֧汾ţĿǰӦΪ 3 
	INT					m_nRqSysKrnlLibMinorVer;	// Ҫϵͳֿ֧Ĵΰ汾ţĿǰӦΪ 0 

	LPTSTR				m_szName;		// ΪNULLա
    // 
    #define LT_CHINESE  1
    #define LT_ENGLISH  2
	INT					m_nLanguage;	// ֵ֧ԣĿǰӦΪ LT_CHINESE 
	LPTSTR				m_szExplain;	// йرϸ

	#define		LBS_FUNC_NO_RUN_CODE		(1 << 2)
		// Ϊ⣬ûжӦִ֧ܵ룬˲С
	#define		LBS_NO_EDIT_INFO			(1 << 3)
		// ޹༭õϢ༭ϢҪΪơַȣ޷IDEء
	DWORD				m_dwState;

//////////////////  йرߵϢ
	LPTSTR				m_szAuthor;
	LPTSTR				m_szZipCode;
	LPTSTR				m_szAddress;
	LPTSTR				m_szPhoto;
	LPTSTR				m_szFax;
	LPTSTR				m_szEmail;
	LPTSTR				m_szHomePage;
	LPTSTR				m_szOther;

//////////////////
	INT                 m_nDataTypeCount;	// Զ͵Ŀm_pDataTypeָԱĿ
	PLIB_DATA_TYPE_INFO m_pDataType;		// Զ͵ĶϢ

	INT					m_nCategoryCount;	// ȫĿͬm_szzCategoryԱʵṩĿ
	LPTSTR				m_szzCategory;		// ȫ˵ÿΪһַǰλֱʾͼţ1ʼ0ʾޣ
                                            // һֵΪָֿ֧Ϊ"LIB_BITMAP"BITMAPԴijһ16X13λͼ

	INT					m_nCmdCount;        // ṩ(ȫ󷽷)Ŀ(Ϊ0)
	PCMD_INFO			m_pBeginCmdInfo;	// ָĶϢ(m_nCmdCountΪ0,ΪNULL)
	PFN_EXECUTE_CMD*    m_pCmdsFunc;		// ָÿʵִ׵ַ(m_nCmdCountΪ0,ΪNULL)

	PFN_RUN_ADDIN_FN	m_pfnRunAddInFn;	// ΪNULLΪIDEṩӹܡ
	//     йAddInܵ˵ַ˵һܡһΪ
	// 20ַڶΪϸܣ60ַմ
	LPTSTR				m_szzAddInFnInfo;

	PFN_NOTIFY_LIB		m_pfnNotify;		// ΪNULLṩIDEл֪ͨϢĺ

    // ģʱá
	PFN_SUPER_TEMPLATE	m_pfnSuperTemplate;	// ΪNULL
	LPTSTR m_szzSuperTemplateInfo;	// ΪNULL

	// ⶨг
	INT	m_nLibConstCount;   // Ŀ
	PLIB_CONST_INFO m_pLibConst;    // ָ顣

	LPTSTR m_szzDependFiles;	// ΪNULL
	    // ҪļװʱԶЩļ
}
LIB_INFO, *PLIB_INFO;

/*////////////////////////////////////////////*/

#define	FUNCNAME_GET_LIB_INFO		"GetNewInf"     // ȡֿ֧PLIB_INFOָ
typedef PLIB_INFO (WINAPI *PFN_GET_LIB_INFO) ();	// GetNewInfĺԭ
typedef INT (*PFN_ADD_IN_FUNC) ();  // m_pfnRunAddInFnĺԭ

/*////////////////////////////////////////////*/

#define LIB_BMP_RESOURCE	"LIB_BITMAP"	    // ֿ֧ṩͼԴ
#define LIB_BMP_CX			16					// ÿһͼԴĿ
#define LIB_BMP_CY			13					// ÿһͼԴĸ߶
#define LIB_BMP_BKCOLOR		RGB(255, 255, 255)	// ͼԴĵɫ

//////////////////////////// ʱʹõĺ

#define	WU_GET_WND_PTR			(WM_APP + 2)	// ִ֧ڵԪ¼
#define	WU_SIZE_CHANGED			(WM_APP + 3)	// ڴڳߴı֪ͨ״ڵԪ
#define	WU_PARENT_RELAYOUT_BAR	(WM_APP + 4)	//   ֪ͨ㴰²е bar Ԫ
                                                // ͨ bar Ԫıߴʹá

#endif


================================================
FILE: krnln/lib2.h
================================================

#ifndef __LIB_INF_H
#define __LIB_INF_H

///////////////////////////////////

// ϵͳ

#define __OS_WIN        0x80000000
#define __OS_LINUX      0x40000000
#define __OS_UNIX       0x20000000

#define OS_ALL     (__OS_WIN | __OS_LINUX | __OS_UNIX)

/*

ڿϵͳּ֧˵

  1ֿ֧Ҫ˵Щϵͳ汾ֿ֧͡
     ͷ¼ֵ֧IJϵͳЩϢ
     ڸֿ֧евϵͳ汾бһ¡

  2Ϊ˺ǰֿ֧ݣm_nRqSysMajorVer.m_nRqSysMinorVer汾
     С3.6ĶĬΪ֧Windowsϵͳڲ͡
     ͷ¼ԡ

  3̶Ժ͹̶¼֧вϵͳ

  4ڴ߿ⲻвϵͳּ֧顣

*/

///////////////////////////////////


#ifdef _DEBUG
	#define CHKV_RET(epr)		\
			ASSERT (epr);	\
			if (!(epr))  return;
	#define CHKV_RET_VAL(epr,val)		\
			ASSERT (epr);	\
			if (!(epr))  return val;
	#define CHKV_BREAK(epr)		\
			ASSERT (epr);	\
			if (!(epr))  break;
	#define CHKV_CONTINUE(epr)		\
			ASSERT (epr);	\
			if (!(epr))  continue;
	#define DEFAULT_FAILD  default: ASSERT (FALSE); break
#else
	#define CHKV_RET(epr)		\
			if (!(epr))  return;
	#define CHKV_RET_VAL(epr,val)		\
			if (!(epr))  return val;
	#define CHKV_BREAK(epr)		\
			if (!(epr))  break;
	#define CHKV_CONTINUE(epr)		\
			if (!(epr))  continue;
	#define DEFAULT_FAILD
#endif


typedef	SHORT		DTBOOL;		// SDT_BOOL͵ֵ
typedef	DTBOOL*		PDTBOOL;
#define	BL_TRUE		-1			// SDT_BOOL͵ֵ
#define	BL_FALSE	0			// SDT_BOOL͵ļֵ

typedef DATE*	PDATE;

///////////////////////////////////

// ϵͳĻ

#define		_SDT_NULL		0           // ݣڲʹãΪ㣩
/*  ڿ򷵻ֵ͡
    1ڶʱ_SDT_ALLƥͣͱҪ󣩡
    2ڶΪ_SDT_ALL͵Ŀ򸴺͵
    (ûԶ͵ڻ˵)_SDT_ALL͵ֻ
    Ϊϵͳͻ򴰿˵͡*/
#define		_SDT_ALL		MAKELONG (MAKEWORD (0, 0), 0x8000)	// ڲʹã
// ֵƥ֣ڿֵ͡
//#define		_SDT_NUM		MAKELONG (MAKEWORD (1, 0), 0x8000)	// ڲʹã3.0汾Ѿ
	#define		SDT_BYTE		MAKELONG (MAKEWORD (1, 1), 0x8000)		// ֽ
	#define		SDT_SHORT		MAKELONG (MAKEWORD (1, 2), 0x8000)		// 
	#define		SDT_INT			MAKELONG (MAKEWORD (1, 3), 0x8000)		// 
	#define		SDT_INT64		MAKELONG (MAKEWORD (1, 4), 0x8000)		// 
	#define		SDT_FLOAT		MAKELONG (MAKEWORD (1, 5), 0x8000)		// С
	#define		SDT_DOUBLE		MAKELONG (MAKEWORD (1, 6), 0x8000)		// ˫С
#define		SDT_BOOL		MAKELONG (MAKEWORD (2, 0),	0x8000)		// ߼
#define		SDT_DATE_TIME	MAKELONG (MAKEWORD (3, 0),	0x8000)		// ʱ
#define		SDT_TEXT		MAKELONG (MAKEWORD (4, 0),	0x8000)		// ı
#define		SDT_BIN			MAKELONG (MAKEWORD (5, 0),	0x8000)		// ֽڼ
#define		SDT_SUB_PTR		MAKELONG (MAKEWORD (6, 0),	0x8000)		// ӳָ
//#define		_SDT_VAR_REF	MAKELONG (MAKEWORD (7, 0),	0x8000)		// ο3.0汾Ѿ
#define		SDT_STATMENT	MAKELONG (MAKEWORD (8, 0),	0x8000)
	// ͣڿ͡ݳΪINT
	// һ¼ӳַڶ¼ӳıջס
    // !!! עʱԽлͣԱжϴ
    /* ӣ
        if (pArgInf->m_dtDataType == SDT_BOOL)
            return pArgInf->m_bool;

        if (pArgInf->m_dtDataType == SDT_STATMENT)
        {
            DWORD dwEBP = pArgInf->m_statment.m_dwSubEBP;
            DWORD dwSubAdr = pArgInf->m_statment.m_dwStatmentSubCodeAdr;
            DWORD dwECX, dwEAX;

            _asm
            {
                mov eax, dwEBP
                call dwSubAdr
                mov dwECX, ecx
                mov dwEAX, eax
            }

            if (dwECX == SDT_BOOL)
                return dwEAX != 0;

            // ͷıֽڼڴ档
            if (dwECX == SDT_TEXT || dwECX == SDT_BIN)
                MFree ((void*)dwEAX);
        }

        GReportError ("жϵֻܽ߼");
    */

// ϵͳ͡ûԶ͡ⶨ
#define	DTM_SYS_DATA_TYPE_MASK		0x80000000
#define	DTM_USER_DATA_TYPE_MASK		0x40000000
#define	DTM_LIB_DATA_TYPE_MASK		0x00000000

// ϸûԶ
#define	UDTM_USER_DECLARE_MASK		0x00000000	// ûԶ帴
#define	UDTM_WIN_DECLARE_MASK		0x10000000	// ûԶ崰

// е־ijֵλ1ʾΪ͵顣
// ־ʱΪAS_RECEIVE_VAR_OR_ARRAYAS_RECEIVE_ALL_TYPE_DATA
// ־Ŀ˵ΪǷΪݣϾδʹáط
// ԺԱ־
#define	DT_IS_ARY					0x20000000
// еĴַ־ijֵλ1ʾΪ͵ıַ
// ־ʱΪAS_RECEIVE_VAR_OR_OTHER־Ŀ˵ΪǷΪ
// ַϾδʹáطԺԱ־
// ־ϱ־ܹ档
#define	DT_IS_VAR					0x20000000

typedef DWORD DATA_TYPE;
typedef DATA_TYPE* PDATA_TYPE;

////////////////////////////////////////////////////////////////

// İ汾ͺ
#define	PT_EDIT_VER				1	// Ϊ༭İ汾
#define	PT_DEBUG_RUN_VER		2	// ΪDEBUGа汾
#define	PT_RELEASE_RUN_VER		3	// ΪRELEASEа汾

// ѧϰѶȼ
#define	LVL_SIMPLE			1		// 
#define	LVL_SECONDARY		2		// м
#define	LVL_HIGH			3		// ߼

/*////////////////////////////////////////////*/

//    ṩʽ֣
//      1ṩʽڿûԶͣ
//      2һṩʽṩԶͱԪء
//		   ԶijԱȣ
//      3ṩʽṩԪأ
//      4ṩʽķֵṩݣ
typedef struct
{
	LPTSTR		m_szName;				// 
	LPTSTR		m_szExplain;			// ϸ
	SHORT		m_shtBitmapIndex;		// ָͼ,1ʼ,0ʾ.
	SHORT		m_shtBitmapCount;		// ͼĿ().

	DATA_TYPE	m_dtType;

	INT			m_nDefault;
		// ϵͳͲĬֵָڱ༭ʱѱʱٴ
		//     1ֱͣΪֵΪСָֻ֣
		//		  ΪָֻINTֵIJ֣
		//     2߼ͣ1棬0ڼ٣
		//     3ıͣʱΪLPTSTRָ룬ָĬı
		//     4ͲԶͣһĬֵָ

	DWORD		m_dwState;				// MASK
	#define		AS_HAS_DEFAULT_VALUE				(1 << 0)
			// ĬֵĬֵm_nDefault˵ڱ༭ʱѱʱٴ
	#define		AS_DEFAULT_VALUE_IS_EMPTY			(1 << 1)
			//   ĬֵĬֵΪգAS_HAS_DEFAULT_VALUE־⣬
			// ʱݹIJͿΪ_SDT_NULL
	#define		AS_RECEIVE_VAR      				(1 << 2)
			//   Ϊṩʱֻṩһṩ顢
			// ֵʱݹIJݿ϶ݲΪıַ
	#define		AS_RECEIVE_VAR_ARRAY				(1 << 3)
			//   Ϊṩʱֻṩ飬ṩһ
			// ֵ
	#define		AS_RECEIVE_VAR_OR_ARRAY     		(1 << 4)
			//   Ϊṩʱֻṩһ飬ṩ
			// ֵд˱־򴫵ݸͽͨDT_IS_ARY
            // ־ǷΪ顣
	#define		AS_RECEIVE_ARRAY_DATA   			(1 << 5)
			//   Ϊṩʱֻṩݣ粻ָ־ĬΪֻṩݡ
			// ָ˱־ʱݹIJݿ϶Ϊ顣
	#define		AS_RECEIVE_ALL_TYPE_DATA            (1 << 6)
			// Ϊṩʱͬʱṩݣϱ־⡣
            // д˱־򴫵ݸͽͨDT_IS_ARY־ǷΪ顣
	#define		AS_RECEIVE_VAR_OR_OTHER      		(1 << 9)
			// Ϊṩʱṩһֵṩ顣
            // д˱־򴫵ݸͽͨDT_IS_VAR־ǷΪַ
}
ARG_INFO, *PARG_INFO;

#ifndef __GCC_
struct CMD_INFO
#else
typedef struct
#endif
{
	LPTSTR		m_szName;			// 
	LPTSTR		m_szEgName;			// ӢƣΪջNULL
	
	LPTSTR		m_szExplain;		// ϸ
	SHORT		m_shtCategory;		// ȫ𣬴1ʼԱĴֵΪ-1

	#define		CT_IS_HIDED			(1 << 2)
		//   ǷΪҪûֱӲѭ
	    // Ϊ˱ּҪڵ
	#define		CT_IS_ERROR			(1 << 3)
		// ڱвʹãд˱־һҪڲͬ԰汾ͬʹã
		// AA԰汾пҪʵֲʹãB԰汾пܾͲҪ
		// ʹ˾д˱־ָֻ֧óͱ룬֧С
		// д˱־Բʵִв֡
	#define		CT_DISABLED_IN_RELEASE		(1 << 4)
		// RELEASE汾вʹã൱ڿ޷ֵ
	#define		CT_ALLOW_APPEND_NEW_ARG		(1 << 5)
		//   ڱIJĩβǷµIJ²ͬڲеһ
		// IJһ
	#define		CT_RETRUN_ARY_TYPE_DATA		(1 << 6)
		// ˵m_dtRetValType˵ǷΪݡ
	#define		CT_IS_OBJ_COPY_CMD              (1 << 7)   // !!! עÿֻһд˱ǡ
		//   ˵Ϊij͵ĸƺ(ִнһͬݸƵʱҪ
        // ڱͶĸֵʱͷŸöԭݣȻɵô
        // Ĵ룬κγ渳ֵƴ)
        // !!! 1һͬͲҲκݡ
        //     2ִбʱΪδʼ״̬ڱ븺ʼȫԱݡ
        //     3ṩĴͲݿΪȫ״̬ɱԶɵĶʼã
        //     ʱҪԴ
	#define		CT_IS_OBJ_FREE_CMD              (1 << 8)   // !!! עÿֻһд˱ǡ
		//   ˵Ϊij͵(ִеʱҪȫ
        // 󳬳ʱɵôĴ룬κγٴ)
        //   !!! 1ûκβҲκݡ
        //       2ִʱݿΪȫ״̬ɱԶɵĶʼã
        //   ͷʱҪԴ
	#define		CT_IS_OBJ_CONSTURCT_CMD         (1 << 9)   // !!! עÿֻһд˱ǡ
		//   ˵Ϊij͵Ĺ캯(ִеݳʼʱҪȫ
        //   !!! 1ûκβҲκݡ
        //       2ִʱΪȫ״̬
        //       3ָͳԱͳԱԱ밴նӦʽһʼ
    #define _CMD_OS(os)     ((os) >> 16)  // תosԱ뵽m_wState
    #define _TEST_CMD_OS(m_wState,os)    ((_CMD_OS (os) & m_wState) != 0) // ָǷָ֧ϵͳ
	WORD		m_wState;

	/*  !!!!! ǧע⣺ֵΪ _SDT_ALL , Բܷ(CT_RETRUN_ARY_TYPE_DATA
		λ)򸴺͵(ûԶ͵ڻ˵),
		Ϊ޷ԶɾĶռ(ıͻֽڼͳԱ).
        ֻͨͨأ_SDT_ALL͵ֻΪ
        ϵͳͻ򴰿˵͡
	*/
	// ֵͣʹǰעתHIWORDΪ0ڲֵʹõֵ
	DATA_TYPE	m_dtRetValType;

	WORD		m_wReserved;

	SHORT		m_shtUserLevel;	// ûѧϰѶȼ𣬱ֵΪꡣ

#ifndef __GCC_
	BOOL IsInObj ()
	{
		return m_shtCategory == -1;
	}
#endif

	SHORT		m_shtBitmapIndex;	// ָͼ,1ʼ,0ʾ.
	SHORT		m_shtBitmapCount;	// ͼĿ().

	INT			m_nArgCount;		// IJĿ
	PARG_INFO	m_pBeginArgInfo;
#ifndef __GCC_
};
#else
} CMD_INFO;
#endif
typedef CMD_INFO* PCMD_INFO;

// ʹõĽṹ
typedef struct
{
    // !!! λöУ򱾳ԱΪSDT_INT
	DATA_TYPE m_dtType;
		//   
    // !!! λöУ򱾳ԱΪNULL
	LPBYTE m_pArySpec;
		// ָΪ飬ֵΪNULLעԲָijάΪ0顣
	LPTSTR m_szName;
		//     ıƣֻһ
		// ֵӦΪNULL
	LPTSTR m_szEgName;
		// ӢıƣΪջNULL
	LPTSTR m_szExplain;

    // !!! λöУ򱾳ԱĬϾLES_HAS_DEFAULT_VALUEǡ
	// ݳԱĬֵĬֵm_nDefault˵
	#define		LES_HAS_DEFAULT_VALUE		(1 << 0)
	// ݳԱء
	#define		LES_HIDED				    (1 << 1)
	DWORD m_dwState;

    // !!! λöУ򱾳ԱΪöֵ
	INT m_nDefault;
		// ϵͳ飩Ĭֵָ
		//     1ֱͣΪֵΪСָֻ֣
		//		  ΪָֻINTֵIJ֣
		//     2߼ͣ1棬0ڼ٣
		//     3ıͣʱΪLPTSTRָ룬ָĬı
		//     4ͲԶͣһĬֵָ
} LIB_DATA_TYPE_ELEMENT;
typedef LIB_DATA_TYPE_ELEMENT* PLIB_DATA_TYPE_ELEMENT;

// ̶ԵĿ
#define	FIXED_WIN_UNIT_PROPERTY_COUNT	8

// ÿ̶Զ
#define	FIXED_WIN_UNIT_PROPERTY	\
	{	_WT(""),    _WT("left"),        NULL,	UD_INT,     _PROP_OS (OS_ALL),	NULL },	\
	{	_WT(""),    _WT("top"),         NULL,	UD_INT,     _PROP_OS (OS_ALL),	NULL },	\
	{	_WT(""),    _WT("width"),       NULL,	UD_INT,     _PROP_OS (OS_ALL),	NULL },	\
	{	_WT("߶"),    _WT("height"),      NULL,	UD_INT,     _PROP_OS (OS_ALL),	NULL },	\
	{	_WT(""),    _WT("tag"),         NULL,	UD_TEXT,	_PROP_OS (OS_ALL),	NULL },	\
	{	_WT(""),    _WT("visible"),     NULL,	UD_BOOL,	_PROP_OS (OS_ALL),	NULL },	\
	{	_WT("ֹ"),    _WT("disable"),     NULL,	UD_BOOL,	_PROP_OS (OS_ALL),	NULL },	\
	{	_WT("ָ"),_WT("MousePointer"),NULL,	UD_CURSOR,	_PROP_OS (OS_ALL),	NULL }

// ԣעⲻҪ֧֡
typedef struct
{
	LPTSTR m_szName;
		// ƣעΪԱͬʱöԣƱ߶һ¡
	LPTSTR m_szEgName;
	LPTSTR m_szExplain;		// Խ͡

// ע⣺ݸʽPFN_NOTIFY_PROPERTY_CHANGED֪ͨ
	#define		UD_PICK_SPEC_INT    1000	// ΪINTֵûֻѡ񣬲ܱ༭

	#define		UD_INT			1001	// ΪINTֵ
	#define		UD_DOUBLE		1002	// ΪDOUBLEֵ
	#define		UD_BOOL			1003	// ΪBOOLֵ
	#define		UD_DATE_TIME	1004	// ΪDATEֵ
	#define		UD_TEXT			1005	// Ϊַ

	#define		UD_PICK_INT			1006	// ΪINTֵûֻѡ񣬲ܱ༭
	#define		UD_PICK_TEXT		1007	// Ϊַûֻѡ񣬲ܱ༭
	#define		UD_EDIT_PICK_TEXT	1008	// ΪַûԱ༭

	#define		UD_PIC			1009	// ΪͼƬļ
	#define		UD_ICON			1010	// Ϊͼļ
	#define		UD_CURSOR		1011
		//   һINT¼ֵָͣLoadCursorΪ-1
		// ΪԶָ룬ʱӦȵָļݡ
	#define		UD_MUSIC		1012	// Ϊļ

	#define		UD_FONT			1013
		//   ΪһLOGFONTݽṹٸġ
	#define		UD_COLOR		1014
		// ΪCOLORREFֵ
	#define		UD_COLOR_TRANS	1015
		// ΪCOLORREFֵ͸ɫ(CLR_DEFAULT)
	#define		UD_FILE_NAME	1016
		// Ϊļַʱm_szzPickStrеΪ
		//   Ի\0 + ļ\0 + ĬϺ׺\0 +
		//   "1"ȡļ"0"ȡļ\0
	#define		UD_COLOR_BACK	1017
		// ΪCOLORREFֵϵͳĬϱɫ(CLR_DEFAULT)
	#define		UD_IMAGE_LIST		1023
		// ͼƬ飬ݽṹΪ
		#define	IMAGE_LIST_DATA_MARK	(MAKELONG ('IM', 'LT'))
		/*
		DWORD: ־ݣΪ IMAGE_LIST_DATA_MARK
		COLORREF: ͸ɫΪCLR_DEFAULT
		ΪͼƬ.CImageList::ReadCImageList::Writeд
		*/
	#define		UD_CUSTOMIZE		1024

#define	UD_BEGIN	UD_PICK_SPEC_INT
#define	UD_END		UD_CUSTOMIZE

	SHORT m_shtType;	// Ե͡

	#define	UW_HAS_INDENT		(1 << 0)	// ԱʾʱһΣһԡ
	#define	UW_GROUP_LINE		(1 << 1)	// Աбʾ׷ߡ
	#define	UW_ONLY_READ		(1 << 2)
		// ֻԣʱãʱд
	#define	UW_CANNOT_INIT		(1 << 3)
		// ʱãʱдϱ־⡣
    #define UW_IS_HIDED         (1 << 4)    // 3.2 
        // صá
    //!!! עλ __OS_xxxx ֵָ֧IJϵͳ
    #define _PROP_OS(os)     ((os) >> 16)  // תosԱ뵽m_wState
    #define _TEST_PROP_OS(m_wState,os)    ((_PROP_OS (os) & m_wState) != 0) // ָǷָ֧ϵͳ
	WORD m_wState;

	LPTSTR m_szzPickStr;
		// ˳¼еıѡıUD_FILE_NAMEһմ
		// m_nTypeΪUP_PICK_INTUP_PICK_TEXTUD_EDIT_PICK_TEXTUD_FILE_NAMEʱΪNULL
        // m_nTypeΪUD_PICK_SPEC_INTʱÿһѡıĸʽΪ ֵı + "\0" + ˵ı + "\0" 
} UNIT_PROPERTY;
typedef UNIT_PROPERTY* PUNIT_PROPERTY;

///////////////////////////////// 3.2 ǰʹõ¼Ϣһ汾

typedef struct
{
	LPTSTR		m_szName;				// 
	LPTSTR		m_szExplain;			// ϸ

	#define EAS_IS_BOOL_ARG     (1 << 0)	// Ϊ߼Ͳ޴˱־ĬΪͲ
	DWORD		m_dwState;		// MASK
}
EVENT_ARG_INFO, *PEVENT_ARG_INFO;

typedef struct
{
	LPTSTR		m_szName;			// ¼
	LPTSTR		m_szExplain;		// ¼ϸ

	// ¼ǷΪ¼ܱһûʹû򱻷Ϊ˱ּҪڵ¼
	#define		EV_IS_HIDED			(1 << 0)

	// #define		EV_IS_MOUSE_EVENT	(1 << 1)    // 3.2
	#define		EV_IS_KEY_EVENT		(1 << 2)

	#define		EV_RETURN_INT		(1 << 3)	// һ
	#define		EV_RETURN_BOOL		(1 << 4)	// һ߼ֵϱ־⡣
    //!!! עλ __OS_xxxx ָ¼ֵ֧IJϵͳ
    #define _EVENT_OS(os)     ((os) >> 1)  // תosԱ뵽m_dwState
    #define _TEST_EVENT_OS(m_dwState,os)    ((_EVENT_OS (os) & m_dwState) != 0) // ָ¼Ƿָ֧ϵͳ
	DWORD		m_dwState;  // Բܶɷıֽڼ͵ҪռͷŴ͡

	INT             m_nArgCount;		// ¼IJĿ
	PEVENT_ARG_INFO m_pEventArgInfo;	// ¼
}
EVENT_INFO, *PEVENT_INFO;

///////////////////////////////// 3.2 Ժʹõ¼Ϣڶ汾

// עײȫ EVENT_ARG_INFO 
typedef struct
{
	LPTSTR		m_szName;       // 
	LPTSTR		m_szExplain;    // ϸ

    // ǷҪԲοʽֵλֿ֧׳¼Ĵȷܹϵͳ
    // ڴķݵĸʽҪ󣩡
	#define     EAS_BY_REF      (1 << 1)    // ʹ (1 << 0)
	DWORD		m_dwState;		// MASK

	DATA_TYPE	m_dtDataType;
}
EVENT_ARG_INFO2, *PEVENT_ARG_INFO2;

// עײȫ EVENT_INFO 
typedef struct
{
	LPTSTR		m_szName;			// ¼
	LPTSTR		m_szExplain;		// ¼ϸ

    // »״ֵ̬ EVENT_INFO еĶͬ
	// #define		EV_IS_HIDED			(1 << 0)    // ¼ǷΪ¼ܱһûʹû򱻷Ϊ˱ּҪڵ¼
    // #define		EV_IS_KEY_EVENT		(1 << 2)
    #define     EV_IS_VER2  (1 << 31)   // ʾṹΪEVENT_INFO2!!!ʹñṹʱϴ״ֵ̬
    //!!! עλ __OS_xxxx ָ¼ֵ֧IJϵͳ
    // #define _EVENT_OS(os)     ((os) >> 1)  // תosԱ뵽m_dwState
    // #define _TEST_EVENT_OS(m_dwState,os)    ((_EVENT_OS (os) & m_dwState) != 0) // ָ¼Ƿָ֧ϵͳ
	DWORD		m_dwState;

	INT				    m_nArgCount;		// ¼IJĿ
	PEVENT_ARG_INFO2    m_pEventArgInfo;	// ¼

    //!!! жҪͷţҪֿ֧׳¼Ĵ븺ͷš
    DATA_TYPE m_dtRetDataType;
}
EVENT_INFO2, *PEVENT_INFO2;

////////////////////////////////////

typedef DWORD  HUNIT;

// ͨýӿָ롣
typedef void (WINAPI *PFN_INTERFACE) ();

// ȡָĽӿڡ
#define	ITF_CREATE_UNIT					1		// 
#define	ITF_PROPERTY_UPDATE_UI			2		// ָĿǰɷ޸
#define	ITF_DLG_INIT_CUSTOMIZE_DATA		3		// ʹöԻøӶ
#define	ITF_NOTIFY_PROPERTY_CHANGED		4		// ֪ͨijݱû޸
#define	ITF_GET_ALL_PROPERTY_DATA		5		// ȡȫ
#define	ITF_GET_PROPERTY_DATA			6		// ȡij
#define	ITF_GET_ICON_PROPERTY_DATA		7		// ȡڵͼݣڴڣ
#define	ITF_IS_NEED_THIS_KEY			8		// ѯǷҪָİϢ
		// ػĬΪϵͳİTABSHIFT+TABUPDOWNȡ
#define ITF_LANG_CNV                    9       // ת
#define ITF_MSG_FILTER                  11      // Ϣ
#define ITF_GET_NOTIFY_RECEIVER         12      // ȡĸ֪ͨ(PFN_ON_NOTIFY_UNIT)
#if _MSC_VER == 1200
	typedef INT (WINAPI *PFN_ON_NOTIFY_UNIT) (INT nMsg, DWORD dwParam1 = 0, DWORD dwParam2 = 0);
#else
	typedef INT(WINAPI* PFN_ON_NOTIFY_UNIT) (INT nMsg, DWORD dwParam1, DWORD dwParam2);
#endif
	#define NU_GET_CREATE_SIZE_IN_DESIGNER		0
	// ȡʱõʱĬϴߴ.
	// dwParam1: : INT*, ؿ(λ)
	// dwParam2: : INT*, ظ߶(λ)
	// ɹ1,ʧܷ0.

typedef PFN_INTERFACE (WINAPI *PFN_GET_INTERFACE) (INT nInterfaceNO);

//////////////////////////////////// ӿڣ

// ɹʱشھphUnitзʧܷNULL
// hDesignWndblInDesignModeΪʱЧΪƴĴھ
typedef HUNIT (WINAPI *PFN_CREATE_UNIT) (LPBYTE pAllData, INT nAllDataSize,
		DWORD dwStyle, HWND hParentWnd, UINT uID, HMENU hMenu, INT x, INT y, INT cx, INT cy,
		DWORD dwWinFormID, DWORD dwUnitID,			// ֪ͨϵͳ
    #if __GCC_ || _MSC_VER == 1200
		HWND hDesignWnd = 0, BOOL blInDesignMode = FALSE);
    #else
		HWND hDesignWnd, BOOL blInDesignMode);
    #endif

// dwStateΪºֵϡ
#define CNV_NULL        0
#define CNV_FONTNAME    (1 << 0)    // Ϊת(ڿܱ䳤
                                    // psб뱣֤㹻Ŀռת)
typedef void (WINAPI* PFN_CNV)(char* ps, DWORD dwState, int nParam);
// תذתݵHGLOBALʧܷNULL
typedef HGLOBAL (WINAPI *PFN_LANG_CNV) (LPBYTE pAllData, LPINT pnAllDataSize,
		PFN_CNV fnCnv, int nParam);  // nParamԭֵݸfnCnvĶӦ

// ºʱʹá

//   ָĿǰԱ棬򷵻ؼ١
typedef BOOL (WINAPI *PFN_PROPERTY_UPDATE_UI) (HUNIT hUnit, INT nPropertyIndex);

//   иӶݣʹöԻЩݣ޸ڲݼΣ
// Ҫ´޸Σ档pblModifiedΪNULLз
// ޸״̬
typedef BOOL (WINAPI *PFN_DLG_INIT_CUSTOMIZE_DATA) (HUNIT hUnit, INT nPropertyIndex,
    #if __GCC_ || _MSC_VER == 1200
		BOOL* pblModified = NULL, LPVOID pResultExtraData = NULL);
    #else
		BOOL* pblModified, LPVOID pResultExtraData);
    #endif

// ¼ijԵֵ
union UNIT_PROPERTY_VALUE
{
	INT			m_int;			// UD_INTUD_PICK_INTUD_PICK_SPEC_INT
	DOUBLE		m_double;		// UD_DOUBLE
	BOOL		m_bool;			// UD_BOOL
	DATE		m_dtDateTime;	// UD_DATE_TIME
	COLORREF	m_clr;			// UD_COLORUD_COLOR_TRANSUD_COLOR_BACK
	LPTSTR		m_szText;		// UD_TEXTUD_PICK_TEXTUD_EDIT_PICK_TEXT
			// UD_DATA_SOURCE_NAMEUD_DATA_PROVIDER_NAMEUD_DSCOL_NAME
			// UD_ODBC_CONNECT_STRUD_ODBC_SELECT_STR
	LPTSTR		m_szFileName;	// UD_FILE_NAME

	struct
	{
		LPBYTE		m_pData;
		INT			m_nDataSize;
	} m_data;
	/*
		UD_PICUD_ICONUD_CURSORUD_MUSICUD_FONTUD_CUSTOMIZEUD_IMAGE_LIST
	*/

#ifndef __GCC_
	UNIT_PROPERTY_VALUE ()
	{
		memset ((LPBYTE)this, 0, sizeof (UNIT_PROPERTY_VALUE));
	}

	BOOL IsSame (INT nDataType, UNIT_PROPERTY_VALUE& val)
	{
		switch (nDataType)
		{
		case UD_INT:
		case UD_PICK_INT:
        case UD_PICK_SPEC_INT:
			return m_int == val.m_int;
		case UD_DOUBLE:
			return m_double == val.m_double;
		case UD_BOOL:
			return m_bool == val.m_bool;
		case UD_DATE_TIME:
			return m_dtDateTime == val.m_dtDateTime;
		case UD_COLOR:
		case UD_COLOR_TRANS:
		case UD_COLOR_BACK:
			return m_clr == val.m_clr;
		case UD_TEXT:
		case UD_PICK_TEXT:
		case UD_EDIT_PICK_TEXT:
		/*case UD_DATA_SOURCE_NAME:
		case UD_DATA_PROVIDER_NAME:
		case UD_DSCOL_NAME:
		case UD_ODBC_CONNECT_STR:
		case UD_ODBC_SELECT_STR:*/
			return m_szText == NULL && val.m_szText == NULL ||
					m_szText != NULL && val.m_szText != NULL &&
					strcmp (m_szText, val.m_szText) == 0;
		case UD_FILE_NAME:
			return m_szFileName == NULL && val.m_szFileName == NULL ||
					m_szFileName != NULL && val.m_szFileName != NULL &&
					strcmp (m_szFileName, val.m_szFileName) == 0;
		case UD_PIC:
		case UD_ICON:
		case UD_CURSOR:
		case UD_MUSIC:
		case UD_FONT:
		case UD_CUSTOMIZE:
		case UD_IMAGE_LIST:
			if (m_data.m_nDataSize == val.m_data.m_nDataSize)
			{
				if (m_data.m_nDataSize == 0)
					return TRUE;
				else
					return memcmp (m_data.m_pData, val.m_data.m_pData, m_data.m_nDataSize) == 0;
			}
			break;
		default:
			//ASSERT (FALSE);
			break;
		}

		return FALSE;
	}
#endif
};
typedef union UNIT_PROPERTY_VALUE* PUNIT_PROPERTY_VALUE;

//   ֪ͨijһԣǶԣݱû޸ģ޸ڲݼΣȷʵҪ
// ´޸Σ档κӦʾϢصppszTipTextС
//   ע⣺ֵĺϷУ顣
typedef BOOL (WINAPI *PFN_NOTIFY_PROPERTY_CHANGED) (HUNIT hUnit, INT nPropertyIndex,
    #if __GCC_ || _MSC_VER == 1200
		PUNIT_PROPERTY_VALUE pPropertyVaule, LPTSTR* ppszTipText = NULL);
    #else
		PUNIT_PROPERTY_VALUE pPropertyVaule, LPTSTR* ppszTipText);
    #endif

// ȡijݵpPropertyVauleУɹ棬򷵻ؼ١
// !! 1ʱܱûı䣨ֱӵAPIԣʱȡʵֵ
// !! 2ȡصıֽڼȷжڴָ룬ͷţ׳򲢲Ὣͷš
typedef BOOL (WINAPI *PFN_GET_PROPERTY_DATA) (HUNIT hUnit, INT nPropertyIndex,
		PUNIT_PROPERTY_VALUE pPropertyVaule);

// ȡȫ
typedef HGLOBAL (WINAPI *PFN_GET_ALL_PROPERTY_DATA) (HUNIT hUnit);

// ȡڵͼݣڴڣ
typedef HGLOBAL (WINAPI *PFN_GET_ICON_PROPERTY_DATA) (LPBYTE pAllData, INT nAllDataSize);

// ѯǷҪָİϢҪ棬򷵻ؼ١
typedef BOOL (WINAPI *PFN_IS_NEED_THIS_KEY) (HUNIT hUnit, WORD wKey);

// Ϣ(Ϣ˴Ч,LDT_MSG_FILTER_CONTROL)˵棬򷵻ؼ١
typedef BOOL (WINAPI *PFN_MESSAGE_FILTER) (void* pMsg); // WindowsϵͳpMsgΪMSG*ָ롣

////////////////////////////////////

#define	UNIT_BMP_SIZE			24		// ־λͼĿȺ͸߶ȡ
#define	UNIT_BMP_BACK_COLOR		(RGB (192, 192, 192))	// ־λͼıɫ

//!!!   עm_pElementBeginm_pPropertyBeginֻһΪNULLm_nElementCount
//!!! m_nPropertyCountֻһΪ0

typedef struct  // ⶨͽṹ
{
	LPTSTR m_szName;  // ͵ƣ磺߾ȵȣ
	LPTSTR m_szEgName;
		// ͵Ӣƣ磺intdoubleȵȣΪջNULL
	LPTSTR m_szExplain;   // ͵ϸͣΪNULL

	INT m_nCmdCount;
		// ṩijԱĿΪ0
	LPINT m_pnCmdsIndex;	// ˳¼гԱڿеֵΪNULL

//   ǷΪͣûֱͣ类
// Ϊ˱ּҪڵͣ
	#define		LDT_IS_HIDED				(1 << 0)
// ڱвʹãд˱־һ
// ʹд˱־͵Ҳ塣
	#define		LDT_IS_ERROR				(1 << 1)
//   ǷΪڻڴʹõ˱־λm_nElementCountΪ0
	#define		LDT_WIN_UNIT				(1 << 6)
// ǷΪд˱־LDT_WIN_UNITλ
	#define		LDT_IS_CONTAINER			(1 << 7)
//ǷΪTABؼ(ѡ) 4.0
	#define		LDT_IS_TAB_UNIT				(1 << 8)
// ṩܵĴʱӣ˱־λLDT_WIN_UNITλ
// д˱־ߴ̶Ϊ32*32ʱ޿Ρ
	#define		LDT_IS_FUNCTION_PROVIDER	(1 << 15)
// ˱־λʾܽ뽹㣬TABͣ
	#define		LDT_CANNOT_GET_FOCUS		(1 << 16)
// ˱־λʾĬϲͣTABʹñ־ϱ־λ
	#define		LDT_DEFAULT_NO_TABSTOP		(1 << 17)
// ǷΪö͡
	#define		LDT_ENUM				    (1 << 22)   // 3.7
// ǷΪϢ
	#define		LDT_MSG_FILTER_CONTROL		(1 << 5)
    //!!! עλ __OS_xxxx ֵָ֧IJϵͳ
    #define _DT_OS(os)     (os)  // תosԱ뵽m_dwState
    #define _TEST_DT_OS(m_dwState,os)    ((_DT_OS (os) & m_dwState) != 0) // ָǷָ֧ϵͳ
	DWORD m_dwState;

////////////////////////////////////////////
// ±ֻΪڡ˵ҲΪöʱЧ

	DWORD m_dwUnitBmpID;		// ָڿеͼԴID0Ϊޡ
                                // OCXװУm_dwUnitBmpIDָͼԴID

	INT m_nEventCount;
	PEVENT_INFO2 m_pEventBegin;	// 屾¼

	INT m_nPropertyCount;
	PUNIT_PROPERTY m_pPropertyBegin;

	PFN_GET_INTERFACE m_pfnGetInterface;

////////////////////////////////////////////
// ±ֻڲΪڡ˵ΪöʱЧ

	// ĿΪڡ˵˱ֵΪ0
	INT	m_nElementCount;
	PLIB_DATA_TYPE_ELEMENT m_pElementBegin;  // ָݳԱ顣
} LIB_DATA_TYPE_INFO;
typedef LIB_DATA_TYPE_INFO* PLIB_DATA_TYPE_INFO;

/*////////////////////////////////////////////*/

typedef struct  // ⳣݽṹ
{
	LPTSTR	m_szName;
	LPTSTR	m_szEgName;
	LPTSTR	m_szExplain;

	SHORT	m_shtLayout;

	#define	CT_NULL			0
	#define	CT_NUM			1	// value sample: 3.1415926
	#define	CT_BOOL			2	// value sample: 1
	#define	CT_TEXT			3	// value sample: "abc"
	SHORT	m_shtType;

	LPTSTR	m_szText;		// CT_TEXT
	DOUBLE	m_dbValue;		// CT_NUMCT_BOOL
} LIB_CONST_INFO;
typedef LIB_CONST_INFO* PLIB_CONST_INFO;

//////////////////////////////////////////// ݽṹ

typedef union
{
	BYTE	m_byte;
	SHORT	m_short;
	INT		m_int;
	INT64	m_int64;
	FLOAT	m_float;
	DOUBLE	m_double;
}
SYS_NUM_VALUE, *PSYS_NUM_VALUE;

typedef struct
{
    DWORD m_dwFormID;
    DWORD m_dwUnitID;
}
MUNIT, *PMUNIT;

typedef struct
{
    DWORD m_dwStatmentSubCodeAdr;   // ¼صӳĽַ
    DWORD m_dwSubEBP;       // ¼ӳEBPָ룬Աʸӳеľֲ
}
STATMENT_CALL_DATA, *PSTATMENT_CALL_DATA;

#ifndef __GCC_
    #pragma pack (push, old_value)   // VC++ṹֽ
    #pragma pack (1)    // Ϊһֽڶ롣
#endif

typedef struct
{
    union
    {
	    BYTE	      m_byte;         // SDT_BYTE
	    SHORT	      m_short;        // SDT_SHORT
	    INT		      m_int;          // SDT_INT
	    DWORD	      m_uint;         // (DWORD)SDT_INT
	    INT64	      m_int64;        // SDT_INT64
	    FLOAT	      m_float;        // SDT_FLOAT
	    DOUBLE	      m_double;       // SDT_DOUBLE
        DATE          m_date;         // SDT_DATE_TIME
        BOOL          m_bool;         // SDT_BOOL
        char*         m_pText;        // SDT_TEXTΪNULL
                                      // !!!Ϊ˱޸ĵ(m_pTextпָ)еݣ
                                      // ֻɶȡɸеݣͬ
        LPBYTE        m_pBin;         // SDT_BINΪNULL!!!ֻɶȡɸеݡ
        DWORD         m_dwSubCodeAdr; // SDT_SUB_PTR¼ӳַ
        STATMENT_CALL_DATA  m_statment;     // SDT_STATMENT͡
        MUNIT         m_unit;         // ˵͡
        void*         m_pCompoundData;// ָ룬ָָݵĸʽ run.h 
                                      // ֱӸеݳԱҪͷŸóԱ
        void*         m_pAryData;     // ָ룬ָָݵĸʽ run.h 
                                      // עΪıֽڼ飬ԱָΪNULL
                                      // !!! ֻɶȡɸеݡ

        // Ϊַָָ룬ʵֺʱá
	    BYTE*	m_pByte;         // SDT_BYTE*
	    SHORT*	m_pShort;        // SDT_SHORT*
	    INT*	m_pInt;          // SDT_INT*
	    DWORD*	m_pUInt;         // ((DWORD)SDT_INT)*
	    INT64*	m_pInt64;        // SDT_INT64*
	    FLOAT*	m_pFloat;        // SDT_FLOAT*
	    DOUBLE*	m_pDouble;       // SDT_DOUBLE*
        DATE*   m_pDate;         // SDT_DATE_TIME*
        BOOL*   m_pBool;         // SDT_BOOL*
        char**  m_ppText;        // SDT_TEXT*m_ppTextΪNULL
                                 // עдֵ֮ǰͷǰֵMFree (*m_ppText)
                                 // !!!ֱӸ*m_ppTextָݣֻͷԭָָ롣
        LPBYTE* m_ppBin;         // SDT_BIN*m_ppBinΪNULL
                                 // עдֵ֮ǰͷǰֵMFree (*m_ppBin)
                                 // !!!ֱӸ*m_ppBinָݣֻͷԭָָ롣
        DWORD*  m_pdwSubCodeAdr; // SDT_SUB_PTRӳַ
        PSTATMENT_CALL_DATA m_pStatment;   // SDT_STATMENTͱ
        PMUNIT   m_pUnit;           // ˵ͱ
        void**  m_ppCompoundData;   // ͱ
                                    // ֱӸеݳԱҪͷŸóԱ
        void**  m_ppAryData;        // ݱע⣺
                                    // 1дֵ֮ǰͷԭֵʹNRS_FREE_VAR֪ͨ
                                    // 2Ϊıֽڼ飬ԱָΪNULL
                                    // !!!ֱӸ*m_ppAryDataָݣֻͷԭָָ롣
    };

    // 1ʱò AS_RECEIVE_VAR_OR_ARRAY 
    //    AS_RECEIVE_ALL_TYPE_DATA ־Ϊݣ־ DT_IS_ARY 
    //    Ҳ DT_IS_ARY ־Ψһʹóϡ
    // 2ݲʱΪհݣΪ _SDT_NULL 
    DATA_TYPE m_dtDataType;
} MDATA_INF;
typedef MDATA_INF* PMDATA_INF;

#ifndef __GCC_
    #pragma pack (pop, old_value)    // ָVC++ṹֽ
#endif

//////////////////////////////////////////// ֪ͨݽṹ

/*/////////////*/
// ֪ͨϵͳֵ

#ifndef __GCC_
struct MDATA
{
	MDATA ()
	{
		m_pData = NULL;
		m_nDataSize = 0;
	}
#else
typedef struct
{
#endif

	LPBYTE	m_pData;
	INT		m_nDataSize;

#ifndef __GCC_
};
#else
} MDATA;
#endif
typedef MDATA* PMDATA;

// һ¼֪ͨ
#ifndef __GCC_
struct EVENT_NOTIFY
#else
typedef struct
#endif
{
	// ¼¼Դ
	DWORD	m_dwFormID;		//  ID
	DWORD	m_dwUnitID;		//  ID
	INT		m_nEventIndex;	// ¼

	INT		m_nArgCount;		// ¼ݵIJĿ 5 
	INT		m_nArgValue [5];	// ¼ֵSDT_BOOL ͲֵΪ 1  0

    //!!! עԱûж巵ֵ¼Ч
	// û¼ӳ¼Ƿзֵ
	BOOL	m_blHasRetVal;
	// û¼ӳ¼ķֵ߼ֵֵ 0٣  1棩 ء
	INT		m_nRetVal;

    /////////////////////////////////////

#ifndef __GCC_
	EVENT_NOTIFY (DWORD dwFormID, DWORD dwUnitID, INT nEventIndex)
	{
		m_dwFormID = dwFormID;
		m_dwUnitID = dwUnitID;
		m_nEventIndex = nEventIndex;

		m_nArgCount = 0;
		m_blHasRetVal = FALSE;
		m_nRetVal = 0;
	}
};
#else
} EVENT_NOTIFY;
#endif
typedef EVENT_NOTIFY* PEVENT_NOTIFY;

typedef struct
{
    MDATA_INF m_inf;

    // m_infǷΪָݡ
    //!!! ע m_inf.m_dtDataType Ϊıֽ͡ڼ͡ⶨͣڵԪ˵ͣ
    // 봫ָ룬DZλ
    #define EAV_IS_POINTER  (1 << 0)
    #define EAV_IS_WINUNIT  (1 << 1)    // ˵m_inf.m_dtDataTypeǷΪڵԪ
                                        // !!!עm_inf.m_dtDataTypeΪڵԪ˱DZλ
    DWORD m_dwState;
}
EVENT_ARG_VALUE, *PEVENT_ARG_VALUE;

// ڶ¼֪ͨ
#ifndef __GCC_
struct EVENT_NOTIFY2
#else
typedef struct
#endif
{
	// ¼¼Դ
	DWORD m_dwFormID;  //  ID
	DWORD m_dwUnitID;  //  ID
	INT m_nEventIndex;  // ¼

    #define MAX_EVENT2_ARG_COUNT    12
	INT m_nArgCount;  // ¼ݵIJĿ MAX_EVENT2_ARG_COUNT 
	EVENT_ARG_VALUE m_arg [MAX_EVENT2_ARG_COUNT];  // ¼ֵ

    //!!! עԱûж巵ֵ¼Ч
	// û¼ӳ¼Ƿзֵ
	BOOL m_blHasRetVal;
    // ¼û¼ӳ¼ķֵעеm_infRetData.m_dtDataTypeԱδʹá
    MDATA_INF m_infRetData;

    /////////////////////////////////////

#ifndef __GCC_
	EVENT_NOTIFY2 (DWORD dwFormID, DWORD dwUnitID, INT nEventIndex)
	{
		m_dwFormID = dwFormID;
		m_dwUnitID = dwUnitID;
		m_nEventIndex = nEventIndex;
		m_nArgCount = 0;
		m_blHasRetVal = FALSE;
        m_infRetData.m_dtDataType = _SDT_NULL;
	}
};
#else
} EVENT_NOTIFY2;
#endif
typedef EVENT_NOTIFY2* PEVENT_NOTIFY2;

typedef struct
{
	HICON	m_hBigIcon;
	HICON	m_hSmallIcon;
} APP_ICON;
typedef APP_ICON* PAPP_ICON;

/*///////////////////////*/

// NES_ Ϊױ༭֪ͨ
#define NES_GET_MAIN_HWND			        1
	// ȡױ༭ڵľֿ֧֧AddIn
#define	NES_RUN_FUNC				        2
	// ֪ͨױ༭ָĹܣһBOOLֵ
	// dwParam1Ϊܺš
	// dwParam2Ϊһ˫DWORDָ,ֱṩܲ12
#define NES_PICK_IMAGE_INDEX_DLG            7
    // ֪ͨױ༭ʾһԻгָͼƬڵͼƬûѡͼƬš
    // dwParam1ΪЧͼƬ
    //   dwParam2ΪNULLϵͳΪΪһ༭HWNDھûЧѡ
    // ϵͳԶĴ˱༭ݲתȥ
    // ûѡͼƬ(-1ʾûѡͼƬ)ûδѡ򷵻-2

// NAS_ Ϊȱױ༭ֱл֪ͨ
#define	NAS_GET_APP_ICON			        1000
	// ֪ͨϵͳسͼꡣ
	// dwParam1ΪPAPP_ICONָ롣
#define NAS_GET_LIB_DATA_TYPE_INFO          1002
    // ָⶨ͵PLIB_DATA_TYPE_INFOϢָ롣
    // dwParam1Ϊ͡
    // Ч߲Ϊⶨͣ򷵻NULL򷵻PLIB_DATA_TYPE_INFOָ롣
#define NAS_GET_HBITMAP                     1003
    // dwParam1ΪͼƬָ룬dwParam2ΪͼƬݳߴ硣
    // ɹطNULLHBITMAPעʹϺͷţ򷵻NULL
#define NAS_GET_LANG_ID                     1004
    // صǰϵͳлֵ֧IDIDֵlang.h
#define NAS_GET_VER                         1005
    // صǰϵͳлİ汾ţLOWORDΪ汾ţHIWORDΪΰ汾š
#define NAS_GET_PATH                        1006
    /* صǰлijһĿ¼ļĿ¼ԡ\
       dwParam1: ָҪĿ¼Ϊֵ
         Aл¾ЧĿ¼:
            1: лϵͳĿ¼
         BЧĿ¼(Ч):
            1001: ϵͳֿ̺֧Ŀ¼
            1002: ϵͳĿ¼
            1003: ϵͳϢĿ¼
            1004: еǼǵϵͳģĿ¼
            1005: ֿ֧ڵĿ¼
            1006: װĿ¼
         CлЧĿ¼(лЧ):
            2001: ûEXEļĿ¼
            2002: ûEXEļ
       dwParam2: ջַߴΪMAX_PATH
    */
#define NAS_CREATE_CWND_OBJECT_FROM_HWND    1007
    // ָͨHWNDһCWND󣬷ָ룬סָͨNRS_DELETE_CWND_OBJECTͷ
    // dwParam1ΪHWND
    // ɹCWnd*ָ룬ʧܷNULL
#define NAS_DELETE_CWND_OBJECT              1008
    // ɾͨNRS_CREATE_CWND_OBJECT_FROM_HWNDCWND
    // dwParam1ΪɾCWndָ
#define NAS_DETACH_CWND_OBJECT              1009
    // ȡͨNRS_CREATE_CWND_OBJECT_FROM_HWNDCWNDHWNDİ
    // dwParam1ΪCWndָ
    // ɹHWND,ʧܷ0
#define NAS_GET_HWND_OF_CWND_OBJECT         1010
    // ȡͨNRS_CREATE_CWND_OBJECT_FROM_HWNDCWNDеHWND
    // dwParam1ΪCWndָ
    // ɹHWND,ʧܷ0
#define NAS_ATTACH_CWND_OBJECT              1011
    // ָHWNDͨNRS_CREATE_CWND_OBJECT_FROM_HWNDCWND
    // dwParam1ΪHWND
    // dwParam2ΪCWndָ
    // ɹ1,ʧܷ0
#define	NAS_IS_EWIN							1014
    // ָΪԴڻ棬򷵻ؼ١
    // dwParam1ΪԵHWND.

// NRS_ Ϊܱл֪ͨ
#define NRS_UNIT_DESTROIED			        2000
	// ֪ͨϵͳָѾ١
	// dwParam1ΪdwFormID
	// dwParam2ΪdwUnitID
#define NRS_CONVERT_NUM_TO_INT              2001
	// תֵʽ
	// dwParam1Ϊ PMDATA_INF ָ룬 m_dtDataType Ϊֵ͡
    // תֵ
#define NRS_GET_CMD_LINE_STR			    2002
	// ȡǰı
	// ıָ룬пΪմ
#define NRS_GET_EXE_PATH_STR                2003
	// ȡǰִļĿ¼
	// صǰִļĿ¼ıָ롣
#define NRS_GET_EXE_NAME				    2004
	// ȡǰִļ
	// صǰִļıָ롣
#define NRS_GET_UNIT_PTR				    2006
	// ȡָ
	// dwParam1ΪWinFormID
	// dwParam2ΪWinUnitID
	// ɹЧCWnd*ָ룬ʧܷ0
#define NRS_GET_AND_CHECK_UNIT_PTR			2007
	// ȡָ
	// dwParam1ΪWinFormID
	// dwParam2ΪWinUnitID
	// ɹЧCWnd*ָ룬ʧܱʱ˳
#define NRS_EVENT_NOTIFY				    2008
	// Եһ෽ʽ֪ͨϵͳ¼
	// dwParam1ΪPEVENT_NOTIFYָ롣
	//    0 ʾ¼ѱϵͳʾϵͳѾɹݴ¼û
	// ¼ӳ
#define	NRS_DO_EVENTS			            2018
	// ֪ͨϵͳд¼
#define NRS_GET_UNIT_DATA_TYPE              2022
	// dwParam1ΪWinFormID
	// dwParam2ΪWinUnitID
	// ɹЧ DATA_TYPE ʧܷ 0 
#define NRS_FREE_ARY                        2023
    // ͷָݡ
    // dwParam1ΪݵDATA_TYPEֻΪϵͳ͡
    // dwParam2Ϊָݵָ롣
#define NRS_MALLOC                          2024
    // ָռڴ棬׳򽻻ڴ涼ʹñ֪ͨ䡣
    //   dwParam1Ϊڴֽ
    //   dwParam2Ϊ0ʧܾԶʱ˳
    // 粻Ϊ0ʧܾͷNULL
    //   ڴ׵ַ
#define NRS_MFREE                           2025
    // ͷѷָڴ档
    // dwParam1Ϊͷڴ׵ַ
#define NRS_MREALLOC                        2026
    // ·ڴ档
    //   dwParam1Ϊ·ڴߴ׵ַ
    //   dwParam2Ϊ·ڴֽ
    // ·ڴ׵ַʧԶʱ˳
#define	NRS_RUNTIME_ERR			            2027
	// ֪ͨϵͳѾʱ
	// dwParam1Ϊchar*ָ룬˵ı
#define	NRS_EXIT_PROGRAM                    2028
	// ֪ͨϵͳ˳û
	// dwParam1Ϊ˳룬ô뽫صϵͳ
#define NRS_GET_PRG_TYPE                    2030
    // صǰûͣΪPT_DEBUG_RUN_VER԰棩PT_RELEASE_RUN_VER棩
#define NRS_EVENT_NOTIFY2				    2031
	// Եڶ෽ʽ֪ͨϵͳ¼
	// dwParam1ΪPEVENT_NOTIFY2ָ롣
	//    0 ʾ¼ѱϵͳʾϵͳѾɹݴ¼û
	// ¼ӳ
#define NRS_GET_WINFORM_COUNT               2032
    // صǰĴĿ
#define NRS_GET_WINFORM_HWND                2033
    // ָĴھôδ룬NULL
	// dwParam1Ϊ
#define NRS_GET_BITMAP_DATA                 2034
    // ָHBITMAPͼƬݣɹذBMPͼƬݵHGLOBALʧܷNULL
	// dwParam1ΪȡͼƬݵHBITMAP
#define NRS_FREE_COMOBJECT                  2035
    // ֪ͨϵͳͷָDTP_COM_OBJECTCOM
    // dwParam1ΪCOMĵַָ롣
#define NRS_CHK_TAB_VISIBLE                 2039
	// ѡӼбл, ʹñϢ֪ͨϵͳ


/*///////////////////////////////////////////////////////////////////*/
// ϵͳֵ֪ͨ
#define	NL_SYS_NOTIFY_FUNCTION		    1
	//   ֪֪ͨϵͳõĺָ룬װֿ֧ǰ֪ͨжΣ
	// ֵ֪ͨӦøǰֵ֪ͨԷֵ
	//   ɽ˺ָ¼ԱҪʱʹ֪ͨϢϵͳ
	//   dwParam1: (PFN_NOTIFY_SYS)
#define NL_FREE_LIB_DATA                6
    // ֿ֪֧ͨͷԴ׼˳ͷָĸݡ

#define NL_GET_CMD_FUNC_NAMES            14
    // ʵֺĵĺ(char*[]), ֧־̬Ķ̬봦
#define NL_GET_NOTIFY_LIB_FUNC_NAME      15
    // شϵͳ֪ͨĺ(PFN_NOTIFY_LIB), ֧־̬Ķ̬봦
#define NL_GET_DEPENDENT_LIBS            16
    // ؾ̬̬ļб(ʽΪ\0ָı,β\0), ֧־̬Ķ̬봦
    // kernel32.lib user32.lib gdi32.lib ȳõϵͳⲻҪڴб
    // NULLNR_ERRʾָļ


/*///////////////////////////////////////////////////////////////////*/

#define NR_OK		0
#define NR_ERR		-1

#if __GCC_ || _MSC_VER == 1200
    typedef INT (WINAPI *PFN_NOTIFY_LIB) (INT nMsg, DWORD dwParam1 = 0, DWORD dwParam2 = 0);
	    // ˺ϵͳ֪ͨй¼
    typedef INT (WINAPI *PFN_NOTIFY_SYS) (INT nMsg, DWORD dwParam1 = 0, DWORD dwParam2 = 0);
	    // ˺֪ͨϵͳй¼
#else
    typedef INT (WINAPI *PFN_NOTIFY_LIB) (INT nMsg, DWORD dwParam1, DWORD dwParam2);
	    // ˺ϵͳ֪ͨй¼
    typedef INT (WINAPI *PFN_NOTIFY_SYS) (INT nMsg, DWORD dwParam1, DWORD dwParam2);
	    // ˺֪ͨϵͳй¼
#endif

/* ͷʵֺԭ͡
   1 CDECL ÷ʽ
   2pRetData ݣ
   3!!!ָͲΪ _SDT_ALL 
       pRetData->m_dtDataTypeΪ _SDT_ALL д
   4pArgInf ṩݱָ MDATA_INF ÿĿͬ nArgCount */
typedef void (*PFN_EXECUTE_CMD) (PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf);
// ֿ֧ADDINܵĺ
typedef INT (WINAPI *PFN_RUN_ADDIN_FN) (INT nAddInFnIndex);
// ṩijģĺ
typedef INT (WINAPI *PFN_SUPER_TEMPLATE) (INT nTemplateIndex);

////////////////////////////////////////////////////

#define		LIB_FORMAT_VER		20000101	// ʽ

typedef struct
{
	DWORD				m_dwLibFormatVer;
		// ʽţӦõLIB_FORMAT_VERҪ;£
		//   Ʃ krnln.fnX ⣬ͬȫһµĿʱӦı˸ʽţ
		// Էֹװء

	LPTSTR				m_szGuid;
		// ӦڱΨһGUIDΪNULLգа汾˴Ӧͬ
		// ΪActiveXؼ˴¼CLSID
	INT					m_nMajorVersion;	// 汾ţ0
	INT					m_nMinorVersion;	// Ĵΰ汾š

	INT					m_nBuildNumber;
		// 汾ţԴ˰汾κδ
		//   汾Žͬʽ汾ŵϵͳƩ޸˼ BUG
		// ֵʽ汾ϵͳκιûʹõİ汾乹汾
		// ŶӦòһ
		//   ֵʱӦ˳

	INT					m_nRqSysMajorVer;		// Ҫϵͳ汾š
	INT					m_nRqSysMinorVer;		// ҪϵͳĴΰ汾š
	INT					m_nRqSysKrnlLibMajorVer;	// Ҫϵͳֿ֧汾š
	INT					m_nRqSysKrnlLibMinorVer;	// Ҫϵͳֿ֧Ĵΰ汾š

	LPTSTR				m_szName;
		// ΪNULLա
	INT					m_nLanguage;	// ֵ֧ԡ
	LPTSTR				m_szExplain;	// ϸ

	#define		LBS_FUNC_NO_RUN_CODE		(1 << 2)
		// Ϊ⣬ûжӦִ֧ܵ룬˲С
	#define		LBS_NO_EDIT_INFO			(1 << 3)
		// ޹༭õϢ༭ϢҪΪơַȣ
	#define		LBS_IS_DB_LIB				(1 << 5)
		// ǷΪݿֿ֧⡣
    //!!! עλ __OS_xxxx ڱֿ֧евϵͳ汾
    #define _LIB_OS(os)     (os)  // תosԱ뵽m_dwState
    #define _TEST_LIB_OS(m_dwState,os)    ((_LIB_OS (os) & m_dwState) != 0) // ֿ֧Ƿָϵͳİ汾
	DWORD				m_dwState;

//////////////////
	LPTSTR				m_szAuthor;
	LPTSTR				m_szZipCode;
	LPTSTR				m_szAddress;
	LPTSTR				m_szPhoto;
	LPTSTR				m_szFax;
	LPTSTR				m_szEmail;
	LPTSTR				m_szHomePage;
	LPTSTR				m_szOther;

//////////////////
	INT                 m_nDataTypeCount;	// Զ͵Ŀ
	PLIB_DATA_TYPE_INFO m_pDataType;		// еԶ͡
		//   Բοʹϵͳֿ֧еԶͣϵͳֿ֧ڳ
		// ĿǼеֵ1ֵΪ1

	INT					m_nCategoryCount;	// ȫĿΪ0
	LPTSTR				m_szzCategory;		// ȫ˵

	// ṩȫĿΪ0
	INT					m_nCmdCount;
	PCMD_INFO			m_pBeginCmdInfo;	// ΪNULL
	PFN_EXECUTE_CMD*    m_pCmdsFunc;		// ָÿʵִ׵ַΪNULL

	PFN_RUN_ADDIN_FN	m_pfnRunAddInFn;	// ΪNULL
	//     йAddInܵ˵ַ˵һܡһΪ
	// һ20ַϣгʼλöԶ뵽߲˵
    // Ӧ@ʼʱյֵΪ -(nAddInFnIndex + 1) ĵ֪ͨ
    // ڶΪϸܣһ60ַմ
	LPTSTR				m_szzAddInFnInfo;

	PFN_NOTIFY_LIB		m_pfnNotify;		// ΪNULL

    // ģʱá
	PFN_SUPER_TEMPLATE	m_pfnSuperTemplate;	// ΪNULL
	//     йSuperTemplate˵ַ˵һSuperTemplate
	// һΪSuperTemplateƣһ30ַڶΪϸܣޣ
	// մ
	LPTSTR m_szzSuperTemplateInfo;

	// Ԥȶг
	INT	m_nLibConstCount;
	PLIB_CONST_INFO m_pLibConst;

	LPTSTR m_szzDependFiles;	// ΪNULL
	// Ҫ֧ļ
}
LIB_INFO, *PLIB_INFO;

#define	FUNCNAME_GET_LIB_INFO		"GetNewInf"     // Ʊ̶(3.0ǰΪ"GetLibInf")
typedef PLIB_INFO (WINAPI *PFN_GET_LIB_INFO) ();	// ȡֿ֧Ϣ
typedef INT (*PFN_ADD_IN_FUNC) ();

/*////////////////////////////////////////////*/

#define LIB_BMP_RESOURCE	"LIB_BITMAP"	// ֿ֧ṩͼԴ
#define LIB_BMP_CX			16					// ÿһͼԴĿ
#define LIB_BMP_CY			13					// ÿһͼԴĸ߶
#define LIB_BMP_BKCOLOR		RGB(255, 255, 255)	// ͼԴĵɫ

////////////////////////////

#define	WU_GET_WND_PTR			(WM_APP + 2)	// ڷǺֿ֧еĴ֧¼

#endif



================================================
FILE: krnln/md5t.cpp
================================================
#include "stdafx.h"
#include <stdio.h>

#pragma warning(disable:4996)

typedef struct {
	DWORD state[4];			//encypted message
	DWORD count[2];			//bits of plaintext
	unsigned char buffer[64];
}MD5_CTX;

void MD5Init(MD5_CTX *);
void MD5Update(MD5_CTX *, unsigned char *, unsigned int);//ܵмǸ
void MD5Final(MD5_CTX *);

#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21

#define a esi
#define b edi
#define c edx
#define d ebx
#define tmp1 eax
#define tmp2 ecx

#define x(i) [x+4*i]

static void MD5Transform (DWORD [4], unsigned char [64]);

static unsigned char PADDING[64] = {
	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

#define FF(a, b, c, d, x, s, ac) \
	__asm mov tmp1,b \
	__asm and tmp1,c \
	__asm mov tmp2,b \
	__asm not tmp2 \
	__asm and tmp2,d \
	__asm or tmp2,tmp1 \
	__asm lea a,[tmp2+a+ac] \
	__asm add a,x \
	__asm rol a,s \
	__asm add a,b \

#define GG(a, b, c, d, x, s, ac) \
	__asm mov tmp1,b \
	__asm and tmp1,d \
	__asm mov tmp2,d \
	__asm not tmp2 \
	__asm and tmp2,c \
	__asm or tmp2,tmp1 \
	__asm lea a,[tmp2+a+ac] \
	__asm add a,x \
	__asm rol a,s \
	__asm add a,b 

#define HH(a,b,c, d, x, s, ac) \
	__asm mov tmp2,b \
	__asm xor tmp2,c \
	__asm xor tmp2,d \
	__asm lea a,[tmp2+a+ac] \
	__asm add a,x \
	__asm rol a,s \
	__asm add a,b

#define II(a, b, c, d, x, s, ac) \
	__asm mov tmp2,d \
	__asm not tmp2 \
	__asm or tmp2,b \
	__asm xor tmp2,c \
	__asm lea a,[tmp2+a+ac] \
	__asm add a,x \
	__asm rol a,s \
	__asm add a,b

void MD5Init (MD5_CTX *context)
{
	context->count[0] = context->count[1] = 0;
	context->state[0] = 0x67452301;
	context->state[1] = 0xefcdab89;
	context->state[2] = 0x98badcfe;
	context->state[3] = 0x10325476;
}

void MD5Update (MD5_CTX *context, unsigned char *input, unsigned int inputLen)
{
	unsigned int i, index, partLen;

	index = (unsigned int)((context->count[0] >> 3) & 0x3F);

	if ((context->count[0] += ((DWORD)inputLen << 3)) < ((DWORD)inputLen << 3))
		context->count[1]++;
	context->count[1] += ((DWORD)inputLen >> 29);

	partLen = 64 - index;

	if (inputLen >= partLen) {
		CopyMemory(&context->buffer[index],input, partLen);
		MD5Transform (context->state, context->buffer);

		for (i = partLen; i + 63 < inputLen; i += 64){}
		index = 0;
	}
	else
		i = 0;

	/* Buffer remaining input */
	CopyMemory(&context->buffer[index],&input[i],inputLen-i);
}

void MD5Final (MD5_CTX *context)
{
	unsigned char bits[8];
	unsigned int index, padLen;

	CopyMemory(bits,context->count,8);

	index = (unsigned int)((context->count[0] >> 3) & 0x3f);
	padLen = (index < 56) ? (56 - index) : (120 - index);
	MD5Update (context, PADDING, padLen);
	MD5Update (context, bits, 8);
}

static void MD5Transform (DWORD state[4], unsigned char block[64])
{
	DWORD x[16];
	__asm {
		//initial
		/*		mov a,0x67452301
		mov b,0xefcdab89
		mov c,0x98badcfe
		mov d,0x10325476
		*/
		mov tmp1,DWORD PTR [state]
		mov a,DWORD PTR [tmp1]
		mov b,DWORD PTR [tmp1+4]
		mov c,DWORD PTR [tmp1+8]
		mov d,DWORD PTR [tmp1+12]
		//copy string from block to state
		//ǵAPIӰĴԼʵһڴ濽
		push esi
			push edi

			xor ecx,ecx
			mov esi,dword ptr [block]
		lea edi,[x]
ROLL:
		mov eax,dword ptr [esi+ecx]
		mov dword ptr [edi+ecx],eax
			add ecx,4
			cmp ecx,64
			jb  ROLL

			pop edi
			pop esi
	}

	/* Round 1 */
	FF(a, b, c, d, x( 0), S11, 0xd76aa478); /* 1 */
	FF(d, a, b, c, x( 1), S12, 0xe8c7b756); /* 2 */
	FF(c, d, a, b, x( 2), S13, 0x242070db); /* 3 */
	FF(b, c, d, a, x( 3), S14, 0xc1bdceee); /* 4 */
	FF(a, b, c, d, x( 4), S11, 0xf57c0faf); /* 5 */
	FF(d, a, b, c, x( 5), S12, 0x4787c62a); /* 6 */
	FF(c, d, a, b, x( 6), S13, 0xa8304613); /* 7 */
	FF(b, c, d, a, x( 7), S14, 0xfd469501); /* 8 */
	FF(a, b, c, d, x( 8), S11, 0x698098d8); /* 9 */
	FF(d, a, b, c, x( 9), S12, 0x8b44f7af); /* 10 */
	FF(c, d, a, b, x(10), S13, 0xffff5bb1); /* 11 */
	FF(b, c, d, a, x(11), S14, 0x895cd7be); /* 12 */
	FF(a, b, c, d, x(12), S11, 0x6b901122); /* 13 */
	FF(d, a, b, c, x(13), S12, 0xfd987193); /* 14 */
	FF(c, d, a, b, x(14), S13, 0xa679438e); /* 15 */
	FF(b, c, d, a, x(15), S14, 0x49b40821); /* 16 */

	/* Round 2 */
	GG (a, b, c, d, x( 1), S21, 0xf61e2562); /* 17 */
	GG (d, a, b, c, x( 6), S22, 0xc040b340); /* 18 */
	GG (c, d, a, b, x(11), S23, 0x265e5a51); /* 19 */
	GG (b, c, d, a, x( 0), S24, 0xe9b6c7aa); /* 20 */
	GG (a, b, c, d, x( 5), S21, 0xd62f105d); /* 21 */
	GG (d, a, b, c, x(10), S22,  0x2441453); /* 22 */
	GG (c, d, a, b, x(15), S23, 0xd8a1e681); /* 23 */
	GG (b, c, d, a, x( 4), S24, 0xe7d3fbc8); /* 24 */
	GG (a, b, c, d, x( 9), S21, 0x21e1cde6); /* 25 */
	GG (d, a, b, c, x(14), S22, 0xc33707d6); /* 26 */
	GG (c, d, a, b, x( 3), S23, 0xf4d50d87); /* 27 */
	GG (b, c, d, a, x( 8), S24, 0x455a14ed); /* 28 */
	GG (a, b, c, d, x(13), S21, 0xa9e3e905); /* 29 */
	GG (d, a, b, c, x( 2), S22, 0xfcefa3f8); /* 30 */
	GG (c, d, a, b, x( 7), S23, 0x676f02d9); /* 31 */
	GG (b, c, d, a, x(12), S24, 0x8d2a4c8a); /* 32 */

	/* Round 3 */
	HH (a, b, c, d, x( 5), S31, 0xfffa3942); /* 33 */
	HH (d, a, b, c, x( 8), S32, 0x8771f681); /* 34 */
	HH (c, d, a, b, x(11), S33, 0x6d9d6122); /* 35 */
	HH (b, c, d, a, x(14), S34, 0xfde5380c); /* 36 */
	HH (a, b, c, d, x( 1), S31, 0xa4beea44); /* 37 */
	HH (d, a, b, c, x( 4), S32, 0x4bdecfa9); /* 38 */
	HH (c, d, a, b, x( 7), S33, 0xf6bb4b60); /* 39 */
	HH (b, c, d, a, x(10), S34, 0xbebfbc70); /* 40 */
	HH (a, b, c, d, x(13), S31, 0x289b7ec6); /* 41 */
	HH (d, a, b, c, x( 0), S32, 0xeaa127fa); /* 42 */
	HH (c, d, a, b, x( 3), S33, 0xd4ef3085); /* 43 */
	HH (b, c, d, a, x( 6), S34,  0x4881d05); /* 44 */
	HH (a, b, c, d, x( 9), S31, 0xd9d4d039); /* 45 */
	HH (d, a, b, c, x(12), S32, 0xe6db99e5); /* 46 */
	HH (c, d, a, b, x(15), S33, 0x1fa27cf8); /* 47 */
	HH (b, c, d, a, x( 2), S34, 0xc4ac5665); /* 48 */

	/* Round 4 */
	II (a, b, c, d, x( 0), S41, 0xf4292244); /* 49 */
	II (d, a, b, c, x( 7), S42, 0x432aff97); /* 50 */
	II (c, d, a, b, x(14), S43, 0xab9423a7); /* 51 */
	II (b, c, d, a, x( 5), S44, 0xfc93a039); /* 52 */
	II (a, b, c, d, x(12), S41, 0x655b59c3); /* 53 */
	II (d, a, b, c, x( 3), S42, 0x8f0ccc92); /* 54 */
	II (c, d, a, b, x(10), S43, 0xffeff47d); /* 55 */
	II (b, c, d, a, x( 1), S44, 0x85845dd1); /* 56 */
	II (a, b, c, d, x( 8), S41, 0x6fa87e4f); /* 57 */
	II (d, a, b, c, x(15), S42, 0xfe2ce6e0); /* 58 */
	II (c, d, a, b, x( 6), S43, 0xa3014314); /* 59 */
	II (b, c, d, a, x(13), S44, 0x4e0811a1); /* 60 */
	II (a, b, c, d, x( 4), S41, 0xf7537e82); /* 61 */
	II (d, a, b, c, x(11), S42, 0xbd3af235); /* 62 */
	II (c, d, a, b, x( 2), S43, 0x2ad7d2bb); /* 63 */
	II (b, c, d, a, x( 9), S44, 0xeb86d391); /* 64 */

	__asm {
		mov tmp1,DWORD PTR [state]
		add DWORD PTR [tmp1],a
			add DWORD PTR [tmp1+4],b
			add DWORD PTR [tmp1+8],c
			add DWORD PTR [tmp1+12],d
	}
}


/********************************************************
 жļMD5Уֵ
 m_filename	ļ
Orgin		MD5Уֵ
 TRUE or FALSE
********************************************************/

BOOL CalcMD5(LPCTSTR m_filename,unsigned char Orgin[16])
{
	MD5_CTX context;
	FILE* ff;
	unsigned char *rbuff = NULL;
	DWORD dwSize;
	DWORD rCount;

	dwSize=64;
	rCount=0;
	if(!(ff=fopen(m_filename,"rb")))return false;

	MD5Init(&context);
	while( !feof( ff ) )
	{
		rbuff=new unsigned char[dwSize];
		rCount = fread(rbuff,sizeof(char),dwSize,ff);
		MD5Update(&context, rbuff,rCount);
	}
	MD5Final(&context);
	if (rbuff)
		delete[] rbuff;
	fclose(ff);
	memcpy(Orgin,(unsigned char*)context.state,16);//ؼܽڵ
	return TRUE;
}


BOOL GetMD5(char* pMd5String,char* strPath)
{
	unsigned char O[16];
	if(!CalcMD5(strPath,O))
		return FALSE;

	wsprintf(pMd5String,"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
		O[0],O[1],O[2],O[3],O[4],O[5],O[6],O[7],O[8],O[9],O[10],O[11],O[12],O[13],O[14],O[15]);
	return TRUE;
}


BOOL GetBufMD5(unsigned char* pMd5String,unsigned char* rbuff,DWORD BufSize)
{
	MD5_CTX context;
	unsigned char O[16];

	MD5Init(&context);
	MD5Update(&context, rbuff, BufSize);
	MD5Final(&context);

	memcpy(O, (unsigned char*)context.state, 16);
	wsprintf((char*)pMd5String,"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
		O[0],O[1],O[2],O[3],O[4],O[5],O[6],O[7],O[8],O[9],O[10],O[11],O[12],O[13],O[14],O[15]);
	return TRUE;
}




================================================
FILE: krnln/md5t.h
================================================
BOOL GetMD5(char* pMd5String,char* strPath);

BOOL GetBufMD5(unsigned char* pMd5String,unsigned char* rbuff,DWORD BufSize);

================================================
FILE: krnln/mem.cpp
================================================
// Mem.cpp: implementation of the CFreqMem class.
//
//////////////////////////////////////////////////////////////////////

#include "StdAfx.h"
#include <TCHAR.H>
#include "mem.h"

static HANDLE s_hHeap = NULL;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

static BOOL s_blAllowUseBuf = FALSE;
	// Ϊ٣򻺳ֹܱ CVarManger бԶá

BOOL CFreqMem::IsAllowUseBuf ()
{
	return s_blAllowUseBuf;
}

void CFreqMem::AllowUseBuf (BOOL blAllow)
{
	s_blAllowUseBuf = blAllow;
}

//////////////////////////////////////////////////////////////////////

MEM_BUF _m_membuf;	// !!! ֱô˱

CFreqMem::CFreqMem ()
{
	m_pMemBuf = &_m_membuf;
	m_pData = NULL;
	m_nAllocedSize = m_nSize = 0;
}

// IMPLEMENT_SERIAL (CFreqMem, CObject, 1)

LPBYTE CFreqMem::Alloc (INT nSize)
{
//	ASSERT (nSize > 0);

	if (m_pData != NULL)
	{
//		ASSERT (m_nAllocedSize > 0);
		return Realloc (nSize);
	}

	if (nSize == 0)  return NULL;

	if (s_blAllowUseBuf == TRUE && nSize <= PAGE_SIZE &&
			m_pMemBuf->m_nPageUsedCount < PAGE_COUNT)
	{
		INT n = FindByte (m_pMemBuf->m_btaryUsed, PAGE_COUNT, 0);
//		ASSERT (n != -1);

		m_pMemBuf->m_btaryUsed [n] = 1;
		m_pMemBuf->m_nPageUsedCount++;

		m_nAllocedSize = PAGE_SIZE;
		m_pData = m_pMemBuf->m_buf + n * PAGE_SIZE;
		m_nSize = nSize;
		return m_pData;
	}

	if (s_hHeap == NULL)
		s_hHeap = ::GetProcessHeap ();

	m_pData = (LPBYTE)::HeapAlloc (s_hHeap, 0, nSize + FM_GROW_SIZE);
	if (m_pData == NULL)
	{
		m_nAllocedSize = 0;
		m_nSize = 0;
	}
	else
	{
		m_nAllocedSize = nSize + FM_GROW_SIZE;
		m_nSize = nSize;
	}
	return m_pData;
}

LPBYTE CFreqMem::Realloc (INT nSize)
{
//	ASSERT (nSize >= 0);
	if (nSize == 0)
	{
		Free ();
		return NULL;
	}
	if (m_pData == NULL)
	{
//		ASSERT (m_nAllocedSize == 0);
		return Alloc (nSize);
	}

	BOOL blIsAllocBuf = m_pData >= m_pMemBuf->m_buf &&
			m_pData < m_pMemBuf->m_buf + PAGE_BUF_SIZE;

	if (m_nAllocedSize >= nSize && (blIsAllocBuf == TRUE ||
			m_nAllocedSize - nSize <= FM_MAX_FREE_BUF_SIZE + FM_GROW_SIZE))
	{
		m_nSize = nSize;
		return m_pData;
	}

	if (s_hHeap == NULL)
		s_hHeap = ::GetProcessHeap ();

	LPBYTE pNew;
	if (blIsAllocBuf == TRUE)
	{
		pNew = (LPBYTE)::HeapAlloc (s_hHeap, 0, nSize + FM_GROW_SIZE);
		if (pNew != NULL)
		{
			CopyMemory (pNew, m_pData, min (nSize, m_nSize));
			_Free (m_pData);
			m_pData = pNew;
			m_nAllocedSize = nSize + FM_GROW_SIZE;
			m_nSize = nSize;
			return m_pData;
		}
		else
			return NULL;
	}

	pNew = (LPBYTE)::HeapReAlloc (s_hHeap, 0, m_pData, nSize + FM_GROW_SIZE);
	if (pNew != NULL)
	{
		m_pData = pNew;
		m_nAllocedSize = nSize + FM_GROW_SIZE;
		m_nSize = nSize;
		return m_pData;
	}
	else
		return NULL;
}

void CFreqMem::Free ()
{
	_Free (m_pData);

	m_pData = NULL;
	m_nAllocedSize = m_nSize = 0;
}

void CFreqMem::_Free (LPBYTE pData)
{
	if (pData == NULL)  return;

	if (pData < m_pMemBuf->m_buf || pData >= m_pMemBuf->m_buf + PAGE_BUF_SIZE)
	{
		if (s_hHeap == NULL)
			s_hHeap = ::GetProcessHeap ();
//		VERIFY (::HeapFree (s_hHeap, NULL, pData));
		::HeapFree (s_hHeap, NULL, pData);
	}
	else
	{
//		ASSERT ((pData - m_pMemBuf->m_buf) % PAGE_SIZE == 0 &&
//				m_pMemBuf->m_btaryUsed [(pData - m_pMemBuf->m_buf) / PAGE_SIZE] == 1 &&
//				m_pMemBuf->m_nPageUsedCount > 0);
		m_pMemBuf->m_btaryUsed [(pData - m_pMemBuf->m_buf) / PAGE_SIZE] = 0;
		m_pMemBuf->m_nPageUsedCount--;
	}
}

///////////////////////////////////////////

void CFreqMem::AddFloat	(FLOAT flt)
{
	if (m_nAllocedSize - m_nSize >= sizeof (FLOAT))
	{
		*(FLOAT*)(m_pData + m_nSize) = flt;
		m_nSize += sizeof (FLOAT);
	}
	else
		Append ((LPBYTE)&flt, sizeof (flt));
}

void CFreqMem::AddDouble (DOUBLE db)
{
	if (m_nAllocedSize - m_nSize >= sizeof (DOUBLE))
	{
		*(DOUBLE*)(m_pData + m_nSize) = db;
		m_nSize += sizeof (DOUBLE);
	}
	else
		Append ((LPBYTE)&db, sizeof (DOUBLE));
}

void CFreqMem::AddDWord (DWORD dw)
{
	if (m_nAllocedSize - m_nSize >= sizeof (DWORD))
	{
		*(DWORD*)(m_pData + m_nSize) = dw;
		m_nSize += sizeof (DWORD);
	}
	else
		Append ((LPBYTE)&dw, sizeof (DWORD));
}

void CFreqMem::AddInt64 (INT64 n64)
{
	if (m_nAllocedSize - m_nSize >= sizeof (INT64))
	{
		*(INT64*)(m_pData + m_nSize) = n64;
		m_nSize += sizeof (INT64);
	}
	else
		Append ((LPBYTE)&n64, sizeof (INT64));
}

void CFreqMem::AddInt (INT n)
{
	if (m_nAllocedSize - m_nSize >= sizeof (INT))
	{
		*(INT*)(m_pData + m_nSize) = n;
		m_nSize += sizeof (INT);
	}
	else
		Append ((LPBYTE)&n, sizeof (INT));
}

void CFreqMem::AddWord (WORD w)
{
	if (m_nAllocedSize - m_nSize >= sizeof (WORD))
	{
		*(WORD*)(m_pData + m_nSize) = w;
		m_nSize += sizeof (WORD);
	}
	else
		Append ((LPBYTE)&w, sizeof (WORD));
}

void CFreqMem::AddShort (SHORT sht)
{
	if (m_nAllocedSize - m_nSize >= sizeof (SHORT))
	{
		*(SHORT*)(m_pData + m_nSize) = sht;
		m_nSize += sizeof (SHORT);
	}
	else
		Append ((LPBYTE)&sht, sizeof (SHORT));
}

void CFreqMem::AddByte (BYTE bt)
{
	if (m_nAllocedSize > m_nSize)
		m_pData [m_nSize++] = bt;
	else
		Append ((LPBYTE)&bt, sizeof (BYTE));
}

void CFreqMem::AddBool (BOOL bl)
{
	if (m_nAllocedSize - m_nSize >= sizeof (BOOL))
	{
		*(BOOL*)(m_pData + m_nSize) = bl;
		m_nSize += sizeof (BOOL);
	}
	else
		Append ((LPBYTE)&bl, sizeof (BOOL));
}

void CFreqMem::AddStr (LPTSTR pstr)
{
	if (IsEmptyStr (pstr) == TRUE)
		AddByte (0);
	else
		Append ((LPBYTE)pstr, tcsallbytes (pstr));
}

void CFreqMem::AddText (LPTSTR pstr)
{
	if (IsEmptyStr (pstr) == FALSE)
		Append ((LPBYTE)pstr, tcsbytes (pstr));
}

///////////////////////////////////////////

BOOL CFreqMem::EmptyAndRqSpace (INT nSize)
{
//	ASSERT (nSize >= 0);
	if (nSize <= 0)
		nSize = 0;

	if (Realloc (nSize) != NULL)
	{
		m_nSize = 0;
		return TRUE;
	}
	else
		return FALSE;
}

// !! 뱣֤ı MEM ׵ַָ롣
void CFreqMem::XchgMem (CFreqMem& mem)
{
	PMEM_BUF pMemBuf = m_pMemBuf;
	m_pMemBuf = mem.m_pMemBuf;
	mem.m_pMemBuf = pMemBuf;

	LPBYTE p = m_pData;
	m_pData = mem.m_pData;
	mem.m_pData = p;

	INT n = m_nAllocedSize;
	m_nAllocedSize = mem.m_nAllocedSize;
	mem.m_nAllocedSize = n;

	n = m_nSize;
	m_nSize = mem.m_nSize;
	mem.m_nSize = n;
}
/*
void CFreqMem::SaveEmpty (CArchive& ar)
{
	ASSERT (ar.IsStoring ());
	ar << (INT)0;
}

void CFreqMem::Serialize (CArchive& ar)
{
	if (ar.IsStoring())
	{
		ar << m_nSize;
		if (m_nSize > 0)
			ar.Write (m_pData, m_nSize);
	}
	else
	{
		Free ();

		INT nSize;
		ar >> nSize;
		if (nSize > 0)
		{
			if (Alloc (nSize) != NULL)
				ar.Read (m_pData, nSize);
			else
				AfxThrowArchiveException (CArchiveException::generic);
		}
	}
}

INT CFreqMem::ReadFile (CString& strFileName, INT nReadLength)
{
	TRY
	{
		CFile file;
		if (file.Open (strFileName, CFile::modeRead | CFile::shareDenyWrite) == TRUE)
		{
			if (nReadLength == -1)
				nReadLength = file.GetLength ();

			if (nReadLength > 0)
			{
				LPBYTE p = Alloc (nReadLength);
				if (p != NULL)
				{
					INT n = file.Read (p, nReadLength);
					if (n != nReadLength)
						Realloc (n);
					return n;
				}
			}
			else
			{
				Free ();
				return 0;
			}
		}
	}
	END_TRY

	Free ();
	return -1;
}

BOOL CFreqMem::WriteFile (CString& strFileName, INT nWriteLength)
{
	ASSERT (strFileName.IsEmpty () == FALSE);

	TRY
	{
		INT nSize = GetSize ();
		if (nWriteLength == -1)
			nWriteLength = nSize;
		else
			nWriteLength = min (nWriteLength, nSize);

		CFile file;
		if (file.Open (strFileName, CFile::modeCreate | CFile::modeWrite |
				CFile::shareExclusive) == TRUE)
		{
			if (nWriteLength > 0)
				file.Write (GetPtr (), nWriteLength);

			file.Close ();
			return TRUE;
		}
	}
	END_TRY

	return FALSE;
}
*/
////////////////////////////

// if pData == NULL, insert blank data.
BOOL CFreqMem::Insert (INT nOffset, LPBYTE pData, INT nSize)
{
//	ASSERT (nOffset >= 0 && nSize >= 0);
	if (nSize == 0)  return TRUE;
	if (nOffset == m_nSize)  return Append (pData, nSize);

	INT nOldSize = m_nSize;
	LPBYTE pMem = Realloc (max (nOffset, nOldSize) + nSize);
	if (pMem == NULL)  return FALSE;

	LPBYTE pInsert = pMem + nOffset;
	if (nOffset < nOldSize)
		MoveMem (pInsert + nSize, pInsert, nOldSize - nOffset);
	
	if (pData != NULL)
	{
//		ASSERT (AfxIsValidAddress (pData, nSize));
		MoveMem (pInsert, pData, nSize);
	}
	else
		ZeroMem (pInsert, nSize);

	return TRUE;
}

BOOL CFreqMem::AppendSpace (INT nSpaceCount)
{
//	ASSERT (nSpaceCount >= 0);

	if (Append (NULL, nSpaceCount) == TRUE)
	{
		if (nSpaceCount > 0)
			memset (GetPtr () + GetSize () - nSpaceCount, ' ', nSpaceCount);
		return TRUE;
	}

	return FALSE;
}

// if pData == NULL, append blank data.
BOOL CFreqMem::Append (LPBYTE pData, INT nSize)
{
//	ASSERT (nSize >= 0);
	if (nSize <= 0)  return TRUE;

	INT nOldSize = m_nSize;
	LPBYTE pMem = Realloc (nOldSize + nSize);
	if (pMem == NULL)  return FALSE;

	LPBYTE pAppend = pMem + nOldSize;
	if (pData != NULL)
		MoveMem (pAppend, pData, nSize);
	else
		ZeroMem (pAppend, nSize);

	return TRUE;
}

// if pReplaceData == NULL, replace blank data.
BOOL CFreqMem::Replace (INT nOffset, INT nSize, LPBYTE pReplaceData, INT nReplaceSize)
{
//	ASSERT (nOffset >= 0 && nSize >= 0 && nReplaceSize >= 0);

	INT nOldSize = m_nSize;
	if (nSize == 0 || nOffset >= nOldSize)
		return Insert (nOffset, pReplaceData, nReplaceSize);
	if (nReplaceSize == 0)  
		return Remove (nOffset, nSize);

	if (nSize > nOldSize - nOffset)  nSize = nOldSize - nOffset;

	LPBYTE pReplaceAt;
	INT nMoveSize = nOldSize - nOffset - nSize;
	if (nReplaceSize > nSize)
	{
		pReplaceAt = Realloc (nOldSize + nReplaceSize - nSize);
		if (pReplaceAt == NULL)  return FALSE;
		pReplaceAt += nOffset;

		if (nMoveSize > 0)
			MoveMem (pReplaceAt + nReplaceSize, pReplaceAt + nSize, nMoveSize);
	}
	else
	{
		pReplaceAt = m_pData;
//		ASSERT (pReplaceAt != NULL);
		pReplaceAt += nOffset;

		if (nReplaceSize < nSize)
		{
			if (nMoveSize > 0)
				MoveMem (pReplaceAt + nReplaceSize, pReplaceAt + nSize, nMoveSize);

			pReplaceAt = Realloc (nOldSize - (nSize - nReplaceSize));
		//	ASSERT (pReplaceAt != NULL);
			if (pReplaceAt == NULL)  return FALSE;  // data already be changed!
			pReplaceAt += nOffset;
		}
	}

	if (pReplaceData != NULL)
	{
//		ASSERT (AfxIsValidAddress (pReplaceData, nReplaceSize, FALSE));
		MoveMem (pReplaceAt, pReplaceData, nReplaceSize);
	}
	else
		ZeroMem (pReplaceAt, nReplaceSize);
	return TRUE;
}

// if nOffset == -1, delete data from tail.
BOOL CFreqMem::Remove (INT nOffset, INT nSize)
{
	if (nOffset == -1)
	{
		INT nNewSize = max (0, m_nSize - nSize);
		if (nNewSize == 0)
		{
			Free ();
			return TRUE;
		}
		else
			return Realloc (nNewSize) != NULL;
	}

	if (nSize == 0)  return TRUE;
	if (m_pData == NULL || nOffset >= m_nSize)  return FALSE;
	
	LPBYTE pRemoveAt = m_pData + nOffset;
	
	INT nRemoveSize;
	if (nSize < m_nSize - nOffset)
	{
		nRemoveSize = nSize;
		MoveMem (pRemoveAt, pRemoveAt + nRemoveSize, m_nSize - nOffset - nRemoveSize);
	}
	else
		nRemoveSize = m_nSize - nOffset;

	if (m_nSize == nRemoveSize)
	{
		Free ();
		return TRUE;
	}
	else
		return Realloc (m_nSize - nRemoveSize) != NULL;
}

//////////////////////////////////////////

BOOL CMyDWordArray::SetSize (INT nNewSize)
{
	if (nNewSize == 0)
	{
		Free ();
	}
	else
	{
		nNewSize *= sizeof (DWORD);
		LPBYTE p = Alloc (nNewSize);
		if (p != NULL)
			ZeroMem (p, nNewSize);
		else
			return FALSE;
	}

	return TRUE;
}

///////////////////////////////////////////////////////////////////////////////

INT FindInt (LPINT pnTable, INT nCount, INT nFind)
{
	return FindDWord ((LPDWORD)pnTable, nCount, (DWORD)nFind);
}

BOOL IsEmptyStr (LPTSTR szStr)
{
	return szStr == NULL || *szStr == 0;
}

void MoveMem (LPBYTE pDest, LPBYTE pSrc, DWORD dwLength)
{
	if (dwLength == 0)
		return;
	else if (dwLength == 1)
		*pDest = *pSrc;
	else if (dwLength == sizeof (WORD))
		*(LPWORD)pDest = *(LPWORD)pSrc;
	else if (dwLength == sizeof (DWORD))
		*(LPDWORD)pDest = *(LPDWORD)pSrc;
	else
		::MoveMemory (pDest, pSrc, dwLength);
}

void CopyMem (LPBYTE pDest, LPBYTE pSrc, DWORD dwLength)
{
	if (dwLength == 0)
		return;
	else if (dwLength == 1)
		*pDest = *pSrc;
	else if (dwLength == sizeof (WORD))
		*(LPWORD)pDest = *(LPWORD)pSrc;
	else if (dwLength == sizeof (DWORD))
		*(LPDWORD)pDest = *(LPDWORD)pSrc;
	else
		::CopyMemory (pDest, pSrc, dwLength);
}

void ZeroMem (LPBYTE pDest, DWORD dwLength)
{
	if (dwLength == 0)
		return;
	else if (dwLength == 1)
		*pDest = 0;
	else if (dwLength == sizeof (WORD))
		*(LPWORD)pDest = 0;
	else if (dwLength == sizeof (DWORD))
		*(LPDWORD)pDest = 0;
	else
		::ZeroMemory (pDest, dwLength);
}

INT tcsallbytes (LPTSTR pstr)
{
	return (_tcslen (pstr) + 1) * sizeof (TCHAR);
/*
	if (*pstr == '\0')  return 1;

	DWORD dw;

	_asm
	{
		push	eax
		push	ebx
		push	esi

		mov		esi, dword ptr [pstr]
		mov		ebx, esi

		cld
	l0:
		lodsb
		or		al, al
		jne		l0

		sub		esi, ebx
		mov		dw, esi

		pop		esi
		pop		ebx
		pop		eax
	}

	return (INT)dw; */
}

INT tcsbytes (LPTSTR pstr)
{
	return _tcslen (pstr) * sizeof (TCHAR);
/*
	if (pstr == NULL || *pstr == '\0')  return 0;

	DWORD dw;

	_asm
	{
		push	eax
		push	ebx
		push	esi

		mov		esi, dword ptr [pstr]
		mov		ebx, esi

		cld
	l0:
		lodsb
		or		al, al
		jne		l0

		dec		esi
		sub		esi, ebx
		mov		dw, esi

		pop		esi
		pop		ebx
		pop		eax
	}

	return (INT)dw; */
}

// صֽƫ
INT FindByte (LPBYTE pTable, INT count, BYTE btFind)
{ 
	INT nRetOffset = -1;

	if (count > 0)
	{
//		ASSERT (pTable != NULL);
		if (*pTable == btFind)  return 0;

		__asm
		{
			push edi
			push eax
			push ecx

			mov al, btFind
			mov ecx, count
			push ecx
			mov edi, dword ptr [pTable]

	        cld
			repne scasb
			pop eax
			jnz quit

			inc ecx
			sub eax, ecx
			mov dword ptr [nRetOffset], eax
quit:
			pop ecx
			pop eax
			pop edi
		}
	}

	return nRetOffset;
}

// صIJֽDWORDƫ
INT FindDWord (LPDWORD pdwTable, INT count, DWORD dwFind)
{ 
	INT nRetOffset = -1;

	if (count > 0)
	{
		if (*pdwTable == dwFind)  return 0;

	//	ASSERT (pdwTable != NULL);
		__asm
		{
			push edi
			push eax
			push ecx

			mov eax, dwFind
			mov ecx, count
			push ecx
			mov edi, dword ptr [pdwTable]

	        cld
			repne scasd
			pop eax
			jnz quit

			inc ecx
			sub eax, ecx
			mov dword ptr [nRetOffset], eax
quit:
			pop ecx
			pop eax
			pop edi
		}
	}

	return nRetOffset;
}

// صIJֽWORDƫ
INT FindWord (LPWORD pwTable, INT count, WORD wFind)
{ 
	INT nRetOffset = -1;

	if (count > 0)
	{
	//	ASSERT (pwTable != NULL);
		__asm
		{
			push edi
			push eax
			push ecx

			mov ax, wFind
			mov ecx, count
			push ecx
			mov edi, dword ptr [pwTable]

	        cld
			repne scasw
			pop eax
			jnz quit

			inc ecx
			sub eax, ecx
			mov dword ptr [nRetOffset], eax
quit:
			pop ecx
			pop eax
			pop edi
		}
	}

	return nRetOffset;
}



================================================
FILE: krnln/mem.h
================================================
// Mem.h: interface for the CFreqMem class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_MEM_H__AD73B7A1_418A_11D2_AAE7_000021612B48__INCLUDED_)
#define AFX_MEM_H__AD73B7A1_418A_11D2_AAE7_000021612B48__INCLUDED_

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

BOOL IsEmptyStr (LPTSTR szStr);
INT tcsallbytes (LPTSTR pstr, LPDWORD pdwStrIndex);
INT tcsallbytes (LPTSTR pstr);
INT tcsbytes (LPTSTR pstr);
INT FindWord (LPWORD pwTable, INT count, WORD wFind);
INT FindDWord (LPDWORD pdwTable, INT count, DWORD dwFind);
INT FindInt (LPINT pnTable, INT nCount, INT nFind);
INT FindByte (LPBYTE pTable, INT count, BYTE btFind);
void ZeroMem (LPBYTE pDest, DWORD dwLength);
void CopyMem (LPBYTE pDest, LPBYTE pSrc, DWORD dwLength);
void MoveMem (LPBYTE pDest, LPBYTE pSrc, DWORD dwLength);


#define	PAGE_SIZE			512		// ҳߴ
#define	PAGE_COUNT			96		// ҳĿ
#define	PAGE_BUF_SIZE		PAGE_COUNT * PAGE_SIZE

struct MEM_BUF
{
	INT m_nPageUsedCount;			// ҳǰѾʹõĿ
	BYTE m_btaryUsed [PAGE_COUNT];	// ¼ÿһҳǷѱʹá
	BYTE m_buf [PAGE_BUF_SIZE];
};
typedef MEM_BUF* PMEM_BUF;

//////////////////////

#define	FM_MAX_FREE_BUF_SIZE	128
#define	FM_GROW_SIZE			128

class CFreqMem
{
protected:
	PMEM_BUF m_pMemBuf;

protected:
	LPBYTE m_pData;
	INT m_nAllocedSize;
	INT m_nSize;

public:
	CFreqMem ();
	virtual ~CFreqMem ()
	{
		Free ();
	}

public:
	static void BeginUseBuf ();
	static BOOL IsAllowUseBuf ();
	static void AllowUseBuf (BOOL blAllow);

	LPBYTE GetPtr () const
	{
		return m_nSize == 0 ? NULL : m_pData;
	}
	operator LPBYTE () const
	{
		return m_nSize == 0 ? NULL : m_pData;
	}
	INT GetSize () const
	{
		return m_nSize;
	}
	operator INT () const
	{
		return m_nSize;
	}
	INT FindInt (INT nFind)
	{
		LPINT pn = (LPINT)GetPtr ();
		if (pn == NULL)
			return -1;
		else
			return ::FindDWord ((LPDWORD)pn, GetSize () / sizeof (DWORD), (DWORD)nFind);
	}
	INT FindDWord (DWORD dwFind)
	{
		LPDWORD pdw = (LPDWORD)GetPtr ();
		if (pdw == NULL)
			return -1;
		else
			return ::FindDWord (pdw, GetSize () / sizeof (DWORD), dwFind);
	}
	INT FindWord (WORD wFind)
	{
		LPWORD pw = (LPWORD)GetPtr ();
		if (pw == NULL)
			return -1;
		else
			return ::FindWord (pw, GetSize () / sizeof (WORD), wFind);
	}
	BOOL IsEmpty ()
	{
		return m_nSize == 0;
	}

public:
	BOOL EmptyAndRqSpace (INT nSize);
//	void Serialize (CArchive& ar);
//	void SaveEmpty (CArchive& ar);

	void AddFloat		(FLOAT flt);
	void AddDouble		(DOUBLE db);
	void AddDWord		(DWORD dw);
	void AddInt64		(INT64 n64);
	void AddInt			(INT n);
	void AddWord		(WORD w);
	void AddShort		(SHORT sht);
	void AddByte		(BYTE bt);
	void AddBool		(BOOL bl);
	void AddStr			(LPTSTR pstr);
	void AddText        (LPTSTR pstr);

	INT GetDoubleCount ()	{	return m_nSize / sizeof (DOUBLE);	}
	INT GetDWordCount ()	{	return m_nSize / sizeof (DWORD);	}
	INT GetIntCount ()		{	return m_nSize / sizeof (INT);		}
	INT GetWordCount ()		{	return m_nSize / sizeof (WORD);		}
	INT GetShortCount ()	{	return m_nSize / sizeof (SHORT);	}
	DOUBLE*	GetDoublePtr ()	{	return m_nSize == 0 ? NULL : (DOUBLE*)m_pData;		}
	LPDWORD	GetDWordPtr ()	{	return m_nSize == 0 ? NULL : (LPDWORD)m_pData;		}
	LPINT	GetIntPtr ()	{	return m_nSize == 0 ? NULL : (LPINT)m_pData;		}
	LPWORD	GetWordPtr ()	{	return m_nSize == 0 ? NULL : (LPWORD)m_pData;		}
	SHORT*	GetShortPtr ()	{	return m_nSize == 0 ? NULL : (SHORT*)m_pData;		}

public:
	LPBYTE Alloc (INT nSize);
	LPBYTE Realloc (INT nSize);
	void Free ();

	void XchgMem (CFreqMem& mem);
	void Empty ()  { m_nSize = 0; }
	BOOL CopyFrom (CFreqMem& mem)
	{
		Empty ();
		return Append (mem, mem);
	}
	BOOL CopyFrom (LPBYTE pData, INT nSize)
	{
		Empty ();
		return Append (pData, nSize);
	}

	BOOL Insert (INT nOffset, LPBYTE pData, INT nSize);
	BOOL Append (LPBYTE pData, INT nSize);
	BOOL Replace (INT nOffset, INT nSize, LPBYTE pReplaceData, INT nReplaceSize);
	BOOL Remove (INT nOffset, INT nSize);
	BOOL AppendSpace (INT nSpaceCount);

//	INT ReadFile (CString& strFileName, INT nReadLength = -1);
//	BOOL WriteFile (CString& strFileName, INT nWriteLength = -1);

/////////////////

protected:
	void _Free (LPBYTE pData);
};

class CMyDWordArray : public CFreqMem
{
public:
	CMyDWordArray ()  { }

	INT GetSize ()
	{
		return GetDWordCount ();
	}
	INT GetUpperBound ()
	{
		return GetDWordCount () - 1;
	}
	BOOL SetSize (INT nNewSize);
	void RemoveAll ()
	{
		Free ();
	}
	LPDWORD GetData ()
	{
		return GetDWordPtr ();
	}

	DWORD GetAt (INT nIndex) const
	{
//		ASSERT (nIndex >= 0 && nIndex < (INT)(m_nSize / sizeof (DWORD)));
		return ((LPDWORD)m_pData) [nIndex];
	}
	DWORD& ElementAt (INT nIndex)
	{
//		ASSERT (nIndex >= 0 && nIndex < (INT)(m_nSize / sizeof (DWORD)));
		return ((LPDWORD)m_pData) [nIndex];
	}

	void SetAt (INT nIndex, DWORD dwElement)
	{
//		ASSERT (nIndex >= 0 && nIndex < GetDWordCount ());
		if (nIndex >= 0 && nIndex < GetDWordCount ())
			((LPDWORD)m_pData) [nIndex] = dwElement;
	}

	INT Append (const CMyDWordArray& src)
	{
		INT n = GetSize ();
		CFreqMem::Append (src, src);
		return n;
	}
	void Copy (CMyDWordArray& src)
	{
		CopyFrom (src);
	}

	DWORD operator[] (INT nIndex) const
	{
		return GetAt (nIndex);
	}
	DWORD& operator[] (INT nIndex)
	{
		return ElementAt (nIndex);
	}

	INT Add (DWORD dwElement)
	{
		AddDWord (dwElement);
		return GetUpperBound ();
	}
	void InsertAt (INT nIndex, DWORD dwElement)
	{
		Insert (nIndex * sizeof (DWORD), (LPBYTE)&dwElement, sizeof (DWORD));
	}
	void RemoveAt (INT nIndex, INT nCount = 1)
	{
		Remove (nIndex * sizeof (DWORD), sizeof (DWORD) * nCount);
	}
};


#endif // !defined(AFX_MEM_H__AD73B7A1_418A_11D2_AAE7_000021612B48__INCLUDED_)



================================================
FILE: krnln/midi.cpp
================================================
/////////////////////////////////////////////////////////////////////////////
// Copyright (C) 1998 by Jrg Knig
// All rights reserved
//
// This file is part of the completely free tetris clone "CGTetris".
//
// This is free software.
// You may redistribute it by any means providing it is not sold for profit
// without the authors written consent.
//
// No warrantee of any kind, expressed or implied, is included with this
// software; use at your own risk, responsibility for damages (if any) to
// anyone resulting from the use of this software rests entirely with the
// user.
//
// Send bug reports, bug fixes, enhancements, requests, flames, etc., and
// I'll try to keep a version up to date.  I can be reached as follows:
//    J.Koenig@adg.de                 (company site)
//    Joerg.Koenig@rhein-neckar.de    (private site)
/////////////////////////////////////////////////////////////////////////////


// Midi.cpp
//


// The CMIDI class is based on a sample in the DirectX SDK (mstream)

#include "stdafx.h"
#include "Midi.h"

#ifdef _DEBUG
#define DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


#define MThd		0x6468544D		// Start of file
#define MTrk		0x6B72544D		// Start of track


#define BUFFER_TIME_LENGTH		60   // Amount to fill in milliseconds

#define TRACE0   
#define TRACE1   
// These structures are stored in MIDI files; they need to be byte aligned.
//
#pragma pack(1)

// Contents of MThd chunk.
struct MIDIFILEHDR
{
    WORD	wFormat;			// Format (hi-lo)
    WORD	wTrackCount;		// # tracks (hi-lo)
    WORD	wTimeDivision;		// Time division (hi-lo)
};

#pragma pack() // End of need for byte-aligned structures


// Macros for swapping hi/lo-endian data
//
#define WORDSWAP(w)		(((w) >> 8) | \
						(((w) << 8) & 0xFF00))

#define DWORDSWAP(dw)	(((dw) >> 24) | \
						(((dw) >> 8) & 0x0000FF00) | \
						(((dw) << 8) & 0x00FF0000) | \
						(((dw) << 24) & 0xFF000000))


static char gteBadRunStat[] 	= "Reference to missing running status.";
static char gteRunStatMsgTrunc[]= "Running status message truncated";
static char gteChanMsgTrunc[]	= "Channel message truncated";
static char gteSysExLenTrunc[]	= "SysEx event truncated (length)";
static char gteSysExTrunc[]	= "SysEx event truncated";
static char gteMetaNoClass[]	= "Meta event truncated (no class byte)";
static char gteMetaLenTrunc[]	= "Meta event truncated (length)";
static char gteMetaTrunc[]	= "Meta event truncated";
static char gteNoMem[]		= "Out of memory during malloc call";


//////////////////////////////////////////////////////////////////////
// CMIDI -- Construction/Destruction
//////////////////////////////////////////////////////////////////////

CMIDI::CMIDI()
	: m_dwSoundSize(0)
	, m_pSoundData(0)
	, m_dwFormat(0)
	, m_dwTrackCount(0)
	, m_dwTimeDivision(0)
	, m_bPlaying(FALSE)
	, m_hStream(0)
	, m_dwProgressBytes(0)
	, m_bLooped(FALSE)
	, m_tkCurrentTime(0)
	, m_dwBufferTickLength(0)
	, m_dwCurrentTempo(0)
	, m_dwTempoMultiplier(100)
	, m_bInsertTempo(FALSE)
	, m_bBuffersPrepared(FALSE)
	, m_nCurrentBuffer(0)
	, m_uMIDIDeviceID(MIDI_MAPPER)
	, m_nEmptyBuffers(0)
	, m_bPaused(FALSE)
	, m_uCallbackStatus(0)
	, m_hBufferReturnEvent(0)

	, m_ptsTrack(0)
	, m_ptsFound(0)
	, m_dwStatus(0)
	, m_tkNext(0)
	, m_dwMallocBlocks(0)
{
	m_hBufferReturnEvent = ::CreateEvent(0, FALSE, FALSE, TEXT("Wait For Buffer Return"));
	ASSERT(m_hBufferReturnEvent != 0);
}

CMIDI::~CMIDI()
{
	Stop(FALSE);

	if(m_hBufferReturnEvent)
		::CloseHandle(m_hBufferReturnEvent);
}


//DEL BOOL CMIDI::Create(UINT uResID)
//DEL {
//DEL 	return	Create(MAKEINTRESOURCE(uResID));
//DEL }


//DEL BOOL CMIDI::Create(LPCTSTR pszResID)
//DEL {
//DEL 	//////////////////////////////////////////////////////////////////
//DEL 	// load resource
//DEL 	HINSTANCE hApp = ::GetModuleHandle(0);
//DEL 	ASSERT(hApp);
//DEL 
//DEL 	HRSRC hResInfo = ::FindResource(hApp, pszResID, TEXT("MIDI"));
//DEL 	if(hResInfo == 0)
//DEL 		return FALSE;
//DEL 
//DEL 	HGLOBAL hRes = ::LoadResource(hApp, hResInfo);
//DEL 	if(hRes == 0)
//DEL 		return FALSE;
//DEL 
//DEL 	LPVOID pTheSound = ::LockResource(hRes);
//DEL 	if(pTheSound == 0)
//DEL 		return FALSE;
//DEL 
//DEL 	DWORD dwTheSound = ::SizeofResource(hApp, hResInfo);
//DEL 
//DEL 	return Create(pTheSound, dwTheSound);
//DEL }


BOOL CMIDI::Create(LPVOID pSoundData, DWORD dwSize)
{
	if( m_pSoundData ) {
		// already created
		ASSERT(FALSE);
		return FALSE;
	}

	ASSERT(pSoundData != 0);
	ASSERT(dwSize > 0);

	register LPBYTE p = LPBYTE(pSoundData);

	// check header of MIDI
	if(*(DWORD*)p != MThd) {
		ASSERT(FALSE);
		return FALSE;
	}
	p += sizeof(DWORD);

	// check header size
	DWORD dwHeaderSize = DWORDSWAP(*(DWORD*)p);
	if( dwHeaderSize != sizeof(MIDIFILEHDR) ) {
		ASSERT(FALSE);
		return FALSE;
	}
	p += sizeof(DWORD);

	// get header
	MIDIFILEHDR hdr;
	::CopyMemory(&hdr, p, dwHeaderSize);
	m_dwFormat = DWORD(WORDSWAP(hdr.wFormat));
	m_dwTrackCount = DWORD(WORDSWAP(hdr.wTrackCount));
	m_dwTimeDivision = DWORD(WORDSWAP(hdr.wTimeDivision));
	p += dwHeaderSize;

	// create the array of tracks
	m_Tracks.resize(m_dwTrackCount);
	for(register DWORD i = 0; i < m_dwTrackCount; ++i) {
		// check header of track
		if(*(DWORD*)p != MTrk) {
			ASSERT(FALSE);
			return FALSE;
		}
		p += sizeof(DWORD);

		m_Tracks[i].dwTrackLength = DWORDSWAP(*(DWORD*)p);
		p += sizeof(DWORD);

		m_Tracks[i].pTrackStart = m_Tracks[i].pTrackCurrent = p;
			p += m_Tracks[i].dwTrackLength;

        // Handle bozo MIDI files which contain empty track chunks
		if( !m_Tracks[i].dwTrackLength ) {
			m_Tracks[i].fdwTrack |= ITS_F_ENDOFTRK;
			continue;
		}

		// We always preread the time from each track so the mixer code can
		// determine which track has the next event with a minimum of work
		if( !GetTrackVDWord( &m_Tracks[i], &m_Tracks[i].tkNextEventDue )) {
			TRACE0("Error in MIDI data\n");
			ASSERT(FALSE);
			return FALSE;
		}
	}


	m_pSoundData = pSoundData;
	m_dwSoundSize = dwSize;


	// allocate volume channels and initialise them
	m_Volumes.resize(NUM_CHANNELS, VOLUME_INIT);

	if( ! StreamBufferSetup() ) {
		ASSERT(FALSE);
		return FALSE;
	}

	return TRUE;
}


BOOL CMIDI :: Play(BOOL bInfinite /* = FALSE */) {
	if( IsPaused() ) {
		Continue();
		return TRUE;
	}

	// calling Play() while it is already playing will restart from scratch
	if( IsPlaying() )
		Stop();

	// Clear the status of our callback so it will handle
	// MOM_DONE callbacks once more
	m_uCallbackStatus = 0;

	if( !m_bLooped )
		m_bInsertTempo = TRUE;

	MMRESULT mmResult;
	if( (mmResult = midiStreamRestart(m_hStream)) != MMSYSERR_NOERROR ) {
		MidiError(mmResult);
		return FALSE;
	}

	m_bPlaying = TRUE;
	m_bLooped = bInfinite;

	return m_bPlaying;
}


BOOL CMIDI :: Stop(BOOL bReOpen /*=TRUE*/) {
	MMRESULT mmrRetVal;

	if( IsPlaying()	|| (m_uCallbackStatus != STATUS_CALLBACKDEAD) ) {
		m_bPlaying = m_bPaused = FALSE;
		if( m_uCallbackStatus != STATUS_CALLBACKDEAD && m_uCallbackStatus != STATUS_WAITINGFOREND )
			m_uCallbackStatus = STATUS_KILLCALLBACK;

		if( (mmrRetVal = midiStreamStop(m_hStream) ) != MMSYSERR_NOERROR ) {
			MidiError(mmrRetVal);
			return FALSE;
		}
		if( (mmrRetVal = midiOutReset((HMIDIOUT)m_hStream)) != MMSYSERR_NOERROR ) {
			MidiError(mmrRetVal);
			return FALSE;
		}
		// Wait for the callback thread to release this thread, which it will do by
		// calling SetEvent() once all buffers are returned to it
		if( WaitForSingleObject( m_hBufferReturnEvent, DEBUG_CALLBACK_TIMEOUT ) == WAIT_TIMEOUT ) {
			// Note, this is a risky move because the callback may be genuinely busy, but
			// when we're debugging, it's safer and faster than freezing the application,
			// which leaves the MIDI device locked up and forces a system reset...
			TRACE0("Timed out waiting for MIDI callback\n");
			m_uCallbackStatus = STATUS_CALLBACKDEAD;
		}
	}

	//m_pSoundData = NULL;//´
	if( m_uCallbackStatus == STATUS_CALLBACKDEAD ) {
		m_uCallbackStatus = 0;
		FreeBuffers();
		if( m_hStream ) {
			if( (mmrRetVal = midiStreamClose(m_hStream) ) != MMSYSERR_NOERROR ) {
				MidiError(mmrRetVal);
			}
			m_hStream = 0;
		}

		if( bReOpen ) {
			if( !StreamBufferSetup() ) {
				// Error setting up for MIDI file
				// Notification is already taken care of...
				return FALSE;
			}
			if( ! m_bLooped ) {
				Rewind();
				m_dwProgressBytes = 0;
				m_dwStatus = 0;
			}
		}
	}
	return TRUE;
}


BOOL CMIDI :: Pause() {
	if( ! m_bPaused && m_bPlaying && m_pSoundData && m_hStream ) {
		midiStreamPause(m_hStream);
		m_bPaused = TRUE;
	}
	return FALSE;
}


BOOL CMIDI :: Continue() {
	if( m_bPaused && m_bPlaying && m_pSoundData && m_hStream ) {
		midiStreamRestart(m_hStream);
		m_bPaused = FALSE;
	}
	return FALSE;
}


BOOL CMIDI :: Rewind() {
	if( ! m_pSoundData )
		return FALSE;

	for(register DWORD i = 0; i < m_dwTrackCount; ++i) {
		m_Tracks[i].pTrackCurrent = m_Tracks[i].pTrackStart;
		m_Tracks[i].byRunningStatus = 0;
		m_Tracks[i].tkNextEventDue = 0;
		m_Tracks[i].fdwTrack = 0;

        // Handle bozo MIDI files which contain empty track chunks
		if( !m_Tracks[i].dwTrackLength ) {
			m_Tracks[i].fdwTrack |= ITS_F_ENDOFTRK;
			continue;
		}

		// We always preread the time from each track so the mixer code can
		// determine which track has the next event with a minimum of work
		if( !GetTrackVDWord( &m_Tracks[i], &m_Tracks[i].tkNextEventDue )) {
			TRACE0("Error in MIDI data\n");
			ASSERT(FALSE);
			return FALSE;
		}
	}

	return TRUE;
}


DWORD CMIDI :: GetChannelCount() const {
	return m_Volumes.size();
}


void CMIDI :: SetVolume(DWORD dwPercent) {
	const DWORD dwSize = m_Volumes.size();
	for( register DWORD i = 0; i < dwSize; ++i )
		SetChannelVolume(i, dwPercent);
}


DWORD CMIDI :: GetVolume() const {
	DWORD dwVolume = 0;
	const DWORD dwSize = m_Volumes.size();
	for( register DWORD i = 0; i < dwSize; ++i )
		dwVolume += GetChannelVolume(i);

	return dwVolume / GetChannelCount();
}


void CMIDI :: SetChannelVolume(DWORD dwChannel, DWORD dwPercent) {
	ASSERT(dwChannel < m_Volumes.size());

	if( !m_bPlaying )
		return;

	m_Volumes[dwChannel] = (dwPercent > 100) ? 100 : dwPercent;
	DWORD dwEvent = MIDI_CTRLCHANGE | dwChannel | ((DWORD)MIDICTRL_VOLUME << 8) | ((DWORD)(m_Volumes[dwChannel]*VOLUME_MAX/100) << 16);
	MMRESULT mmrRetVal;
	if(( mmrRetVal = midiOutShortMsg((HMIDIOUT)m_hStream, dwEvent)) != MMSYSERR_NOERROR ) {
		MidiError(mmrRetVal);
		return;
	}
}


DWORD CMIDI :: GetChannelVolume(DWORD dwChannel) const {
	ASSERT(dwChannel < GetChannelCount());
	return m_Volumes[dwChannel];
}


void CMIDI :: SetTempo(DWORD dwPercent) {
	m_dwTempoMultiplier = dwPercent ? dwPercent : 1;
	m_bInsertTempo = TRUE;
}


DWORD CMIDI :: GetTempo() const {
	return m_dwTempoMultiplier;
}


void CMIDI :: SetInfinitePlay(BOOL bSet) {
	m_bLooped = bSet;
}

//////////////////////////////////////////////////////////////////////
// CMIDI -- implementation
//////////////////////////////////////////////////////////////////////

// This function converts MIDI data from the track buffers setup by a
// previous call to ConverterInit().  It will convert data until an error is
// encountered or the output buffer has been filled with as much event data
// as possible, not to exceed dwMaxLength. This function can take a couple
// bit flags, passed through dwFlags. Information about the success/failure
// of this operation and the number of output bytes actually converted will
// be returned in the CONVERTINFO structure pointed at by lpciInfo.
int CMIDI :: ConvertToBuffer(DWORD dwFlags, CONVERTINFO * lpciInfo) {
	int	    nChkErr;

	lpciInfo->dwBytesRecorded = 0;

	if( dwFlags & CONVERTF_RESET ) {
		m_dwProgressBytes = 0;
		m_dwStatus = 0;
		memset( &m_teTemp, 0, sizeof(TEMPEVENT));
		m_ptsTrack = m_ptsFound = 0;
	}

	// If we were already done, then return with a warning...
	if( m_dwStatus & CONVERTF_STATUS_DONE ) {
		if( m_bLooped ) {
			Rewind();
			m_dwProgressBytes = 0;
			m_dwStatus = 0;
		} else
			return CONVERTERR_DONE;
	} else if( m_dwStatus & CONVERTF_STATUS_STUCK ) {
		// The caller is asking us to continue, but we're already hosed because we
		// previously identified something as corrupt, so complain louder this time.
		return( CONVERTERR_STUCK );
	} else if( m_dwStatus & CONVERTF_STATUS_GOTEVENT ) {
		// Turn off this bit flag
		m_dwStatus ^= CONVERTF_STATUS_GOTEVENT;

		// The following code for this case is duplicated from below, and is
		// designed to handle a "straggler" event, should we have one left over
		// from previous processing the last time this function was called.

		// Don't add end of track event 'til we're done
		if( m_teTemp.byShortData[0] == MIDI_META && m_teTemp.byShortData[1] == MIDI_META_EOT ) {
			if( m_dwMallocBlocks ) {
				delete [] m_teTemp.pLongData;
				--m_dwMallocBlocks;
			}
		} else if(( nChkErr = AddEventToStreamBuffer( &m_teTemp, lpciInfo )) != CONVERTERR_NOERROR ) {
			if( nChkErr == CONVERTERR_BUFFERFULL ) {
				// Do some processing and tell caller that this buffer's full
				m_dwStatus |= CONVERTF_STATUS_GOTEVENT;
				return CONVERTERR_NOERROR;
			} else if( nChkErr == CONVERTERR_METASKIP ) {
				// We skip by all meta events that aren't tempo changes...
			} else {
				TRACE0("Unable to add event to stream buffer.\n");
				if( m_dwMallocBlocks ) {
					delete [] m_teTemp.pLongData;
					m_dwMallocBlocks--;
				}
				return( TRUE );
			}
		}
	}

	for(;;) {
		m_ptsFound = 0;
		m_tkNext = 0xFFFFFFFFL;
		// Find nearest event due
		for( register DWORD idx = 0; idx < m_Tracks.size(); ++idx ) {
			m_ptsTrack = &m_Tracks[idx];
			if( !(m_ptsTrack->fdwTrack & ITS_F_ENDOFTRK) && (m_ptsTrack->tkNextEventDue < m_tkNext) ) {
				m_tkNext = m_ptsTrack->tkNextEventDue;
				m_ptsFound = m_ptsTrack;
			}
		}

		// None found?  We must be done, so return to the caller with a smile.
		if( !m_ptsFound ) {
			m_dwStatus |= CONVERTF_STATUS_DONE;
			// Need to set return buffer members properly
			return CONVERTERR_NOERROR;
		}

		// Ok, get the event header from that track
		if( !GetTrackEvent( m_ptsFound, &m_teTemp )) {
			// Warn future calls that this converter is stuck at a corrupt spot
			// and can't continue
			m_dwStatus |= CONVERTF_STATUS_STUCK;
			return CONVERTERR_CORRUPT;
		}

		// Don't add end of track event 'til we're done
		if( m_teTemp.byShortData[0] == MIDI_META && m_teTemp.byShortData[1] == MIDI_META_EOT ) {
			if( m_dwMallocBlocks ) {
				delete [] m_teTemp.pLongData;
				--m_dwMallocBlocks;
			}
			continue;
		}

		if(( nChkErr = AddEventToStreamBuffer( &m_teTemp, lpciInfo )) != CONVERTERR_NOERROR ) {
			if( nChkErr == CONVERTERR_BUFFERFULL ) {
				// Do some processing and tell somebody this buffer is full...
				m_dwStatus |= CONVERTF_STATUS_GOTEVENT;
				return CONVERTERR_NOERROR;
			} else if( nChkErr == CONVERTERR_METASKIP ) {
				// We skip by all meta events that aren't tempo changes...
			} else {
				TRACE0("Unable to add event to stream buffer.\n");
				if( m_dwMallocBlocks ) {
					delete [] m_teTemp.pLongData;
					m_dwMallocBlocks--;
				}
				return TRUE;
			}
		}
	}	

	return CONVERTERR_NOERROR;
}

// GetTrackEvent
//
// Fills in the event struct with the next event from the track
//
// pteTemp->tkEvent will contain the absolute tick time of the event
// pteTemp->byShortData[0] will contain
//  MIDI_META if the event is a meta event;
//   in this case pteTemp->byShortData[1] will contain the meta class
//  MIDI_SYSEX or MIDI_SYSEXEND if the event is a SysEx event
//  Otherwise, the event is a channel message and pteTemp->byShortData[1]
//   and pteTemp->byShortData[2] will contain the rest of the event.
//
// pteTemp->dwEventLength will contain
//  The total length of the channel message in pteTemp->byShortData if
//   the event is a channel message
//  The total length of the paramter data pointed to by
//   pteTemp->pLongData otherwise
//
// pteTemp->pLongData will point at any additional paramters if the 
//  event is a SysEx or meta event with non-zero length; else
//  it will contain NULL
//
// Returns TRUE on success or FALSE on any kind of parse error
// Prints its own error message ONLY in the debug version
//
// Maintains the state of the input track (i.e. 
// ptsTrack->pTrackPointers, and ptsTrack->byRunningStatus).
//
BOOL CMIDI :: GetTrackEvent(TRACK * ptsTrack, TEMPEVENT * pteTemp) {
	DWORD   idx;
	UINT    dwEventLength;

	// Clear out the temporary event structure to get rid of old data...
	memset( pteTemp, 0, sizeof(TEMPEVENT));

	// Already at end of track? There's nothing to read.
    if( ptsTrack->fdwTrack & ITS_F_ENDOFTRK )
		return FALSE;

	// Get the first byte, which determines the type of event.
	BYTE byByte;
	if( !GetTrackByte(ptsTrack, &byByte) )
		return FALSE;

	// If the high bit is not set, then this is a channel message
	// which uses the status byte from the last channel message
	// we saw. NOTE: We do not clear running status across SysEx or
	// meta events even though the spec says to because there are
	// actually files out there which contain that sequence of data.
	if( !(byByte & 0x80) ) {
		// No previous status byte? We're hosed.
		if( !ptsTrack->byRunningStatus ) {
			TrackError(ptsTrack, gteBadRunStat);
			return FALSE;
		}

		pteTemp->byShortData[0] = ptsTrack->byRunningStatus;
		pteTemp->byShortData[1] = byByte;

		byByte = pteTemp->byShortData[0] & 0xF0;
		pteTemp->dwEventLength = 2;

		// Only program change and channel pressure events are 2 bytes long;
		// the rest are 3 and need another byte
		if(( byByte != MIDI_PRGMCHANGE ) && ( byByte != MIDI_CHANPRESS )) {
			if( !GetTrackByte( ptsTrack, &pteTemp->byShortData[2] ))
				return FALSE;
			++pteTemp->dwEventLength;
		}
	} else if(( byByte & 0xF0 ) != MIDI_SYSEX ) {
		// Not running status, not in SysEx range - must be
		// normal channel message (0x80-0xEF)
		pteTemp->byShortData[0] = byByte;
		ptsTrack->byRunningStatus = byByte;

		// Strip off channel and just keep message type
		byByte &= 0xF0;

		dwEventLength = ( byByte == MIDI_PRGMCHANGE || byByte == MIDI_CHANPRESS ) ? 1 : 2;
		pteTemp->dwEventLength = dwEventLength + 1;

		if( !GetTrackByte( ptsTrack, &pteTemp->byShortData[1] ))
			return FALSE;
		if( dwEventLength == 2 )
			if( !GetTrackByte( ptsTrack, &pteTemp->byShortData[2] ))
				return FALSE;
	} else if(( byByte == MIDI_SYSEX ) || ( byByte == MIDI_SYSEXEND )) {
		// One of the SysEx types. (They are the same as far as we're concerned;
		// there is only a semantic difference in how the data would actually
		// get sent when the file is played. We must take care to put the proper
		// event type back on the output track, however.)
		//
		// Parse the general format of:
		//  BYTE 	bEvent (MIDI_SYSEX or MIDI_SYSEXEND)
		//  VDWORD 	cbParms
		//  BYTE   	abParms[cbParms]
		pteTemp->byShortData[0] = byByte;
		if( !GetTrackVDWord( ptsTrack, &pteTemp->dwEventLength )) {
			TrackError( ptsTrack, gteSysExLenTrunc );
			return FALSE;
		}

		// Malloc a temporary memory block to hold the parameter data
		pteTemp->pLongData = new BYTE [pteTemp->dwEventLength];
		if( pteTemp->pLongData == 0 ) {
			TrackError( ptsTrack, gteNoMem );
			return FALSE;
		}
		// Increment our counter, which tells the program to look around for
		// a malloc block to free, should it need to exit or reset before the
		// block would normally be freed
		++m_dwMallocBlocks;

		// Copy from the input buffer to the parameter data buffer
		for( idx = 0; idx < pteTemp->dwEventLength; idx++ )
			if( !GetTrackByte( ptsTrack, pteTemp->pLongData + idx )) {
				TrackError( ptsTrack, gteSysExTrunc );
				return FALSE;
			}
	} else if( byByte == MIDI_META ) {
		// It's a meta event. Parse the general form:
		//  BYTE	bEvent	(MIDI_META)
		//  BYTE	bClass
		//  VDWORD	cbParms
		//  BYTE	abParms[cbParms]
		pteTemp->byShortData[0] = byByte;

		if( !GetTrackByte( ptsTrack, &pteTemp->byShortData[1] ))
			return FALSE;

		if( !GetTrackVDWord( ptsTrack, &pteTemp->dwEventLength )) {	
			TrackError( ptsTrack, gteMetaLenTrunc );
			return FALSE;
		}

		// NOTE: It's perfectly valid to have a meta with no data
		// In this case, dwEventLength == 0 and pLongData == NULL
		if( pteTemp->dwEventLength ) {		
			// Malloc a temporary memory block to hold the parameter data
			pteTemp->pLongData = new BYTE [pteTemp->dwEventLength];
			if( pteTemp->pLongData == 0 ) {
				TrackError( ptsTrack, gteNoMem );
				return FALSE;
			}
			// Increment our counter, which tells the program to look around for
			// a malloc block to free, should it need to exit or reset before the
			// block would normally be freed
			++m_dwMallocBlocks;

			// Copy from the input buffer to the parameter data buffer
			for( idx = 0; idx < pteTemp->dwEventLength; idx++ )
				if( !GetTrackByte( ptsTrack, pteTemp->pLongData + idx )) {
					TrackError( ptsTrack, gteMetaTrunc );
					return FALSE;
				}
		}

		if( pteTemp->byShortData[1] == MIDI_META_EOT )
			ptsTrack->fdwTrack |= ITS_F_ENDOFTRK;
	} else {
		// Messages in this range are system messages and aren't supposed to
		// be in a normal MIDI file. If they are, we've either misparsed or the
		// authoring software is stupid.
		return FALSE;
	}

	// Event time was already stored as the current track time
	pteTemp->tkEvent = ptsTrack->tkNextEventDue;

	// Now update to the next event time. The code above MUST properly
	// maintain the end of track flag in case the end of track meta is
	// missing.  NOTE: This code is a continuation of the track event
	// time pre-read which is done at the end of track initialization.
	if( !( ptsTrack->fdwTrack & ITS_F_ENDOFTRK )) {
		DWORD	tkDelta;

		if( !GetTrackVDWord( ptsTrack, &tkDelta ))
			return FALSE;

		ptsTrack->tkNextEventDue += tkDelta;
	}

	return TRUE;
}


// GetTrackVDWord
//
// Attempts to parse a variable length DWORD from the given track. A VDWord
// in a MIDI file
//  (a) is in lo-hi format 
//  (b) has the high bit set on every byte except the last
//
// Returns the DWORD in *lpdw and TRUE on success; else
// FALSE if we hit end of track first.
BOOL CMIDI :: GetTrackVDWord(TRACK * ptsTrack, LPDWORD lpdw) {
	ASSERT(ptsTrack != 0);
	ASSERT(lpdw != 0);

	if( ptsTrack->fdwTrack & ITS_F_ENDOFTRK )
		return FALSE;

	BYTE	byByte;
	DWORD	dw = 0;

	do {
		if( !GetTrackByte( ptsTrack, &byByte ))
			return FALSE;

		dw = ( dw << 7 ) | ( byByte & 0x7F );
	} while( byByte & 0x80 );

	*lpdw = dw;

	return TRUE;
}


// AddEventToStreamBuffer
//
// Put the given event into the given stream buffer at the given location
// pteTemp must point to an event filled out in accordance with the
// description given in GetTrackEvent
//
// Handles its own error notification by displaying to the appropriate
// output device (either our debugging window, or the screen).
int CMIDI :: AddEventToStreamBuffer( TEMPEVENT * pteTemp, CONVERTINFO *lpciInfo ) {
	MIDIEVENT * pmeEvent = (MIDIEVENT *)( lpciInfo->mhBuffer.lpData
							+ lpciInfo->dwStartOffset
							+ lpciInfo->dwBytesRecorded );

	// When we see a new, empty buffer, set the start time on it...
	if( !lpciInfo->dwBytesRecorded )
		lpciInfo->tkStart = m_tkCurrentTime;

	// Use the above set start time to figure out how much longer we should fill
	// this buffer before officially declaring it as "full"
	if( m_tkCurrentTime - lpciInfo->tkStart > m_dwBufferTickLength )
		if( lpciInfo->bTimesUp ) {
			lpciInfo->bTimesUp = FALSE;
			return CONVERTERR_BUFFERFULL;
		} else
			lpciInfo->bTimesUp = TRUE;

	DWORD tkNow = m_tkCurrentTime;

	// Delta time is absolute event time minus absolute time
	// already gone by on this track
	DWORD tkDelta = pteTemp->tkEvent - m_tkCurrentTime;

	// Event time is now current time on this track
	m_tkCurrentTime = pteTemp->tkEvent;

	if( m_bInsertTempo ) {
		m_bInsertTempo = FALSE;

		if( lpciInfo->dwMaxLength-lpciInfo->dwBytesRecorded < 3*sizeof(DWORD)) {
			// Cleanup from our write operation
			return CONVERTERR_BUFFERFULL;
		}
		if( m_dwCurrentTempo ) {
			pmeEvent->dwDeltaTime = 0;
			pmeEvent->dwStreamID = 0;
			pmeEvent->dwEvent = ( m_dwCurrentTempo * 100 ) / m_dwTempoMultiplier;
			pmeEvent->dwEvent |= (((DWORD)MEVT_TEMPO ) << 24 ) | MEVT_F_SHORT;

			lpciInfo->dwBytesRecorded += 3 * sizeof(DWORD);
			pmeEvent += 3 * sizeof(DWORD);
		}
	}

	if( pteTemp->byShortData[0] < MIDI_SYSEX ) {
		// Channel message. We know how long it is, just copy it.
		// Need 3 DWORD's: delta-t, stream-ID, event
		if( lpciInfo->dwMaxLength-lpciInfo->dwBytesRecorded < 3*sizeof(DWORD)) {
			// Cleanup from our write operation
			return CONVERTERR_BUFFERFULL;
		}

		pmeEvent->dwDeltaTime = tkDelta;
		pmeEvent->dwStreamID = 0;
		pmeEvent->dwEvent = ( pteTemp->byShortData[0] )
					| (((DWORD)pteTemp->byShortData[1] ) << 8 )
					| (((DWORD)pteTemp->byShortData[2] ) << 16 )
					| MEVT_F_SHORT;

		if((( pteTemp->byShortData[0] & 0xF0) == MIDI_CTRLCHANGE ) && ( pteTemp->byShortData[1] == MIDICTRL_VOLUME )) {
			// If this is a volume change, generate a callback so we can grab
			// the new volume for our cache
			pmeEvent->dwEvent |= MEVT_F_CALLBACK;
		}
		lpciInfo->dwBytesRecorded += 3 *sizeof(DWORD);
	} else if(( pteTemp->byShortData[0] == MIDI_SYSEX ) || ( pteTemp->byShortData[0] == MIDI_SYSEXEND )) {
		TRACE0("AddEventToStreamBuffer: Ignoring SysEx event.\n");
		if( m_dwMallocBlocks ) {
			delete [] pteTemp->pLongData;
			--m_dwMallocBlocks;
		}
	} else {
		// Better be a meta event.
		//  BYTE	byEvent
		//  BYTE	byEventType
		//  VDWORD	dwEventLength
		//  BYTE	pLongEventData[dwEventLength]
		ASSERT( pteTemp->byShortData[0] == MIDI_META );

		// The only meta-event we care about is change tempo
		if( pteTemp->byShortData[1] != MIDI_META_TEMPO ) {
			if( m_dwMallocBlocks ) {
				delete [] pteTemp->pLongData;
				--m_dwMallocBlocks;
			}
			return CONVERTERR_METASKIP;
		}

		// We should have three bytes of parameter data...
		ASSERT(pteTemp->dwEventLength == 3);

		// Need 3 DWORD's: delta-t, stream-ID, event data
		if( lpciInfo->dwMaxLength - lpciInfo->dwBytesRecorded < 3 *sizeof(DWORD)) {
			// Cleanup the temporary event if necessary and return
			if( m_dwMallocBlocks ) {
				delete [] pteTemp->pLongData;
				--m_dwMallocBlocks;
			}
			return CONVERTERR_BUFFERFULL;
		}

		pmeEvent->dwDeltaTime = tkDelta;
		pmeEvent->dwStreamID = 0;
	// Note: this is backwards from above because we're converting a single
	//		 data value from hi-lo to lo-hi format...
		pmeEvent->dwEvent = ( pteTemp->pLongData[2] )
				| (((DWORD)pteTemp->pLongData[1] ) << 8 )
				| (((DWORD)pteTemp->pLongData[0] ) << 16 );

		// This next step has absolutely nothing to do with the conversion of a
		// MIDI file to a stream, it's simply put here to add the functionality
		// of the tempo slider. If you don't need this, be sure to remove the
		// next two lines.
		m_dwCurrentTempo = pmeEvent->dwEvent;
		pmeEvent->dwEvent = (pmeEvent->dwEvent * 100 ) / m_dwTempoMultiplier;

		pmeEvent->dwEvent |= (((DWORD)MEVT_TEMPO ) << 24 ) | MEVT_F_SHORT;

		m_dwBufferTickLength = (m_dwTimeDivision * 1000 * BUFFER_TIME_LENGTH) / m_dwCurrentTempo;
		TRACE1("m_dwBufferTickLength = %lu\n", m_dwBufferTickLength);

		if( m_dwMallocBlocks ) {
			delete [] pteTemp->pLongData;
			--m_dwMallocBlocks;
		}
		lpciInfo->dwBytesRecorded += 3 *sizeof(DWORD);
	}

	return CONVERTERR_NOERROR;
}


// StreamBufferSetup()
//
// Opens a MIDI stream. Then it goes about converting the data into a midiStream buffer for playback.
BOOL CMIDI :: StreamBufferSetup() {
	int		nChkErr;
	BOOL	bFoundEnd = FALSE;

	MMRESULT		mmrRetVal;

	if( !m_hStream )
		if(( mmrRetVal = midiStreamOpen( &m_hStream,
					&m_uMIDIDeviceID,
					DWORD(1), DWORD(MidiProc),
					DWORD(this),
					CALLBACK_FUNCTION )) != MMSYSERR_NOERROR ) {
		MidiError(mmrRetVal);
		return FALSE;
	}

	// allocate stream buffers and initialise them
	m_StreamBuffers.resize(NUM_STREAM_BUFFERS);

	MIDIPROPTIMEDIV mptd;
	mptd.cbStruct = sizeof(mptd);
	mptd.dwTimeDiv = m_dwTimeDivision;
	if(( mmrRetVal = midiStreamProperty( m_hStream, (LPBYTE)&mptd,
					    MIDIPROP_SET | MIDIPROP_TIMEDIV )) != MMSYSERR_NOERROR ) {
		MidiError( mmrRetVal );
		return FALSE;
	}

	m_nEmptyBuffers = 0;
	DWORD dwConvertFlag = CONVERTF_RESET;

	for( m_nCurrentBuffer = 0; m_nCurrentBuffer < NUM_STREAM_BUFFERS; m_nCurrentBuffer++ ) {
		m_StreamBuffers[m_nCurrentBuffer].mhBuffer.dwBufferLength = OUT_BUFFER_SIZE;
		m_StreamBuffers[m_nCurrentBuffer].mhBuffer.lpData = new char [OUT_BUFFER_SIZE];
		if( m_StreamBuffers[m_nCurrentBuffer].mhBuffer.lpData == 0 )
			return FALSE;

		// Tell the converter to convert up to one entire buffer's length of output
		// data. Also, set a flag so it knows to reset any saved state variables it
		// may keep from call to call.
		m_StreamBuffers[m_nCurrentBuffer].dwStartOffset = 0;
		m_StreamBuffers[m_nCurrentBuffer].dwMaxLength = OUT_BUFFER_SIZE;
		m_StreamBuffers[m_nCurrentBuffer].tkStart = 0;
		m_StreamBuffers[m_nCurrentBuffer].bTimesUp = FALSE;

		if(( nChkErr = ConvertToBuffer( dwConvertFlag, &m_StreamBuffers[m_nCurrentBuffer] )) != CONVERTERR_NOERROR ) {
			if( nChkErr == CONVERTERR_DONE ) {
				bFoundEnd = TRUE;
			} else {
				TRACE0("Initial conversion pass failed\n");
				return FALSE;
			}
		}
		m_StreamBuffers[m_nCurrentBuffer].mhBuffer.dwBytesRecorded = m_StreamBuffers[m_nCurrentBuffer].dwBytesRecorded;

		if( !m_bBuffersPrepared )
			if(( mmrRetVal = midiOutPrepareHeader( (HMIDIOUT)m_hStream,
						&m_StreamBuffers[m_nCurrentBuffer].mhBuffer,
						sizeof(MIDIHDR))) != MMSYSERR_NOERROR ) {
				MidiError( mmrRetVal );
				return FALSE;
			}

		if(( mmrRetVal = midiStreamOut( m_hStream,
						&m_StreamBuffers[m_nCurrentBuffer].mhBuffer,
						sizeof(MIDIHDR))) != MMSYSERR_NOERROR ) {
			MidiError(mmrRetVal);
			break;
		}
		dwConvertFlag = 0;

		if( bFoundEnd )
			break;
	}

	m_bBuffersPrepared = TRUE;
	m_nCurrentBuffer = 0;
	return TRUE;
}

// This function unprepares and frees all our buffers -- something we must
// do to work around a bug in MMYSYSTEM that prevents a device from playing
// back properly unless it is closed and reopened after each stop.
void CMIDI :: FreeBuffers() {
	DWORD	idx;
	MMRESULT	mmrRetVal;

	if( m_bBuffersPrepared ) {
		for( idx = 0; idx < NUM_STREAM_BUFFERS; idx++ )
			if(( mmrRetVal = midiOutUnprepareHeader( (HMIDIOUT)m_hStream,
								&m_StreamBuffers[idx].mhBuffer,
								sizeof(MIDIHDR))) != MMSYSERR_NOERROR ) {
				MidiError(mmrRetVal);
			}
		m_bBuffersPrepared = FALSE;
	}
	// Free our stream buffers...
	for( idx = 0; idx < NUM_STREAM_BUFFERS; idx++ )
	if( m_StreamBuffers[idx].mhBuffer.lpData ) {
		delete [] m_StreamBuffers[idx].mhBuffer.lpData;
		m_StreamBuffers[idx].mhBuffer.lpData = 0;
	}
}

//////////////////////////////////////////////////////////////////////
// CMIDI -- error handling
//////////////////////////////////////////////////////////////////////

void CMIDI :: MidiError(MMRESULT mmResult) {
	#ifdef _DEBUG
		char chText[512];
		midiOutGetErrorText(mmResult, chText, sizeof(chText));
		TRACE1("Midi error: %hs\n", chText);
	#endif
}


void CMIDI :: TrackError(TRACK * ptsTrack, LPSTR lpszErr ) {
	TRACE1("Track buffer offset %lu\n", (DWORD)(ptsTrack->pTrackCurrent - ptsTrack->pTrackStart));
    TRACE1("Track total length %lu\n", ptsTrack->dwTrackLength);
	TRACE1("%hs\n", lpszErr);
}

//////////////////////////////////////////////////////////////////////
// CMIDI -- overridables
//////////////////////////////////////////////////////////////////////

void CMIDI :: OnMidiOutOpen() {
}


void CMIDI :: OnMidiOutDone(MIDIHDR & rHdr) {
	if( m_uCallbackStatus == STATUS_CALLBACKDEAD )
		return;

	++m_nEmptyBuffers;

	if( m_uCallbackStatus == STATUS_WAITINGFOREND ) {
		if( m_nEmptyBuffers < NUM_STREAM_BUFFERS )
			return;
		else {
			m_uCallbackStatus = STATUS_CALLBACKDEAD;
			Stop();
			SetEvent(m_hBufferReturnEvent);
			SetEvent(m_hhLoopPlayEvent);//һ,
			return;
		}
	}

	// This flag is set whenever the callback is waiting for all buffers to
	// come back.
	if( m_uCallbackStatus == STATUS_KILLCALLBACK ) {
		// Count NUM_STREAM_BUFFERS-1 being returned for the last time
		if( m_nEmptyBuffers < NUM_STREAM_BUFFERS )
			return;
		else {
			// Change the status to callback dead
			m_uCallbackStatus = STATUS_CALLBACKDEAD;
			SetEvent(m_hBufferReturnEvent);
			return;
		}
	}

	m_dwProgressBytes += m_StreamBuffers[m_nCurrentBuffer].mhBuffer.dwBytesRecorded;

	///////////////////////////////////////////////////////////////////////////////
	// Fill an available buffer with audio data again...

	if( m_bPlaying && m_nEmptyBuffers ) {
		m_StreamBuffers[m_nCurrentBuffer].dwStartOffset = 0;
		m_StreamBuffers[m_nCurrentBuffer].dwMaxLength = OUT_BUFFER_SIZE;
		m_StreamBuffers[m_nCurrentBuffer].tkStart = 0;
		m_StreamBuffers[m_nCurrentBuffer].dwBytesRecorded = 0;
		m_StreamBuffers[m_nCurrentBuffer].bTimesUp = FALSE;

		int nChkErr;

		if(( nChkErr = ConvertToBuffer( 0, &m_StreamBuffers[m_nCurrentBuffer] )) != CONVERTERR_NOERROR ) {
			if( nChkErr == CONVERTERR_DONE ) {
				m_uCallbackStatus = STATUS_WAITINGFOREND;
				
				
				return;
			} else {
				TRACE0("MidiProc() conversion pass failed!\n");
				return;
			}
		}

		m_StreamBuffers[m_nCurrentBuffer].mhBuffer.dwBytesRecorded = m_StreamBuffers[m_nCurrentBuffer].dwBytesRecorded;

		MMRESULT mmrRetVal;
		if( (mmrRetVal = midiStreamOut(m_hStream, &m_StreamBuffers[m_nCurrentBuffer].mhBuffer, sizeof(MIDIHDR))) != MMSYSERR_NOERROR ) {
			MidiError(mmrRetVal);
			return;
		}
		m_nCurrentBuffer = ( m_nCurrentBuffer + 1 ) % NUM_STREAM_BUFFERS;
		m_nEmptyBuffers--;
	}
}


void CMIDI :: OnMidiOutPositionCB(MIDIHDR & rHdr, MIDIEVENT & rEvent) {
	if( MIDIEVENT_TYPE(rEvent.dwEvent) == MIDI_CTRLCHANGE )
	{
		if( MIDIEVENT_DATA1(rEvent.dwEvent) == MIDICTRL_VOLUME ) {
			// Mask off the channel number and cache the volume data byte
			m_Volumes[MIDIEVENT_CHANNEL(rEvent.dwEvent)] = DWORD(MIDIEVENT_VOLUME(rEvent.dwEvent)*100/VOLUME_MAX);
			/*
			if( m_pWndParent && ::IsWindow(m_pWndParent->GetSafeHwnd()) )
				// Do not use SendMessage(), because a change of the midi stream has no effect
				// during callback handling, so if the owner wants to adjust the volume, as a
				// result of the windows message, (s)he will not hear that change.
				m_pWndParent->PostMessage(
					WM_MIDI_VOLUMECHANGED,
					WPARAM(this),
					LPARAM(
						MAKELONG(
							WORD(MIDIEVENT_CHANNEL(rEvent.dwEvent)),
							WORD(MIDIEVENT_VOLUME(rEvent.dwEvent)*100/VOLUME_MAX)
						)
					)
				);
				*/
		}
	}
}


void CMIDI :: OnMidiOutClose() {
}

//////////////////////////////////////////////////////////////////////
// CMIDI -- static members
//////////////////////////////////////////////////////////////////////

void CMIDI :: MidiProc(HMIDIOUT hMidi, UINT uMsg, DWORD dwInstanceData, DWORD dwParam1, DWORD dwParam2) {
	CMIDI * pMidi = (CMIDI *) dwInstanceData;
	ASSERT(pMidi != 0);
	MIDIHDR * pHdr = (MIDIHDR*) dwParam1;

	switch(uMsg) {
		case MOM_OPEN:
			pMidi->OnMidiOutOpen();
			break;

		case MOM_CLOSE:
			pMidi->OnMidiOutClose();
			break;

		case MOM_DONE:
			ASSERT(pHdr != 0);
			pMidi->OnMidiOutDone(*pHdr);
			break;

		case MOM_POSITIONCB:
			ASSERT(pHdr != 0);
			pMidi->OnMidiOutPositionCB(*pHdr, *((MIDIEVENT*)(pHdr->lpData + pHdr->dwOffset)));
			break;

		default:
			break;
	}
}


================================================
FILE: krnln/midi.h
================================================
/////////////////////////////////////////////////////////////////////////////
// Copyright (C) 1998 by Jrg Knig
// All rights reserved
//
// This file is part of the completely free tetris clone "CGTetris".
//
// This is free software.
// You may redistribute it by any means providing it is not sold for profit
// without the authors written consent.
//
// No warrantee of any kind, expressed or implied, is included with this
// software; use at your own risk, responsibility for damages (if any) to
// anyone resulting from the use of this software rests entirely with the
// user.
//
// Send bug reports, bug fixes, enhancements, requests, flames, etc., and
// I'll try to keep a version up to date.  I can be reached as follows:
//    J.Koenig@adg.de                 (company site)
//    Joerg.Koenig@rhein-neckar.de    (private site)
/////////////////////////////////////////////////////////////////////////////


// Midi.h : main header file for the MIDI application
//

// This class is based on the DirectX sample "mstream".

#ifndef MIDI_h
#define MIDI_h

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

#include <mmsystem.h>
#pragma message("linking with multimedia library")
#pragma comment(lib, "winmm.lib")

#include <vector>
using namespace std;


// This message is sent to the controlling window, if the volume changes in
// another way than explicitly set by the owner of the CMIDI object.
// WPARAM	the pointer to the MIDI object
// LPARAM	lo-word: the number of the channel that changed volume
//			hi-word: the new volume in percent
#define	WM_MIDI_VOLUMECHANGED	WM_USER+23


#define MIDI_CTRLCHANGE			((BYTE)0xB0)		// + ctrlr + value
#define MIDI_PRGMCHANGE			((BYTE)0xC0)		// + new patch
#define MIDI_CHANPRESS			((BYTE)0xD0)		// + pressure (1 byte)

#define MIDICTRL_VOLUME			((BYTE)0x07)

#define MIDIEVENT_CHANNEL(dw)	(dw & 0x0000000F)
#define MIDIEVENT_TYPE(dw)		(dw & 0x000000F0)
#define MIDIEVENT_DATA1(dw)		((dw & 0x0000FF00) >> 8)
#define MIDIEVENT_VOLUME(dw)	((dw & 0x007F0000) >> 16)

#define MIDI_SYSEX				((BYTE)0xF0)		// SysEx begin
#define MIDI_SYSEXEND			((BYTE)0xF7)		// SysEx end
#define MIDI_META				((BYTE)0xFF)		// Meta event begin
#define MIDI_META_TEMPO			((BYTE)0x51)		// Tempo change
#define MIDI_META_EOT			((BYTE)0x2F)		// End-of-track


// flags for the ConvertToBuffer() method
#define CONVERTF_RESET				0x00000001
#define CONVERTF_STATUS_DONE		0x00000001
#define CONVERTF_STATUS_STUCK		0x00000002
#define CONVERTF_STATUS_GOTEVENT	0x00000004

// Return values from the ConvertToBuffer() method
#define CONVERTERR_NOERROR		0		// No error occured
#define CONVERTERR_CORRUPT		-101	// The input file is corrupt
// The converter has already encountered a corrupt file and cannot convert any
// more of this file -- must reset the converter
#define CONVERTERR_STUCK		-102
#define CONVERTERR_DONE			-103	// Converter is done
#define CONVERTERR_BUFFERFULL	-104	// The buffer is full
#define CONVERTERR_METASKIP		-105	// Skipping unknown meta event

#define STATUS_KILLCALLBACK		100		// Signals that the callback should die
#define STATUS_CALLBACKDEAD		200		// Signals callback is done processing
#define STATUS_WAITINGFOREND	300		// Callback's waiting for buffers to play

// Description of a track
//
struct TRACK
{
	DWORD	fdwTrack;		// Track's flags
	DWORD	dwTrackLength;	// Total bytes in track
	LPBYTE	pTrackStart;	// -> start of track data buffer
	LPBYTE	pTrackCurrent;	// -> next byte to read in buffer
	DWORD	tkNextEventDue;	// Absolute time of next event in track
	BYTE	byRunningStatus;// Running status from last channel msg

	TRACK()
		: fdwTrack(0)
		, dwTrackLength(0)
		, pTrackStart(0)
		, pTrackCurrent(0)
		, tkNextEventDue(0)
		, byRunningStatus(0)
	{
	}
};

#define ITS_F_ENDOFTRK		0x00000001


// This structure is used to pass information to the ConvertToBuffer()
// system and then internally by that function to send information about the
// target stream buffer and current state of the conversion process to internal
// lower level conversion routines.
struct CONVERTINFO
{
    MIDIHDR	mhBuffer;			// Standard Windows stream buffer header
    DWORD	dwStartOffset;		// Start offset from mhStreamBuffer.lpStart
    DWORD	dwMaxLength;		// Max length to convert on this pass
    DWORD	dwBytesRecorded;
    DWORD	tkStart;
    BOOL	bTimesUp;

	CONVERTINFO()
		: dwStartOffset(0)
		, dwMaxLength(0)
		, dwBytesRecorded(0)
		, tkStart(0)
		, bTimesUp(FALSE)
	{
		memset(&mhBuffer, 0, sizeof(MIDIHDR));
	}
};

// Temporary event structure which stores event data until we're ready to
// dump it into a stream buffer
struct TEMPEVENT
{
	DWORD	tkEvent;		// Absolute time of event
	BYTE	byShortData[4];	// Event type and parameters if channel msg
	DWORD	dwEventLength;	// Length of data which follows if meta or sysex
	LPBYTE	pLongData;		// -> Event data if applicable
};

class CMIDI  
{
protected:
	typedef vector<TRACK>		TrackArray_t;
	typedef vector<DWORD>		VolumeArray_t;
	typedef vector<CONVERTINFO>	ConvertArray_t;

	enum {
		NUM_CHANNELS = 16,		// 16 volume channels
		VOLUME_INIT = 100,		// 100% volume by default
		NUM_STREAM_BUFFERS = 2,
		OUT_BUFFER_SIZE = 1024,	// Max stream buffer size in bytes
		DEBUG_CALLBACK_TIMEOUT = 2000,
		VOLUME_MIN = 0,
		VOLUME_MAX = 127		// == 100%
	};

public:
	CMIDI();
	virtual ~CMIDI();
	HANDLE			m_hhLoopPlayEvent;
	BOOL	Create(LPVOID pSoundData, DWORD dwSize);

	BOOL	Play(BOOL bInfinite = FALSE);
	BOOL	Stop(BOOL bReOpen = TRUE);
	BOOL	IsPlaying() const { return m_bPlaying; }

	BOOL	Pause();
	BOOL	Continue();
	BOOL	IsPaused() const { return m_bPaused; }

		// Set playback position back to the start
	BOOL	Rewind();

		// Get the number of volume channels
	DWORD	GetChannelCount() const;

		// Set the volume of a channel in percent. Channels are from 0 to (GetChannelCount()-1)
	void	SetChannelVolume(DWORD channel, DWORD percent);

		// Get the volume of a channel in percent
	DWORD	GetChannelVolume(DWORD channel) const;
	
		// Set the volume for all channels in percent
	void	SetVolume(DWORD percent);

		// Get the average volume for all channels
	DWORD	GetVolume() const;

		// Set the tempo of the playback. Default: 100%
	void	SetTempo(DWORD percent);

		// Get the current tempo in percent (usually 100)
	DWORD	GetTempo() const;

		// You can (un)set an infinite loop during playback.
		// Note that "Play()" resets this setting!
	void	SetInfinitePlay(BOOL bSet = TRUE);

protected:	// implementation
		// This function converts MIDI data from the track buffers.
	int		ConvertToBuffer(DWORD dwFlags, CONVERTINFO * lpciInfo);

		// Fills in the event struct with the next event from the track
	BOOL	GetTrackEvent(TRACK * ptsTrack, TEMPEVENT * pteTemp);

		// Retrieve the next byte from the track buffer, refilling the buffer from
		// disk if necessary.
	BOOL	GetTrackByte(TRACK * ptsTrack, LPBYTE lpbyByte) {
				if( DWORD(ptsTrack->pTrackCurrent - ptsTrack->pTrackStart) == ptsTrack->dwTrackLength )
					return FALSE;
				*lpbyByte = *ptsTrack->pTrackCurrent++;
				return TRUE;
			}

		// Attempts to parse a variable length DWORD from the given track.
	BOOL	GetTrackVDWord(TRACK * ptsTrack, LPDWORD lpdw);

		// Put the given event into the given stream buffer at the given location.
	int		AddEventToStreamBuffer( TEMPEVENT * pteTemp, CONVERTINFO * lpciInfo );

		// Opens a MIDI stream. Then it goes about converting the data into a midiStream buffer for playback.
	BOOL	StreamBufferSetup();

	void	FreeBuffers();


protected:	// error handling
		// The default implementation writes the error message in the
		// debuggers output window. Override if you want a different
		// behavior.
	virtual void	MidiError(MMRESULT Result);

		// Failure in converting track into stream.
		// The default implementation displays the offset and the total
		// number of bytes of the failed track and the error message in
		// the debuggers output window. 
	virtual void	TrackError(TRACK *, LPSTR ErrMsg);


protected:	// overridables
		// NOTE THAT, IF YOU OVERRIDE ONE OF THESE METHODS, YOU MUST CALL
		// THE BASE CLASS IMPLEMENTATION TOO!

		// called when a MIDI output device is opened
	virtual void	OnMidiOutOpen();
	
		// called when the MIDI output device is closed
	virtual void	OnMidiOutClose();

		// called when the specified system-exclusive or stream buffer
		// has been played and is being returned to the application
	virtual void	OnMidiOutDone(MIDIHDR &);

		// called when a MEVT_F_CALLBACK event is reached in the MIDI output stream
	virtual void	OnMidiOutPositionCB(MIDIHDR &, MIDIEVENT &);


private:	// callback procedure
		// This procedure calls the overridables above.
	static void	CALLBACK	MidiProc(HMIDIOUT, UINT, DWORD, DWORD, DWORD);


protected:	// data members
	DWORD			m_dwSoundSize;
	LPVOID			m_pSoundData;
	DWORD			m_dwFormat;
	DWORD			m_dwTrackCount;
	DWORD			m_dwTimeDivision;
	BOOL			m_bPlaying;
	HMIDISTRM		m_hStream;
	DWORD			m_dwProgressBytes;
	BOOL			m_bLooped;
	DWORD			m_tkCurrentTime;
	DWORD			m_dwBufferTickLength;
	DWORD			m_dwCurrentTempo;
	DWORD			m_dwTempoMultiplier;
	BOOL			m_bInsertTempo;
	BOOL			m_bBuffersPrepared;
	int				m_nCurrentBuffer;
	UINT			m_uMIDIDeviceID;
	int				m_nEmptyBuffers;
	BOOL			m_bPaused;
	UINT			m_uCallbackStatus;
	HANDLE			m_hBufferReturnEvent;
	TrackArray_t	m_Tracks;
	VolumeArray_t	m_Volumes;
	ConvertArray_t	m_StreamBuffers;

	// data members especially for ConvertToBuffer()
    TRACK *			m_ptsTrack;
	TRACK *			m_ptsFound;
    DWORD			m_dwStatus;
    DWORD			m_tkNext;
	DWORD			m_dwMallocBlocks;
    TEMPEVENT		m_teTemp;
};

//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.

#endif // MIDI_h


================================================
FILE: krnln/replaceText.cpp
================================================
#include "stdafx.h"
#include "mem.h"
#include "Myfunctions.h"
/*
BOOL replaceText(LPSTR& pDest,LPSTR pSub,LPSTR pRplStr,BOOL bNeedFree)
{
//ͳҵĴͻ峤
	INT nSubLen =strlen(pSub);
	INT nLen = strlen(pDest);
	char* pStart = pDest;
	char* pEnd = pDest+nLen-nSubLen;

	INT nFind = 0;
	while(pStart <= pEnd)
	{
		if(strncmp(pStart,pSub,nSubLen)==0)
		{
			nFind++;
			pStart+=nSubLen;
		}
		else
		{
			if(*pStart<0)
				pStart+=2;
			else
				pStart++;
		}
	}
	if(nFind==0)
	{
		return FALSE;
	}
	INT nStrRpl = strlen(pRplStr);

	INT nBuf = nLen + (nStrRpl - nSubLen) * nFind;
	char *pText = (char*)malloc(nBuf+1);
	char* pszDest = pText;
	


//ʼ滻
	pStart = pDest;
	pEnd = pDest+nLen-nSubLen;
	char* pSrc = pDest;
	while(pStart <= pEnd)
	{
		if(strncmp(pStart,pSub,nSubLen)==0)
		{
			INT nStr = pStart - pSrc;
			if(nStr)
			{
				strncpy(pszDest,pSrc,nStr);//ϴζ
				pszDest+=nStr;
				*pszDest =0;
			}
				
			strncpy(pszDest,pRplStr,nStrRpl);//滻ı
			pszDest+=nStrRpl;
			*pszDest =0;
			

	
			pStart+=nSubLen;//һ;
			pSrc = pStart; //һ;
			nFind--;
			if(nFind == 0)
			{
				if(pStart <= pEnd)
					strcat(pText,pStart);
				break;
			}
		}
		else
		{
			if(*pStart<0)
				pStart+=2;
			else
				pStart++;
		}
	}

	pText [nBuf]=0;
	if(bNeedFree)
		free(pDest);
	pDest = pText;
	
	return TRUE;


}*/
BOOL replaceText(LPSTR& pDest,LPSTR pSub,LPSTR pRplStr,BOOL bNeedFree){
//ʼ滻
	CFreqMem cDest;

	char* pStart = pDest;
	char* pEnd = pDest + mystrlen(pDest);
	INT nFind = 0;
	char* pSrc = pDest;
	INT nLen = mystrlen(pDest);
	INT nStrRpl = mystrlen(pRplStr);
	INT nSubLen = mystrlen(pSub);
	while(pStart < pEnd)
	{
		if(strncmp(pStart,pSub,nSubLen)==0)
		{
			INT nStr = pStart - pSrc;
			cDest.Append((LPBYTE)pSrc,nStr);//ϴζ
			if(pRplStr)
				cDest.Append((LPBYTE)pRplStr,nStrRpl);//滻ı
			
			pStart+=nSubLen;
			pSrc = pStart; //һ;
			nFind++;
			
		}
		else
		{
			if(*pStart<0)
				pStart+=2;
			else
				pStart++;
		}
	}
	if(nFind==0){
		cDest.Free();
		return FALSE;
	}
	if(pStart - pDest<= nLen){
		INT nLen = tcsallbytes(pSrc);
		cDest.Append((LPBYTE)pSrc, nLen);
	}


	INT nBufLen = nLen+1;
	char* m_pText = (char*)malloc(nBufLen);
	memset(m_pText,0,nBufLen);
	memcpy(m_pText,cDest.GetPtr(),cDest.GetSize());
	cDest.Free();

	if(bNeedFree)
		free(pDest);
	pDest=m_pText;
	bNeedFree = TRUE;

	return TRUE;
}

================================================
FILE: krnln_VC6.dsw
================================================
Microsoft Developer Studio Workspace File, Format Version 6.00
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!

###############################################################################

Project: "krnln"=.\Project\krnln_VC6.dsp - Package Owner=<4>

Package=<5>
{{{
}}}

Package=<4>
{{{
}}}

###############################################################################

Project: "krnln_Obj"=.\Project\krnln_VC6_Obj.dsp - Package Owner=<4>

Package=<5>
{{{
}}}

Package=<4>
{{{
}}}

###############################################################################

Project: "MFC_Obj"=.\Project\MFCBlackMoon_VC6.dsp - Package Owner=<4>

Package=<5>
{{{
}}}

Package=<4>
{{{
}}}

###############################################################################

Global:

Package=<5>
{{{
}}}

Package=<3>
{{{
}}}

###############################################################################



================================================
FILE: krnln_VS2019.sln
================================================

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.29519.87
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "krnln", "Project\krnln_VS2019.vcxproj", "{90C7C825-74BF-4F91-BF9C-4A1E762F24B9}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "krnln_Obj", "Project\krnln_VS2019_Obj.vcxproj", "{9EF1C5E2-3C57-47CE-9F68-DACA1CD298D4}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MFCBlackMoon", "Project\MFCBlackMoon_VS2019.vcxproj", "{302FE4C1-503E-476A-AD7B-D6768D2E0158}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|x64 = Debug|x64
		Debug|x86 = Debug|x86
		Release|x64 = Release|x64
		Release|x86 = Release|x86
		ReleaseDll|x64 = ReleaseDll|x64
		ReleaseDll|x86 = ReleaseDll|x86
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{90C7C825-74BF-4F91-BF9C-4A1E762F24B9}.Debug|x64.ActiveCfg = Debug|x64
		{90C7C825-74BF-4F91-BF9C-4A1E762F24B9}.Debug|x64.Build.0 = Debug|x64
		{90C7C825-74BF-4F91-BF9C-4A1E762F24B9}.Debug|x86.ActiveCfg = Debug|Win32
		{90C7C825-74BF-4F91-BF9C-4A1E762F24B9}.Debug|x86.Build.0 = Debug|Win32
		{90C7C825-74BF-4F91-BF9C-4A1E762F24B9}.Release|x64.ActiveCfg = Release|x64
		{90C7C825-74BF-4F91-BF9C-4A1E762F24B9}.Release|x64.Build.0 = Release|x64
		{90C7C825-74BF-4F91-BF9C-4A1E762F24B9}.Release|x86.ActiveCfg = Release|Win32
		{90C7C825-74BF-4F91-BF9C-4A1E762F24B9}.Release|x86.Build.0 = Release|Win32
		{90C7C825-74BF-4F91-BF9C-4A1E762F24B9}.ReleaseDll|x64.ActiveCfg = Release|x64
		{90C7C825-74BF-4F91-BF9C-4A1E762F24B9}.ReleaseDll|x64.Build.0 = Release|x64
		{90C7C825-74BF-4F91-BF9C-4A1E762F24B9}.ReleaseDll|x86.ActiveCfg = Release|Win32
		{90C7C825-74BF-4F91-BF9C-4A1E762F24B9}.ReleaseDll|x86.Build.0 = Release|Win32
		{9EF1C5E2-3C57-47CE-9F68-DACA1CD298D4}.Debug|x64.ActiveCfg = Debug|x64
		{9EF1C5E2-3C57-47CE-9F68-DACA1CD298D4}.Debug|x86.ActiveCfg = Debug|Win32
		{9EF1C5E2-3C57-47CE-9F68-DACA1CD298D4}.Release|x64.ActiveCfg = Release|x64
		{9EF1C5E2-3C57-47CE-9F68-DACA1CD298D4}.Release|x86.ActiveCfg = Release|Win32
		{9EF1C5E2-3C57-47CE-9F68-DACA1CD298D4}.ReleaseDll|x64.ActiveCfg = Release|x64
		{9EF1C5E2-3C57-47CE-9F68-DACA1CD298D4}.ReleaseDll|x64.Build.0 = Release|x64
		{9EF1C5E2-3C57-47CE-9F68-DACA1CD298D4}.ReleaseDll|x86.ActiveCfg = Release|Win32
		{302FE4C1-503E-476A-AD7B-D6768D2E0158}.Debug|x64.ActiveCfg = Debug|x64
		{302FE4C1-503E-476A-AD7B-D6768D2E0158}.Debug|x64.Build.0 = Debug|x64
		{302FE4C1-503E-476A-AD7B-D6768D2E0158}.Debug|x86.ActiveCfg = Debug|Win32
		{302FE4C1-503E-476A-AD7B-D6768D2E0158}.Release|x64.ActiveCfg = Release|x64
		{302FE4C1-503E-476A-AD7B-D6768D2E0158}.Release|x64.Build.0 = Release|x64
		{302FE4C1-503E-476A-AD7B-D6768D2E0158}.Release|x86.ActiveCfg = Release|Win32
		{302FE4C1-503E-476A-AD7B-D6768D2E0158}.ReleaseDll|x64.ActiveCfg = ReleaseDll|x64
		{302FE4C1-503E-476A-AD7B-D6768D2E0158}.ReleaseDll|x64.Build.0 = ReleaseDll|x64
		{302FE4C1-503E-476A-AD7B-D6768D2E0158}.ReleaseDll|x86.ActiveCfg = ReleaseDll|Win32
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {86CE5FFF-CA06-48E5-9A32-FDA961C5F884}
	EndGlobalSection
EndGlobal