RiskYourLife/Client
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Restructure repository to include all source folders

Browse Source 
Move git root from Client/ to src/ to track all source code:
- Client: Game client source (moved to Client/Client/)
- Server: Game server source
- GameTools: Development tools
- CryptoSource: Encryption utilities
- database: Database scripts
- Script: Game scripts
- rylCoder_16.02.2008_src: Legacy coder tools
- GMFont, Game: Additional resources

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
tindevil
2025-11-29 20:17:20 +09:00
parent 5d3cd64a25
commit dd97ddec92
11602 changed files with 1446576 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
CryptoSource/ScriptEngine-MCF File/BaseDef.h Normal file
View File

@@ -0,0 +1,78 @@
#ifndef _BaseDef_H_
#define _BaseDef_H_
#define MACHINECODEFILEEXT ".mcf" //Machine Code File
#define INTCODEFILEEXT ".imc" //InterMediate Code
#define SCRIPTFILEEXT ".dat" //Gama Script File
///////////////////////////////////////////////////////////////////////////////////
//
typedef void * ANY_FUNCTION;
enum eDataType
{
T_VOID = 0,
T_BOOL,
T_INT,
T_FLOAT,
T_STRING = 4
};
typedef int BOOL;
#define TRUE 1
#define FALSE 0
///////////////////////////////////////////////////////////////////////////////////
//
struct ScriptFunc
{
void * pFunc;
long Type;
ScriptFunc( void *, long );
};
typedef ScriptFunc SE_FUNC;
///////////////////////////////////////////////////////////////////////////////////
//
union AnyData
{
int intValue;
float floatValue;
const char* stringValue;
AnyData( int n )
: intValue( n )
{}
AnyData( float f )
: floatValue( f )
{}
AnyData( const char * pszStr )
: stringValue( pszStr )
{}
AnyData( void * p )
: stringValue( (const char *)p )
{
}
AnyData & operator=( int n )
{
intValue = n;
return *this;
}
};
///////////////////////////////////////////////////////////////////////////////////
#endif

44
CryptoSource/ScriptEngine-MCF File/Compiler/Compiler.cpp Normal file
View File

@@ -0,0 +1,44 @@
// Compiler.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <iostream>
#include "../ScriptEngine.h"
using namespace std;
void ScriptMessage( const char * msg )
{
cout << "##" << msg << "##\n";
}
int main(int argc, char* argv[])
{
if( argv[1] != NULL )
{
_SE_SetMessageFunction( ScriptMessage );
SCRIPT Script;
Script = _SE_Create( argv[1] );
char szOutFile[1024];
strcpy( szOutFile, argv[1] );
char * p = strstr( szOutFile, ".gsf" );
if( p )
{
strcpy( p, ".mcf" );
_SE_Save( Script, szOutFile );
_SE_Destroy( Script );
cout << "**Congratulation**\n";
return 0;
}
_SE_Destroy( Script );
}
cout << "usage : ScriptTest [gsf filename]" << endl;
return 0;
}

113
CryptoSource/ScriptEngine-MCF File/Compiler/Compiler.dsp Normal file
View File

@@ -0,0 +1,113 @@
# Microsoft Developer Studio Project File - Name="Compiler" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=Compiler - 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 "Compiler.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 "Compiler.mak" CFG="Compiler - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "Compiler - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "Compiler - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""$/ScriptEngine/Compiler", QSEAAAAA"
# PROP Scc_LocalPath "."
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "Compiler - 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 "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /c
# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /c
# ADD BASE RSC /l 0x412 /d "NDEBUG"
# ADD RSC /l 0x412 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "Compiler - 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 "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /GZ /c
# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /GZ /c
# ADD BASE RSC /l 0x412 /d "_DEBUG"
# ADD RSC /l 0x412 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "Compiler - Win32 Release"
# Name "Compiler - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=.\Compiler.cpp
# End Source File
# Begin Source File
SOURCE=.\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=.\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"
# End Group
# Begin Source File
SOURCE=.\ReadMe.txt
# End Source File
# End Target
# End Project

8
CryptoSource/ScriptEngine-MCF File/Compiler/StdAfx.cpp Normal file
View File

@@ -0,0 +1,8 @@
// stdafx.cpp : source file that includes just the standard includes
// Compiler.pch will be the pre-compiled header
// stdafx.obj will contain the pre-compiled type information
#include "stdafx.h"
// TODO: reference any additional headers you need in STDAFX.H
// and not in this file

19
CryptoSource/ScriptEngine-MCF File/Compiler/StdAfx.h Normal file
View File

@@ -0,0 +1,19 @@
// 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__2CA46FAE_AF8D_405D_89AC_76B42401F8C7__INCLUDED_)
#define AFX_STDAFX_H__2CA46FAE_AF8D_405D_89AC_76B42401F8C7__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// TODO: reference additional headers your program requires here
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_STDAFX_H__2CA46FAE_AF8D_405D_89AC_76B42401F8C7__INCLUDED_)

68
CryptoSource/ScriptEngine-MCF File/CompilerMCF/CompilerMFC.cpp Normal file
View File

@@ -0,0 +1,68 @@
// CompilerMFC.cpp : Defines the class behaviors for the application.
//
#include "stdafx.h"
#include "CompilerMFC.h"
#include "CompilerMFCDlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CCompilerMFCApp
BEGIN_MESSAGE_MAP(CCompilerMFCApp, CWinApp)
//{{AFX_MSG_MAP(CCompilerMFCApp)
// NOTE - the ClassWizard will add and remove mapping macros here.
// DO NOT EDIT what you see in these blocks of generated code!
//}}AFX_MSG
ON_COMMAND(ID_HELP, CWinApp::OnHelp)
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CCompilerMFCApp construction
CCompilerMFCApp::CCompilerMFCApp()
{
// TODO: add construction code here,
// Place all significant initialization in InitInstance
}
/////////////////////////////////////////////////////////////////////////////
// The one and only CCompilerMFCApp object
CCompilerMFCApp theApp;
/////////////////////////////////////////////////////////////////////////////
// CCompilerMFCApp initialization
BOOL CCompilerMFCApp::InitInstance()
{
AfxEnableControlContainer();
// Standard initialization
// If you are not using these features and wish to reduce the size
// of your final executable, you should remove from the following
// the specific initialization routines you do not need.
CCompilerMFCDlg dlg;
m_pMainWnd = &dlg;
int nResponse = dlg.DoModal();
if (nResponse == IDOK)
{
// TODO: Place code here to handle when the dialog is
// dismissed with OK
}
else if (nResponse == IDCANCEL)
{
// TODO: Place code here to handle when the dialog is
// dismissed with Cancel
}
// Since the dialog has been closed, return FALSE so that we exit the
// application, rather than start the application's message pump.
return FALSE;
}

49
CryptoSource/ScriptEngine-MCF File/CompilerMCF/CompilerMFC.h Normal file
View File

@@ -0,0 +1,49 @@
// CompilerMFC.h : main header file for the COMPILERMFC application
//
#if !defined(AFX_COMPILERMFC_H__F873C597_051F_4752_8D3D_6716757FB259__INCLUDED_)
#define AFX_COMPILERMFC_H__F873C597_051F_4752_8D3D_6716757FB259__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
/////////////////////////////////////////////////////////////////////////////
// CCompilerMFCApp:
// See CompilerMFC.cpp for the implementation of this class
//
class CCompilerMFCApp : public CWinApp
{
public:
CCompilerMFCApp();
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CCompilerMFCApp)
public:
virtual BOOL InitInstance();
//}}AFX_VIRTUAL
// Implementation
//{{AFX_MSG(CCompilerMFCApp)
// 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_COMPILERMFC_H__F873C597_051F_4752_8D3D_6716757FB259__INCLUDED_)

175
CryptoSource/ScriptEngine-MCF File/CompilerMCF/CompilerMFC.rc Normal file
View File

@@ -0,0 +1,175 @@
// 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
/////////////////////////////////////////////////////////////////////////////
// <20>ѱ<EFBFBD><D1B1><EFBFBD> resources
#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_KOR)
#ifdef _WIN32
LANGUAGE LANG_KOREAN, SUBLANG_DEFAULT
#pragma code_page(949)
#endif //_WIN32
#ifdef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// TEXTINCLUDE
//
1 TEXTINCLUDE
BEGIN
"resource.h\0"
END
2 TEXTINCLUDE
BEGIN
"#include ""afxres.h""\r\n"
"\0"
END
3 TEXTINCLUDE
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_KOR)\r\n"
"#ifdef _WIN32\r\n"
"LANGUAGE 18, 1\r\n"
"#pragma code_page(949)\r\n"
"#endif //_WIN32\r\n"
"#include ""res\\CompilerMFC.rc2"" // non-Microsoft Visual C++ edited resources\r\n"
"#include ""l.kor\\afxres.rc"" // Standard components\r\n"
"#endif\r\n"
"\0"
END
#endif // APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Icon
//
// Icon with lowest ID value placed first to ensure application icon
// remains consistent on all systems.
IDR_MAINFRAME ICON "res\\CompilerMFC.ico"
/////////////////////////////////////////////////////////////////////////////
//
// Dialog
//
IDD_COMPILERMFC_DIALOG DIALOGEX 0, 0, 291, 93
STYLE DS_SETFONT | DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION |
WS_SYSMENU
EXSTYLE WS_EX_APPWINDOW
CAPTION "CompilerMFC"
FONT 9, "<22><><EFBFBD><EFBFBD>", 0, 0, 0x1
BEGIN
DEFPUSHBUTTON "Start Compile!!",IDOK,7,72,277,14
EDITTEXT IDC_EDIT_INPUT,7,21,221,14,ES_AUTOHSCROLL
PUSHBUTTON "Browse...",IDC_BUTTON_BROWSE1,234,21,50,14
EDITTEXT IDC_EDIT_OUTPUT,7,51,221,14,ES_AUTOHSCROLL
PUSHBUTTON "Browse...",IDC_BUTTON_BROWSE2,234,51,50,14
LTEXT "dat File (Input)",IDC_STATIC,7,7,48,8
LTEXT "mcf File (Output)",IDC_STATIC,7,39,55,8
END
/////////////////////////////////////////////////////////////////////////////
//
// 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 0x1L
FILESUBTYPE 0x0L
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "041204B0"
BEGIN
VALUE "FileDescription", "CompilerMFC MFC <20><><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1>"
VALUE "FileVersion", "1, 0, 0, 1"
VALUE "InternalName", "CompilerMFC"
VALUE "LegalCopyright", "Copyright (C) 2003"
VALUE "OriginalFilename", "CompilerMFC.EXE"
VALUE "ProductName", "CompilerMFC <20><><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1>"
VALUE "ProductVersion", "1, 0, 0, 1"
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x412, 1200
END
END
/////////////////////////////////////////////////////////////////////////////
//
// DESIGNINFO
//
#ifdef APSTUDIO_INVOKED
GUIDELINES DESIGNINFO
BEGIN
IDD_COMPILERMFC_DIALOG, DIALOG
BEGIN
LEFTMARGIN, 7
RIGHTMARGIN, 284
TOPMARGIN, 7
BOTTOMMARGIN, 86
END
END
#endif // APSTUDIO_INVOKED
#endif // <20>ѱ<EFBFBD><D1B1><EFBFBD> resources
/////////////////////////////////////////////////////////////////////////////
#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_KOR)
#ifdef _WIN32
LANGUAGE 18, 1
#pragma code_page(949)
#endif //_WIN32
#include "res\CompilerMFC.rc2" // non-Microsoft Visual C++ edited resources
#include "l.kor\afxres.rc" // Standard components
#endif
/////////////////////////////////////////////////////////////////////////////
#endif // not APSTUDIO_INVOKED

241
CryptoSource/ScriptEngine-MCF File/CompilerMCF/CompilerMFC.vcproj Normal file
View File

@@ -0,0 +1,241 @@
<?xml version="1.0" encoding="ks_c_5601-1987"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.10"
Name="CompilerMFC"
ProjectGUID="{CB57D293-D687-4895-AB60-60488B64F293}"
SccProjectName=""
SccLocalPath=""
Keyword="MFCProj">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Release|Win32"
OutputDirectory="Release"
IntermediateDirectory="Release"
ConfigurationType="1"
UseOfMFC="1"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="./;../;../../Client"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS"
StringPooling="TRUE"
RuntimeLibrary="0"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="3"
PrecompiledHeaderThrough="stdafx.h"
PrecompiledHeaderFile=".\Release/CompilerMFC.pch"
AssemblerListingLocation=""
ObjectFile="$(IntDir)/"
ProgramDataBaseFileName="$(IntDir)/vc70.pdb"
WarningLevel="3"
SuppressStartupBanner="TRUE"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
OutputFile="$(OutDir)/$(ProjectName).exe"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
ProgramDatabaseFile=".\Release/Compiler.pdb"
SubSystem="2"
StackReserveSize="2097152"
TargetMachine="1"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\Release/CompilerMFC.tlb"
HeaderFileName=""/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1042"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="Debug|Win32"
OutputDirectory="Debug"
IntermediateDirectory="Debug"
ConfigurationType="1"
UseOfMFC="1"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="./;../;../../Client"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="3"
PrecompiledHeaderThrough="stdafx.h"
PrecompiledHeaderFile=".\Debug/CompilerMFC.pch"
AssemblerListingLocation=""
ObjectFile="$(IntDir)/"
ProgramDataBaseFileName="$(IntDir)/vc70.pdb"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
OutputFile="$(OutDir)/$(ProjectName).exe"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
GenerateDebugInformation="TRUE"
ProgramDatabaseFile=".\Debug/CompilerMFC.pdb"
SubSystem="2"
StackReserveSize="2097152"
TargetMachine="1"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="_DEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\Debug/CompilerMFC.tlb"
HeaderFileName=""/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1042"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
<File
RelativePath="CompilerMFC.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
PreprocessorDefinitions=""/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions=""
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="CompilerMFC.rc">
</File>
<File
RelativePath="CompilerMFCDlg.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
PreprocessorDefinitions=""/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions=""
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="StdAfx.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
PreprocessorDefinitions=""
UsePrecompiledHeader="1"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions=""
BasicRuntimeChecks="3"
UsePrecompiledHeader="1"/>
</FileConfiguration>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl">
<File
RelativePath="CompilerMFC.h">
</File>
<File
RelativePath="CompilerMFCDlg.h">
</File>
<File
RelativePath="Resource.h">
</File>
<File
RelativePath="StdAfx.h">
</File>
</Filter>
<Filter
Name="Resource Files"
Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe">
<File
RelativePath="res\CompilerMFC.ico">
</File>
<File
RelativePath="res\CompilerMFC.rc2">
</File>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

176
CryptoSource/ScriptEngine-MCF File/CompilerMCF/CompilerMFCDlg.cpp Normal file
View File

@@ -0,0 +1,176 @@
// CompilerMFCDlg.cpp : implementation file
//
#include "stdafx.h"
#include <ScriptEngine/ScriptEngine.h>
#include "CompilerMFC.h"
#include "CompilerMFCDlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CCompilerMFCDlg dialog
CCompilerMFCDlg::CCompilerMFCDlg(CWnd* pParent /*=NULL*/)
: CDialog(CCompilerMFCDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CCompilerMFCDlg)
//}}AFX_DATA_INIT
// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}
void CCompilerMFCDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CCompilerMFCDlg)
DDX_Control(pDX, IDC_EDIT_OUTPUT, m_editOutputFile);
DDX_Control(pDX, IDC_EDIT_INPUT, m_editInputFile);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CCompilerMFCDlg, CDialog)
//{{AFX_MSG_MAP(CCompilerMFCDlg)
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
ON_BN_CLICKED(IDC_BUTTON_BROWSE1, OnButtonBrowse1)
ON_BN_CLICKED(IDC_BUTTON_BROWSE2, OnButtonBrowse2)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CCompilerMFCDlg message handlers
BOOL CCompilerMFCDlg::OnInitDialog()
{
CDialog::OnInitDialog();
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
// TODO: Add extra initialization here
return TRUE; // return TRUE unless you set the focus to a control
}
// If you add a minimize button to your dialog, you will need the code below
// to draw the icon. For MFC applications using the document/view model,
// this is automatically done for you by the framework.
void CCompilerMFCDlg::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // device context for painting
SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// Draw the icon
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialog::OnPaint();
}
}
// The system calls this to obtain the cursor to display while the user drags
// the minimized window.
HCURSOR CCompilerMFCDlg::OnQueryDragIcon()
{
return (HCURSOR) m_hIcon;
}
void CCompilerMFCDlg::OnButtonBrowse1()
{
static char szFilter[] = "Gama Script File(*.dat)|*.dat|All Files(*.*)|*.*||";
CFileDialog fileDlg( TRUE, "dat", NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, szFilter, this );
char szCurPath[1024];
GetCurrentDirectory( 1024, szCurPath );
fileDlg.m_ofn.lpstrInitialDir = szCurPath;
if( fileDlg.DoModal() == IDOK )
{
CString inputFile = fileDlg.GetPathName();
m_editInputFile.SetWindowText( inputFile );
CString outputFile = inputFile;
outputFile.MakeLower();
outputFile.Replace( "dat", "mcf" );
m_editOutputFile.SetWindowText( outputFile );
}
}
void CCompilerMFCDlg::OnButtonBrowse2()
{
static char szFilter[] = "Machine Code File(*.mcf)|*.mcf|All Files(*.*)|*.*||";
CFileDialog fileDlg( FALSE, "mcf", NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, szFilter, this );
char szCurPath[1024];
GetCurrentDirectory( 1024, szCurPath );
fileDlg.m_ofn.lpstrInitialDir = szCurPath;
if( fileDlg.DoModal() == IDOK )
{
m_editOutputFile.SetWindowText( fileDlg.GetPathName() );
}
}
void ScriptMessage( const char * msg )
{
MessageBox( NULL, msg, "Error!!", MB_OK );
}
void CCompilerMFCDlg::OnOK()
{
CString inputFile, outputFile;
m_editInputFile.GetWindowText( inputFile );
m_editOutputFile.GetWindowText( outputFile );
if( inputFile == "" )
{
MessageBox( "Input dat File Name." );
return;
}
if( outputFile == "" )
{
MessageBox( "Input mcf File Name." );
return;
}
_SE_SetMessageFunction( ScriptMessage );
SCRIPT Script;
Script = _SE_Create( inputFile );
if (false == _SE_Save( Script, outputFile ))
{
MessageBox("<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>忡 <20><><EFBFBD><EFBFBD><EFBFBD>Ͽ<EFBFBD><CFBF><EFBFBD><EFBFBD>ϴ<EFBFBD>. <20>ش<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̹<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20>ֽ<EFBFBD><D6BD>ϴ<EFBFBD>.");
return;
}
_SE_Destroy( Script );
MessageBox( "Done!!" );
}

52
CryptoSource/ScriptEngine-MCF File/CompilerMCF/CompilerMFCDlg.h Normal file
View File

@@ -0,0 +1,52 @@
// CompilerMFCDlg.h : header file
//
#if !defined(AFX_COMPILERMFCDLG_H__D80E07C5_9CE0_4EC7_BD39_A658DE84A4ED__INCLUDED_)
#define AFX_COMPILERMFCDLG_H__D80E07C5_9CE0_4EC7_BD39_A658DE84A4ED__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
/////////////////////////////////////////////////////////////////////////////
// CCompilerMFCDlg dialog
class CCompilerMFCDlg : public CDialog
{
// Construction
public:
CCompilerMFCDlg(CWnd* pParent = NULL); // standard constructor
// Dialog Data
//{{AFX_DATA(CCompilerMFCDlg)
enum { IDD = IDD_COMPILERMFC_DIALOG };
CEdit m_editOutputFile;
CEdit m_editInputFile;
//}}AFX_DATA
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CCompilerMFCDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
HICON m_hIcon;
// Generated message map functions
//{{AFX_MSG(CCompilerMFCDlg)
virtual BOOL OnInitDialog();
afx_msg void OnPaint();
afx_msg HCURSOR OnQueryDragIcon();
afx_msg void OnButtonBrowse1();
afx_msg void OnButtonBrowse2();
virtual void OnOK();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_COMPILERMFCDLG_H__D80E07C5_9CE0_4EC7_BD39_A658DE84A4ED__INCLUDED_)

8
CryptoSource/ScriptEngine-MCF File/CompilerMCF/StdAfx.cpp Normal file
View File

@@ -0,0 +1,8 @@
// stdafx.cpp : source file that includes just the standard includes
// CompilerMFC.pch will be the pre-compiled header
// stdafx.obj will contain the pre-compiled type information
#include "stdafx.h"

27
CryptoSource/ScriptEngine-MCF File/CompilerMCF/StdAfx.h Normal file
View File

@@ -0,0 +1,27 @@
// 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__7706ED3B_FEC1_43B3_A7F8_D92FF250AAC9__INCLUDED_)
#define AFX_STDAFX_H__7706ED3B_FEC1_43B3_A7F8_D92FF250AAC9__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers
#include <afxwin.h> // MFC core and standard components
#include <afxext.h> // MFC extensions
#include <afxdisp.h> // MFC Automation classes
#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__7706ED3B_FEC1_43B3_A7F8_D92FF250AAC9__INCLUDED_)

BIN
CryptoSource/ScriptEngine-MCF File/CompilerMCF/res/CompilerMFC.ico Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.1 KiB

13
CryptoSource/ScriptEngine-MCF File/CompilerMCF/res/CompilerMFC.rc2 Normal file
View File

@@ -0,0 +1,13 @@
//
// COMPILERMFC.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...
/////////////////////////////////////////////////////////////////////////////

22
CryptoSource/ScriptEngine-MCF File/CompilerMCF/resource.h Normal file
View File

@@ -0,0 +1,22 @@
//{{NO_DEPENDENCIES}}
// Microsoft Developer Studio generated include file.
// Used by CompilerMFC.rc
//
#define IDD_COMPILERMFC_DIALOG 102
#define IDR_MAINFRAME 128
#define IDC_EDIT_INPUT 1000
#define IDC_BUTTON_BROWSE1 1001
#define IDC_EDIT_OUTPUT 1002
#define IDC_BUTTON_BROWSE2 1003
#define IDC_EDIT_MSG 1004
// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 129
#define _APS_NEXT_COMMAND_VALUE 32771
#define _APS_NEXT_CONTROL_VALUE 1005
#define _APS_NEXT_SYMED_VALUE 101
#endif
#endif

1213
CryptoSource/ScriptEngine-MCF File/IMCodeGen.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

14
CryptoSource/ScriptEngine-MCF File/IMCodeGen.h Normal file
View File

@@ -0,0 +1,14 @@
#ifndef _IMCodeGen_H_
#define _IMCodeGen_H_
#include "STL.h"
class CSyntaxTree;
class IOPCode;
typedef list<IOPCode*> IMCODES;
typedef map<int, IMCODES*> FUNCTIONS;
void GenerateCode( CSyntaxTree &, IMCODES &, FUNCTIONS & );
#endif

1664
CryptoSource/ScriptEngine-MCF File/IMCodeUnits.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

641
CryptoSource/ScriptEngine-MCF File/IMCodeUnits.h Normal file
View File

@@ -0,0 +1,641 @@
#ifndef _IMCodeUnits_H_
#define _IMCodeUnits_H_
#include "BaseDef.h"
#include "Message.h"
#include "STL.h"
class CSymbolTable;
class CRelocTable;
typedef map<int, long> FUNCTABLE;
///////////////////////////////////////////////////////////////////////////////////
//
void SetSymbolTable( CSymbolTable * );
void SetFuncTable( FUNCTABLE * );
void SetRelocTable( CRelocTable * );
///////////////////////////////////////////////////////////////////////////////////
//
typedef unsigned char byte;
enum eRegister
{
EAX = 0,
ECX,
EDX,
EBX,
ESP,
EBP,
ESI,
EDI = 7,
NONE = 8
};
enum eCondition
{
G = 0, //Greater
GE, //Greater or Equal
L, //Less
LE, //Less or Equal
E, //Equal
NE = 5 //Not Equal
};
typedef struct _VAR_* VAR;
typedef struct _CONST_* CONST;
typedef struct _FUNC_* FUNC;
///////////////////////////////////////////////////////////////////////////////////
//
class IOPCode
{
public:
long m_lAddress;
public:
virtual ~IOPCode() {} //ToMachineCode ȣ<><C8A3> <20><><EFBFBD><EFBFBD> Addressing<6E><67> <20>ݵ<EFBFBD><DDB5><EFBFBD> <20>Ǿ<EFBFBD> <20>־<EFBFBD><D6BE><EFBFBD> <20>Ѵ<EFBFBD>.
virtual int ToMachineCode( byte * ) = 0; //<2F>Ѱܹ<D1B0><DCB9><EFBFBD> <20>ּҿ<D6BC> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ڵ带 <20><><EFBFBD><EFBFBD> index<65><78> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ų<EFBFBD><C5B2>.
virtual long Addressing( long ) = 0; //<2F><><EFBFBD><EFBFBD> <20>ּҸ<D6BC> <20>ް<EFBFBD>, <20><><EFBFBD><EFBFBD> instruction<6F><6E> <20>ּҸ<D6BC> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
virtual void Show( MESSAGE_FUNCTION2 ) = 0;
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_call : public IOPCode
{
FUNC m_funcID;
int m_iLine;
public:
COP_call( FUNC, int line );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_mov : public IOPCode
{
byte m_Type;
FUNC m_funcID;
union
{
VAR m_leftVarID;
eRegister m_leftReg;
};
union
{
int m_midArrayIndex;
eRegister m_midIndexReg;
};
union
{
eRegister m_rightReg;
CONST m_rightConstID;
VAR m_rightVarID;
int m_rightValue;
float m_rightValuef;
};
public:
COP_mov( FUNC, VAR, eRegister reg );
COP_mov( eRegister reg, FUNC, VAR );
COP_mov( eRegister reg, CONST constID );
COP_mov( FUNC, VAR, float valuef );
COP_mov( eRegister lreg, eRegister rreg );
COP_mov( eRegister lreg, int value );
COP_mov( FUNC, VAR, int arrayIndex, eRegister rreg );
COP_mov( eRegister lreg, FUNC, VAR, eRegister indexReg );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_nop : public IOPCode
{
public:
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_add : public IOPCode
{
byte m_Type;
eRegister m_leftReg;
union
{
int m_iValue;
eRegister m_rightReg;
};
public:
COP_add( eRegister reg, int value );
COP_add( eRegister lreg, eRegister rreg );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_sub : public IOPCode
{
byte m_Type;
eRegister m_leftReg;
union
{
eRegister m_rightReg;
int m_iValue;
};
public:
COP_sub( eRegister reg, int value );
COP_sub( eRegister lreg, eRegister rreg );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_imul : public IOPCode
{
eRegister m_leftReg;
eRegister m_rightReg;
public:
COP_imul( eRegister lreg, eRegister rreg );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_idiv : public IOPCode
{
eRegister m_rightReg;
public:
COP_idiv( eRegister rreg );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_push : public IOPCode
{
eRegister m_Reg;
public:
COP_push( eRegister reg );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_pop : public IOPCode
{
eRegister m_Reg;
public:
COP_pop( eRegister reg );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_jmp : public IOPCode
{
public:
IOPCode * m_pJumpTarget;
public:
COP_jmp();
COP_jmp( IOPCode * pJmpTarget );
virtual ~COP_jmp();
virtual int ToMachineCode( byte * );
virtual long Addressing( long addr );
virtual void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_jcc : public COP_jmp
{
eCondition m_Condition;
public:
COP_jcc( eCondition condition );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_jmpmark : public IOPCode
{
public:
IOPCode * m_pJumpSrc;
public:
COP_jmpmark();
COP_jmpmark( COP_jmp * pOPjmp );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_cmp : public IOPCode
{
byte m_Type;
FUNC m_funcID;
union
{
VAR m_leftVarID;
eRegister m_leftReg;
};
union
{
byte m_rightValue;
CONST m_rightConstID;
eRegister m_rightReg;
};
public:
COP_cmp( FUNC, VAR lvarID, CONST rconstID );
COP_cmp( eRegister lreg, byte value );
COP_cmp( eRegister lreg, eRegister rreg );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_ret : public IOPCode
{
public:
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
class COP_xor : public IOPCode
{
eRegister m_leftReg;
eRegister m_rightReg;
public:
COP_xor( eRegister lreg, eRegister rreg );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_setcc : public IOPCode
{
eCondition m_Condition;
eRegister m_Reg;
public:
COP_setcc( eCondition condition, eRegister lreg );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_int3 : public IOPCode
{
public:
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_fld : public IOPCode
{
FUNC m_funcID;
VAR m_varID;
public:
COP_fld( FUNC, VAR );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_fadd : public IOPCode
{
FUNC m_funcID;
VAR m_varID;
public:
COP_fadd( FUNC, VAR );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_fsub : public IOPCode
{
FUNC m_funcID;
VAR m_varID;
public:
COP_fsub( FUNC, VAR );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_fmul : public IOPCode
{
FUNC m_funcID;
VAR m_varID;
public:
COP_fmul( FUNC, VAR );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_fdiv : public IOPCode
{
FUNC m_funcID;
VAR m_varID;
public:
COP_fdiv( FUNC, VAR );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_fstp : public IOPCode
{
FUNC m_funcID;
VAR m_varID;
bool m_bDouble;
public:
COP_fstp( FUNC, VAR, bool = false );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_fcomp : public IOPCode
{
FUNC m_funcID;
VAR m_varID;
public:
COP_fcomp( FUNC, VAR );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_fnstsw_ax : public IOPCode
{
public:
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_test_ah : public IOPCode
{
byte m_Value8;
public:
COP_test_ah( byte );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_itoa : public IOPCode
{
eRegister m_leftReg;
FUNC m_funcID;
VAR m_StringBuffer;
public:
COP_itoa( eRegister, VAR );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_ftoa : public IOPCode
{
eRegister m_freeReg;
VAR m_DoubleVar;
VAR m_StringBuffer;
public:
COP_ftoa( eRegister, VAR, VAR );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
//<2F>Ҵ<EFBFBD><D2B4><EFBFBD> <20>޸<EFBFBD><DEB8><EFBFBD><EFBFBD><EFBFBD> <20>ּҰ<D6BC> EAX<41><58> <20><><EFBFBD><EFBFBD><EEB0A3>.
class COP_malloc : public IOPCode
{
eRegister m_Reg;
public:
COP_malloc( eRegister );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_free : public IOPCode
{
FUNC m_funcID;
VAR m_varID;
public:
COP_free( FUNC, VAR );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
class COP_strcpy : public IOPCode
{
int m_type;
eRegister m_leftReg;
FUNC m_funcID;
union
{
eRegister m_rightReg;
VAR m_varID;
};
public:
COP_strcpy( eRegister, eRegister );
COP_strcpy( eRegister, FUNC, VAR );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
//ptr[leftReg]<5D><> ptr[rightReg]<5D><> <20><><EFBFBD>ڿ<EFBFBD><DABF><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ؼ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> eax<61><78> <20>ִ´<D6B4>.
class COP_strcmp : public IOPCode
{
eRegister m_leftReg;
eRegister m_rightReg;
public:
COP_strcmp( eRegister lreg, eRegister rreg );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
//
//ptr [rightReg] <20><> <20>ִ<EFBFBD> <20><><EFBFBD>ڿ<EFBFBD><DABF><EFBFBD> <20><><EFBFBD≯<EFBFBD> <20><><EFBFBD><EFBFBD> leftReg<65><67> <20>ִ´<D6B4>.
class COP_strlen : public IOPCode
{
int m_type;
FUNC m_funcID;
union
{
eRegister m_Reg;
VAR m_varID;
};
public:
COP_strlen( eRegister reg );
COP_strlen( FUNC, VAR );
int ToMachineCode( byte * );
long Addressing( long addr );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
#endif

161
CryptoSource/ScriptEngine-MCF File/IntermediateCode.cpp Normal file
View File

@@ -0,0 +1,161 @@
#include "IntermediateCode.h"
#include "IMCodeGen.h"
#include "IMCodeUnits.h"
#include "SymbolTable.h"
#include <list>
#include <map>
#include "RelocTable.h"
#include <stdlib.h>
#include <string>
#include "GMMemory.h"
///////////////////////////////////////////////////////////////////////////////////
//
CIntermediateCode::CIntermediateCode()
: m_pCodes( new IMCODES )
, m_pFunctions( new FUNCTIONS )
, m_pFuncTable( new FUNCTABLE )
{
}
CIntermediateCode::~CIntermediateCode()
{
Destroy();
delete m_pCodes;
delete m_pFunctions;
delete m_pFuncTable;
}
void CIntermediateCode::Create( CSyntaxTree & rSyntaxTree )
{
GenerateCode( rSyntaxTree, *m_pCodes, *m_pFunctions );
}
void CIntermediateCode::DestroyIMCodes( IMCODES * pIMCodes )
{
for( IMCODES::iterator i = pIMCodes->begin(); i != pIMCodes->end(); i++ )
{
delete *i;
}
pIMCodes->clear();
}
void CIntermediateCode::Destroy()
{
for( FUNCTIONS::iterator i = m_pFunctions->begin(); i != m_pFunctions->end(); i++ )
{
DestroyIMCodes( i->second );
delete i->second;
}
m_pFunctions->clear();
DestroyIMCodes( m_pCodes );
}
void CIntermediateCode::Show( MESSAGE_FUNCTION2 Print, CSymbolTable * pSymbolTable )
{
const char * DataTypeString[] = { "void", "bool", "int", "float", "string" };
SetSymbolTable( pSymbolTable );
Print( "<<< void Main() >>>\n" );
for( IMCODES::iterator i = m_pCodes->begin(); i != m_pCodes->end(); i++ )
{
IOPCode * pCode = (*i);
Print( "%X :\t", pCode->m_lAddress );
pCode->Show( Print );
}
for( FUNCTIONS::iterator j = m_pFunctions->begin(); j != m_pFunctions->end(); j++ )
{
SFuncType type = pSymbolTable->GetTypeOfFunc( j->first );
Print( "<<< %s %s(", DataTypeString[type.GetReturnType()], pSymbolTable->GetNameOfFunc( j->first ) );
if( type.GetArgType( 0 ) != T_VOID )
{
Print( " " );
Print( DataTypeString[ type.GetArgType( 0 ) ] );
for( int ith = 1; ith < 8; ith++ )
{
eDataType dataType = type.GetArgType( ith );
if( dataType == T_VOID )
break;
Print( ", %s", DataTypeString[dataType] );
}
Print( " " );
}
Print( ") >>>\n" );
IMCODES * pFuncCode = j->second;
for( i = pFuncCode->begin(); i != pFuncCode->end(); i++ )
{
Print( "%X :\t", (*i)->m_lAddress );
(*i)->Show( Print );
}
}
}
long CIntermediateCode::Addressing( long addr )
{
for( IMCODES::iterator i = m_pCodes->begin(); i != m_pCodes->end(); i++ )
{
addr = (*i)->Addressing( addr );
}
for( FUNCTIONS::iterator j = m_pFunctions->begin(); j != m_pFunctions->end(); j++ )
{
IMCODES * pFuncCode = j->second;
for( i = pFuncCode->begin(); i != pFuncCode->end(); i++ )
{
addr = (*i)->Addressing( addr );
}
}
return addr;
}
int CIntermediateCode::ToMachineCode( void * pBuf, CRelocTable * pRelocTable )
{
Addressing( 0 );
for( FUNCTIONS::iterator k = m_pFunctions->begin(); k != m_pFunctions->end(); k++ )
{
int funcID = k->first;
int offset = k->second->front()->m_lAddress;
m_pFuncTable->insert( FUNCTABLE::value_type( funcID, offset ) );
}
SetFuncTable( m_pFuncTable );
SetRelocTable( pRelocTable );
byte * pBuffer = (byte*)pBuf;
int TotalSize = 0;
IMCODES::iterator i = m_pCodes->begin();
for( ; i != m_pCodes->end(); i++ )
{
int size = (*i)->ToMachineCode( pBuffer );
pBuffer += size;
TotalSize += size;
}
for( FUNCTIONS::iterator j = m_pFunctions->begin(); j != m_pFunctions->end(); j++ )
{
IMCODES * pFuncCode = j->second;
for( i = pFuncCode->begin(); i != pFuncCode->end(); i++ )
{
int size = (*i)->ToMachineCode( pBuffer );
pBuffer += size;
TotalSize += size;
}
}
return TotalSize;
}
///////////////////////////////////////////////////////////////////////////////////
//

51
CryptoSource/ScriptEngine-MCF File/IntermediateCode.h Normal file
View File

@@ -0,0 +1,51 @@
#ifndef _IntermediateCode_H_
#define _IntermediateCode_H_
#include "STL.h"
#include "BaseDef.h"
#include "Message.h"
///////////////////////////////////////////////////////////////////////////////////
//
class IOPCode;
class CSyntaxTree;
class CSymbolTable;
class CRelocTable;
class CIntermediateCode
{
public:
typedef list<IOPCode*> IMCODES;
typedef map<int, IMCODES*> FUNCTIONS;
typedef map<int, long> FUNCTABLE;
protected:
IMCODES * m_pCodes;
FUNCTIONS * m_pFunctions;
FUNCTABLE * m_pFuncTable;
protected:
void DestroyIMCodes( IMCODES * );
public:
CIntermediateCode();
~CIntermediateCode();
void Create( CSyntaxTree & );
void Destroy();
void Show( MESSAGE_FUNCTION2, CSymbolTable * pSymbolTable );
long Addressing( long addr ); //past end<6E><64> addr<64><72> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
int ToMachineCode( void *, CRelocTable * );
FUNCTABLE & GetFuncTable() { return *m_pFuncTable; }
};
///////////////////////////////////////////////////////////////////////////////////
//
#endif

111
CryptoSource/ScriptEngine-MCF File/Message.cpp Normal file
View File

@@ -0,0 +1,111 @@
#include "Message.h"
#include <iostream>
#include <stdarg.h>
#include "GMMemory.h"
using namespace std;
void DefaultMessageFunction( const char * ErrMsg )
{
cout << ErrMsg << endl;
}
MESSAGE_FUNCTION g_pfuncCompilerMessage = DefaultMessageFunction;
void CompilerMessage( const char * szStr )
{
(*g_pfuncCompilerMessage)( szStr );
}
void CompilerMessage2( const char * szStr, ... )
{
va_list args;
va_start( args, szStr );
char szBuffer[4096];
vsprintf( szBuffer, szStr, args );
CompilerMessage( szBuffer );
}
void SetCompilerMessageFunction( MESSAGE_FUNCTION func )
{
g_pfuncCompilerMessage = func;
}
void ErrorMessage( int line, const char * Msg )
{
CompilerMessage2( "Error (line %d) : %s", line, Msg );
exit(0);
}
void ErrorMessage( const char * Msg )
{
CompilerMessage2( "Error : %s", Msg );
exit(0);
}
void ErrorMessage2( int line, const char * Msg, ... )
{
va_list args;
va_start( args, Msg );
char szBuffer[4096];
vsprintf( szBuffer, Msg, args );
CompilerMessage2( "Error (line %d) : %s", line, szBuffer );
exit(0);
}
void ErrorMessage2( const char * Msg, ... )
{
va_list args;
va_start( args, Msg );
char szBuffer[4096];
vsprintf( szBuffer, Msg, args );
CompilerMessage2( "Error : %s", szBuffer );
exit(0);
}
void WarningMessage( int line, const char * Msg )
{
CompilerMessage2( "Warning (line %d) : %s", line, Msg );
}
void WarningMessage( const char * Msg )
{
CompilerMessage2( "Warning : %s", Msg );
}
void WarningMessage2( const char * Msg, ... )
{
va_list args;
va_start( args, Msg );
char szBuffer[4096];
vsprintf( szBuffer, Msg, args );
CompilerMessage2( "Warning : %s", szBuffer );
}
void WarningMessage2( int line, const char * Msg, ... )
{
va_list args;
va_start( args, Msg );
char szBuffer[4096];
vsprintf( szBuffer, Msg, args );
CompilerMessage2( "Warning (line %d) : %s", line, szBuffer );
}
void ScriptSystemError( const char * Msg )
{
CompilerMessage2( "Script System Error : %s", Msg );
}

27
CryptoSource/ScriptEngine-MCF File/Message.h Normal file
View File

@@ -0,0 +1,27 @@
#ifndef _Message_H_
#define _Message_H_
///////////////////////////////////////////////////////////////////////////////////
//
typedef void (*MESSAGE_FUNCTION)( const char * ErrMsg );
typedef void (*MESSAGE_FUNCTION2)( const char *, ... );
void CompilerMessage( const char * );
void CompilerMessage2( const char *, ... );
void SetCompilerMessageFunction( MESSAGE_FUNCTION );
void ErrorMessage( int line, const char * );
void ErrorMessage( const char * );
void ErrorMessage2( int line, const char *, ... );
void ErrorMessage2( const char *, ... );
void WarningMessage( int line, const char * );
void WarningMessage( const char * );
void WarningMessage2( int line, const char *, ... );
void WarningMessage2( const char *, ... );
void ScriptSystemError( const char * );
///////////////////////////////////////////////////////////////////////////////////
//
#endif

21
CryptoSource/ScriptEngine-MCF File/Parse.bat Normal file
View File

@@ -0,0 +1,21 @@
flex -olex.cpp string.l
@echo off
rem *** Make sure Bison can find these files
rem move bison.simple . >nul
rem move bison.hairy . >nul
rem *** Run Bison to generate the parser
bison --defines --verbose -o parse.cpp string.y
rem *** Put the files back
rem move bison.simple .. >nul
rem move bison.hairy .. >nul
rem *** Rename parse.cpp.h to lexsymb.h
if exist lexsymb.h del lexsymb.h
ren parse.cpp.h lexsymb.h
pause
:End

21
CryptoSource/ScriptEngine-MCF File/ReadMe.txt Normal file
View File

@@ -0,0 +1,21 @@
========================================================================
<20><><EFBFBD><EFBFBD> <20><><EFBFBD>̺귯<CCBA><EAB7AF> : ScriptEngine <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>
========================================================================
<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> <20><><EFBFBD><EFBFBD><EFBFBD>翡<EFBFBD><E7BFA1> <20><> ScriptEngine <20><><EFBFBD>̺귯<CCBA><EAB7AF> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>.
<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ҽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʾҽ<CABE><D2BD>ϴ<EFBFBD>.
ScriptEngine.vcproj
<20><><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> <20><><EFBFBD><EFBFBD><EFBFBD>縦 <20><><EFBFBD><EFBFBD><EFBFBD>Ͽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> VC++ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20>⺻ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD>Դϴ<D4B4>.
<20>ش<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Visual C++<2B><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ͽ<EFBFBD>
<20><><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> <20><><EFBFBD><EFBFBD><EFBFBD>翡<EFBFBD><E7BFA1> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>÷<EFBFBD><C3B7><EFBFBD>, <20><><EFBFBD><EFBFBD> <20><>
<20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD>ɿ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ֽ<EFBFBD><D6BD>ϴ<EFBFBD>.
/////////////////////////////////////////////////////////////////////////////
<EFBFBD><EFBFBD>Ÿ <20><><EFBFBD><EFBFBD>:
<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> <20><><EFBFBD><EFBFBD><EFBFBD>翡<EFBFBD><E7BFA1> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> "TODO:" <20>ּ<EFBFBD><D6BC><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ڰ<EFBFBD> <20>߰<EFBFBD><DFB0>ϰų<CFB0> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD> <20>ϴ<EFBFBD>
<EFBFBD>ҽ<EFBFBD> <20>ڵ<EFBFBD> <20>κ<EFBFBD><CEBA><EFBFBD> <20><>Ÿ<EFBFBD><C5B8><EFBFBD>ϴ<EFBFBD>.
/////////////////////////////////////////////////////////////////////////////

197
CryptoSource/ScriptEngine-MCF File/RelocTable.cpp Normal file
View File

@@ -0,0 +1,197 @@
#include "RelocTable.h"
#include <vector>
#include <fstream>
#include <stdio.h>
#include <windows.h>
#include "VirtualMachine.h"
#include "GMMemory.h"
CRelocTable::CRelocTable()
: m_pGlobalVarTable( new RELOCTABLE )
, m_pStringTable( new RELOCTABLE )
, m_pFuncRelocTable( new FUNCRELOCTABLE )
{
}
CRelocTable::~CRelocTable()
{
delete m_pGlobalVarTable;
delete m_pStringTable;
delete m_pFuncRelocTable;
}
void CRelocTable::Create( ifstream & file )
{
Destroy();
int GlobalVarSize;
int StringBufferSize;
int FuncBufferSize;
file.read( (char*)&GlobalVarSize, sizeof(int) );
file.read( (char*)&StringBufferSize, sizeof(int) );
file.read( (char*)&FuncBufferSize, sizeof(int) );
int Temp;
for( int i = 0; i < GlobalVarSize; i++ )
{
file.read( (char*)&Temp, sizeof(int) );
m_pGlobalVarTable->push_back( Temp );
}
for( i = 0; i < StringBufferSize; i++ )
{
file.read( (char*)&Temp, sizeof(int) );
m_pStringTable->push_back( Temp );
}
for( i = 0; i < FuncBufferSize; i++ )
{
eStdFunc Func;
file.read( (char*)&Func, sizeof(Func) );
file.read( (char*)&Temp, sizeof(int) );
m_pFuncRelocTable->push_back( FUNCRELOC( Func, Temp ) );
}
}
#define READ_INT( p, var ) { var = *((int*)p); p += sizeof(int); }
#define READ_STDFUNCTYPE( p, var ) { var = *((eStdFunc*)p); p+= sizeof(eStdFunc); }
const void * CRelocTable::Create( const void * pDataBuf, unsigned dataSize )
{
Destroy();
const char * pBuf = (const char *)pDataBuf;
int GlobalVarSize, StringBufferSize, FuncBufferSize, temp;
READ_INT( pBuf, GlobalVarSize );
READ_INT( pBuf, StringBufferSize );
READ_INT( pBuf, FuncBufferSize );
for( int i = 0; i < GlobalVarSize; i++ )
{
READ_INT( pBuf, temp );
m_pGlobalVarTable->push_back( temp );
}
for( i = 0; i < StringBufferSize; i++ )
{
READ_INT( pBuf, temp );
m_pStringTable->push_back( temp );
}
for( i = 0; i < FuncBufferSize; i++ )
{
eStdFunc Func;
READ_STDFUNCTYPE( pBuf, Func );
READ_INT( pBuf, temp );
m_pFuncRelocTable->push_back( FUNCRELOC( Func, temp ) );
}
return pBuf;
}
void CRelocTable::Destroy()
{
m_pGlobalVarTable->clear();
m_pStringTable->clear();
}
void CRelocTable::Save( ofstream & file )
{
int GlobalVarSize = m_pGlobalVarTable->size();
int StringBufferSize = m_pStringTable->size();
int FuncBufferSize = m_pFuncRelocTable->size();
file.write( (const char*)&GlobalVarSize, sizeof(int) );
file.write( (const char*)&StringBufferSize, sizeof(int) );
file.write( (const char*)&FuncBufferSize, sizeof(int) );
for( int i = 0; i < GlobalVarSize; i++ )
{
int offset = m_pGlobalVarTable->at( i );
file.write( (const char*)&offset, sizeof(int) );
}
for( i = 0; i < StringBufferSize; i++ )
{
int offset = m_pStringTable->at( i );
file.write( (const char*)&offset, sizeof(int) );
}
for( i = 0; i < FuncBufferSize; i++ )
{
FUNCRELOC relocFunc = m_pFuncRelocTable->at( i );
file.write( (const char*)&relocFunc.first, sizeof(relocFunc.first) );
file.write( (const char*)&relocFunc.second, sizeof(relocFunc.second) );
}
}
void CRelocTable::AddGlobalVar( int offset )
{
m_pGlobalVarTable->push_back( offset );
}
void CRelocTable::AddConstString( int offset )
{
m_pStringTable->push_back( offset );
}
void CRelocTable::AddFuncBind( eStdFunc func, int offset )
{
m_pFuncRelocTable->push_back( FUNCRELOC( func, offset ) );
}
void CRelocTable::Relocate( void * pGlobalVarBuffer, void * pStringBuffer, void * pCodeBuffer )
{
void * ArrFuncPtr[] = { itoa, gcvt, malloc, free, strcpy, strcmp,
strlen, RegisterAllocatedMemory, UnregisterAllocatedMemory };
char * pCode = (char*)pCodeBuffer;
for( RELOCTABLE::iterator i = m_pGlobalVarTable->begin(); i != m_pGlobalVarTable->end(); i++ )
{
long * pValue = (long*)(pCode + *i);
*pValue += long(pGlobalVarBuffer);
}
for( RELOCTABLE::iterator j = m_pStringTable->begin(); j != m_pStringTable->end(); j++ )
{
long * pValue = (long*)(pCode + *j);
*pValue += long(pStringBuffer);
}
for( FUNCRELOCTABLE::iterator k = m_pFuncRelocTable->begin(); k != m_pFuncRelocTable->end(); k++ )
{
long * pValue = (long*)(pCode + k->second);
*pValue = (long) ArrFuncPtr[k->first];
}
}
void CRelocTable::Unlocate( void * pGlobalVarBuffer, void * pStringBuffer, void * pCodeBuffer )
{
char * pCode = (char*)pCodeBuffer;
for( RELOCTABLE::iterator i = m_pGlobalVarTable->begin(); i != m_pGlobalVarTable->end(); i++ )
{
long * pValue = (long*)(pCode + *i);
*pValue -= long(pGlobalVarBuffer);
}
for( i = m_pStringTable->begin(); i != m_pStringTable->end(); i++ )
{
long * pValue = (long*)(pCode + *i);
*pValue -= long(pStringBuffer);
}
for( FUNCRELOCTABLE::iterator k = m_pFuncRelocTable->begin(); k != m_pFuncRelocTable->end(); k++ )
{
long * pValue = (long*)(pCode + k->second);
*pValue = 0;
}
}

51
CryptoSource/ScriptEngine-MCF File/RelocTable.h Normal file
View File

@@ -0,0 +1,51 @@
#ifndef _RelocTable_H_
#define _RelocTable_H_
#include "STL.h"
///////////////////////////////////////////////////////////////////////////////////
//
enum eStdFunc
{
FUNC_ITOA = 0,
FUNC_GCVT,
FUNC_MALLOC,
FUNC_FREE,
FUNC_STRCPY,
FUNC_STRCMP,
FUNC_STRLEN,
FUNC_REGISTERALLOCATEDMEMORY,
FUNC_UNREGISTERALLOCATEDMEMORY = 8
};
class CRelocTable
{
typedef vector<int> RELOCTABLE;
typedef pair<eStdFunc, int> FUNCRELOC;
typedef vector<FUNCRELOC> FUNCRELOCTABLE;
RELOCTABLE * m_pGlobalVarTable;
RELOCTABLE * m_pStringTable;
FUNCRELOCTABLE * m_pFuncRelocTable;
public:
CRelocTable();
~CRelocTable();
void Create( ifstream & );
const void * Create( const void * pDataBuf, unsigned dataSize );
void Destroy();
void Save( ofstream & );
void AddGlobalVar( int offset );
void AddConstString( int offset );
void AddFuncBind( eStdFunc, int offset );
void Relocate( void * pGlobalVarBuffer, void * pStringBuffer, void * pCodeBuffer );
void Unlocate( void * pGlobalVarBuffer, void * pStringBuffer, void * pCodeBuffer );
};
///////////////////////////////////////////////////////////////////////////////////
#endif

20
CryptoSource/ScriptEngine-MCF File/STL.h Normal file
View File

@@ -0,0 +1,20 @@
#ifndef _STL_H_
#define _STL_H_
#pragma warning(disable:4786) //STL<54><4C> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Warning<6E><67> <20><><EFBFBD>ֱ<EFBFBD> <20><><EFBFBD><EFBFBD>..
#include <iosfwd>
#include <map>
#include <set>
#include <string>
#include <deque>
#include <queue>
#include <vector>
#include <stack>
#include <list>
#include <utility>
using namespace std;
#endif

169
CryptoSource/ScriptEngine-MCF File/ScriptEngine.cpp Normal file
View File

@@ -0,0 +1,169 @@
// ScriptEngine.cpp : Defines the entry point for the DLL application.
//
#include "ScriptEngine.h"
#include "SyntaxTree.h"
#include "IntermediateCode.h"
#include "VirtualMachine.h"
#include "Message.h"
#include <stdarg.h>
#include <stdio.h>
#include <windows.h>
#include "GMMemory.h"
/*
BOOL APIENTRY DllMain( HANDLE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
return TRUE;
}*/
SCRIPT _SE_Create( const char * codeFile )
{
FILE * fp = fopen( codeFile, "r" );
if( fp == NULL )
{
ErrorMessage2( "Cannot open file : %s", codeFile );
return NULL;
}
CVirtualMachine * pVM = new CVirtualMachine;
char szFilename[128];
strcpy( szFilename, codeFile );
strlwr( szFilename );
if( strstr( szFilename, MACHINECODEFILEEXT ) != 0 )
{
pVM->Create( codeFile );
}
else if( strstr( szFilename, SCRIPTFILEEXT ) != 0 )
{
CSyntaxTree SyntaxTree;
CIntermediateCode IMCode;
SyntaxTree.Create( codeFile );
IMCode.Create( SyntaxTree );
pVM->Create( IMCode, *SyntaxTree.GetSymbolTable() );
}
else
{
return NULL;
}
return pVM;
}
void _SE_Destroy( SCRIPT Script )
{
delete Script;
}
bool _SE_Save( SCRIPT Script, const char * szFilename )
{
return Script->Save( szFilename );
}
void _SE_Execute( SCRIPT Script )
{
Script->Execute();
}
void _SE_RegisterFunction( SCRIPT Script, ANY_FUNCTION FuncPtr, eDataType RetType, const char * szFuncName, ... )
{
va_list args;
va_start( args, szFuncName );
Script->RegisterFunction( FuncPtr, RetType, szFuncName, args );
}
SE_FUNC _SE_GetScriptFunction( SCRIPT Script, eDataType RetType, const char * szFuncName, ... )
{
va_list args;
va_start( args, szFuncName );
return Script->GetScriptFunction( RetType, szFuncName, args );
}
void _SE_SetMessageFunction( MESSAGE_FUNCTION func )
{
SetCompilerMessageFunction( func );
}
AnyData _SE_CallScriptFunction( SCRIPT pScript, SE_FUNC Func )
{
return pScript->CallScriptFunction( Func );
}
AnyData _SE_CallScriptFunction( SCRIPT pScript, SE_FUNC Func, AnyData arg1 )
{
return pScript->CallScriptFunction( Func, arg1 );
}
AnyData _SE_CallScriptFunction( SCRIPT pScript, SE_FUNC Func, AnyData arg1, AnyData arg2 )
{
return pScript->CallScriptFunction( Func, arg1, arg2 );
}
AnyData _SE_CallScriptFunction( SCRIPT pScript, SE_FUNC Func, AnyData arg1, AnyData arg2, AnyData arg3 )
{
return pScript->CallScriptFunction( Func, arg1, arg2, arg3 );
}
AnyData _SE_CallScriptFunction( SCRIPT pScript, SE_FUNC Func, AnyData arg1, AnyData arg2, AnyData arg3, AnyData arg4 )
{
return pScript->CallScriptFunction( Func, arg1, arg2, arg3, arg4 );
}
AnyData _SE_CallScriptFunction( SCRIPT pScript, SE_FUNC Func, AnyData args[], int nArgs )
{
return pScript->CallScriptFunction( Func, args, nArgs );
}
AnyData _SE_CallScriptFunction( SCRIPT pScript, SE_FUNC Func, AnyData arg0, AnyData arg1, AnyData arg2, AnyData arg3, AnyData arg4,
AnyData arg5, AnyData arg6, AnyData arg7, AnyData arg8, AnyData arg9,
AnyData arg10, AnyData arg11, AnyData arg12, AnyData arg13, AnyData arg14,
AnyData arg15, AnyData arg16, AnyData arg17, AnyData arg18, AnyData arg19,
AnyData arg20, AnyData arg21, AnyData arg22, AnyData arg23, AnyData arg24,
AnyData arg25, AnyData arg26, AnyData arg27, AnyData arg28, AnyData arg29,
AnyData arg30, AnyData arg31, AnyData arg32, AnyData arg33, AnyData arg34 )
{
return pScript->CallScriptFunction( Func, arg0,
arg1,
arg2,
arg3,
arg4,
arg5,
arg6,
arg7,
arg8,
arg9,
arg10,
arg11,
arg12,
arg13,
arg14,
arg15,
arg16,
arg17,
arg18,
arg19,
arg20,
arg21,
arg22,
arg23,
arg24,
arg25,
arg26,
arg27,
arg28,
arg29,
arg30,
arg31,
arg32,
arg33,
arg34 ) ;
}

72
CryptoSource/ScriptEngine-MCF File/ScriptEngine.h Normal file
View File

@@ -0,0 +1,72 @@
#ifndef _ScriptEngine_H_
#define _ScriptEngine_H_
#include "BaseDef.h"
#define DllExport // __declspec( dllexport )
class CVirtualMachine;
typedef CVirtualMachine * SCRIPT;
typedef void (*MESSAGE_FUNCTION)( const char * ErrMsg );
typedef void (*MESSAGE_FUNCTION2)( const char *, ... );
typedef char * va_list;
////////////////////////////////////////////////////////////////////////////////
//
DllExport SCRIPT _SE_Create( const char * codeFile );
DllExport void _SE_Destroy( SCRIPT );
DllExport bool _SE_Save( SCRIPT, const char * );
DllExport void _SE_Execute( SCRIPT );
DllExport void _SE_RegisterFunction( SCRIPT, ANY_FUNCTION, eDataType, const char * FuncName, ... );
DllExport SE_FUNC _SE_GetScriptFunction( SCRIPT, eDataType, const char * FuncName, ... );
DllExport void _SE_SetMessageFunction( MESSAGE_FUNCTION );
DllExport AnyData _SE_CallScriptFunction( SCRIPT, SE_FUNC );
DllExport AnyData _SE_CallScriptFunction( SCRIPT, SE_FUNC, AnyData );
DllExport AnyData _SE_CallScriptFunction( SCRIPT, SE_FUNC, AnyData, AnyData );
DllExport AnyData _SE_CallScriptFunction( SCRIPT, SE_FUNC, AnyData, AnyData, AnyData );
DllExport AnyData _SE_CallScriptFunction( SCRIPT, SE_FUNC, AnyData, AnyData, AnyData, AnyData );
DllExport AnyData _SE_CallScriptFunction( SCRIPT, SE_FUNC, AnyData args[], int nArgs );
DllExport AnyData _SE_CallScriptFunction( SCRIPT, SE_FUNC,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData,
AnyData ) ;
////////////////////////////////////////////////////////////////////////////////
#endif

284
CryptoSource/ScriptEngine-MCF File/ScriptEngine.vcproj Normal file
View File

@@ -0,0 +1,284 @@
<?xml version="1.0" encoding="ks_c_5601-1987"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.10"
Name="ScriptEngine"
ProjectGUID="{38A28771-3FBC-4836-841D-F01C585D0DF4}"
Keyword="Win32Proj">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="../../Library/$(ConfigurationName)"
IntermediateDirectory="../../Intermediate/$(ProjectName)/$(ConfigurationName)"
ConfigurationType="4"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="../../MemoryManager"
PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
MinimalRebuild="TRUE"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="FALSE"
DebugInformationFormat="4"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLibrarianTool"
OutputFile="$(OutDir)/ScriptEngine.lib"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="../../Library/$(ConfigurationName)"
IntermediateDirectory="../../Intermediate/$(ProjectName)/$(ConfigurationName)"
ConfigurationType="4"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="../../MemoryManager"
PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
RuntimeLibrary="0"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="FALSE"
DebugInformationFormat="3"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLibrarianTool"
OutputFile="$(OutDir)/ScriptEngine.lib"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="Release_NoGD|Win32"
OutputDirectory="../../Library/$(ConfigurationName)"
IntermediateDirectory="../../Intermediate/$(ProjectName)/$(ConfigurationName)"
ConfigurationType="4"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="../../MemoryManager"
PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
RuntimeLibrary="0"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="FALSE"
DebugInformationFormat="3"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLibrarianTool"
OutputFile="$(OutDir)/ScriptEngine.lib"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="Debug_NOGD|Win32"
OutputDirectory="$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="4"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="../../MemoryManager"
PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
MinimalRebuild="TRUE"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="FALSE"
DebugInformationFormat="4"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLibrarianTool"
OutputFile="$(OutDir)/ScriptEngine.lib"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="<22>ҽ<EFBFBD> <20><><EFBFBD><EFBFBD>"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
<File
RelativePath=".\IMCodeGen.cpp">
</File>
<File
RelativePath=".\IMCodeUnits.cpp">
</File>
<File
RelativePath=".\IntermediateCode.cpp">
</File>
<File
RelativePath=".\lex.cpp">
</File>
<File
RelativePath=".\Message.cpp">
</File>
<File
RelativePath=".\parse.cpp">
</File>
<File
RelativePath=".\RelocTable.cpp">
</File>
<File
RelativePath=".\ScriptEngine.cpp">
</File>
<File
RelativePath=".\SymbolTable.cpp">
</File>
<File
RelativePath=".\SyntaxTree.cpp">
</File>
<File
RelativePath=".\VirtualMachine.cpp">
</File>
</Filter>
<Filter
Name="<22><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
<File
RelativePath=".\BaseDef.h">
</File>
<File
RelativePath=".\IMCodeGen.h">
</File>
<File
RelativePath=".\IMCodeUnits.h">
</File>
<File
RelativePath=".\IntermediateCode.h">
</File>
<File
RelativePath=".\lex.h">
</File>
<File
RelativePath=".\lexsymb.h">
</File>
<File
RelativePath=".\Message.h">
</File>
<File
RelativePath=".\RelocTable.h">
</File>
<File
RelativePath=".\ScriptEngine.h">
</File>
<File
RelativePath=".\STL.h">
</File>
<File
RelativePath=".\SymbolTable.h">
</File>
<File
RelativePath=".\SyntaxTree.h">
</File>
<File
RelativePath=".\unistd.h">
</File>
<File
RelativePath=".\VirtualMachine.h">
</File>
</Filter>
<Filter
Name="<22><><EFBFBD>ҽ<EFBFBD> <20><><EFBFBD><EFBFBD>"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}">
</Filter>
<File
RelativePath=".\bison.simple">
</File>
<File
RelativePath=".\ReadMe.txt">
</File>
<File
RelativePath=".\string.l">
</File>
<File
RelativePath=".\string.y">
</File>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

104
CryptoSource/ScriptEngine-MCF File/ScriptTest/ScriptTest.dsp Normal file
View File

@@ -0,0 +1,104 @@
# Microsoft Developer Studio Project File - Name="ScriptTest" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=ScriptTest - 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 "ScriptTest.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 "ScriptTest.mak" CFG="ScriptTest - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "ScriptTest - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "ScriptTest - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""$/ScriptEngine/ScriptTest", MFDAAAAA"
# PROP Scc_LocalPath "."
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "ScriptTest - 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 Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /Zi /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FAcs /YX /FD /c
# SUBTRACT CPP /Fr
# ADD BASE RSC /l 0x412 /d "NDEBUG"
# ADD RSC /l 0x412 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386
# SUBTRACT LINK32 /map
!ELSEIF "$(CFG)" == "ScriptTest - 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 Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x412 /d "_DEBUG"
# ADD RSC /l 0x412 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"ScriptTest.exe" /pdbtype:sept
!ENDIF
# Begin Target
# Name "ScriptTest - Win32 Release"
# Name "ScriptTest - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=.\main.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

245
CryptoSource/ScriptEngine-MCF File/ScriptTest/TestCode.gsf Normal file
View File

@@ -0,0 +1,245 @@
void Print( int );
void Print( float );
void Print( string );
void Print( bool );
int getDouble( int n )
{
return n*n;
}
float getDouble( float f )
{
return f*f;
}
float TestFloat( float f1, float f2 )
{
return f1 * f2;
}
float TestFloat( float f1, float f2, float f3 )
{
return f1 * f2 * f3;
}
float TestFloat( float f1, float f2, float f3, float f4 )
{
return f1 * f2 * f3 * f4;
}
void TestArith()
{
Print( "--------<2D><><EFBFBD><EFBFBD> <20><>Ģ<EFBFBD><C4A2><EFBFBD><EFBFBD> <20>׽<EFBFBD>Ʈ---------" );
int iint1 = 0X0ecd;//54434;
int iint2 = 1840;
Print( iint1 );
int iint3 = iint1 + iint2;
Print( iint3 );
Print( iint1 - iint2 );
iint3 = iint1 * iint2;
Print( iint3 );
iint3 = iint1 / iint2;
Print( iint3 );
iint3 = iint1 % iint2;
Print( iint3 );
Print( iint3++ );
Print( iint3-- );
Print( ++iint3 );
Print( --iint3 );
Print( iint3 += iint1 );
Print( iint1 - iint3 );
Print( iint3 -= iint1 );
Print( iint3 *= iint2 );
Print( iint3 /= iint2 );
Print( iint3 %= iint1 );
}
void ScriptMain()
{
float f1 = 0.43521;
float f2 = 98.3145;
int i1 = 4352;
int i2 = 986214;
bool b1 = true;
bool b2 = false;
string str1 = "str1<72><31><EFBFBD><EFBFBD><EFBFBD><EFBFBD>~";
string str2 = "str2<72><32><EFBFBD>շ<EFBFBD>~~";
Print( "--------string <20>׽<EFBFBD>Ʈ--------" );
string str3;
Print( str3 = str1 );
str3 = i1;
Print( str3 );
Print( str3 = f1 );
str3 = b1;
Print( str3 );
str3 = "ũũũ ";
str3 += str2;
Print( str3 );
str3 += i2;
Print( str3 );
str3 += f2;
Print( str3 );
str3 += b2;
Print( str3 );
Print( str1 + str2 );
Print( str1 + i1 );
Print( str1 + f1 );
Print( str1 + b1 );
Print( str2 + str1 );
Print( i2 + str2 );
Print( f2 + str2 );
Print( b2 + str2 );
str3 = str1 == str2;
Print( str3 );
str3 = str1 == "str1<72><31><EFBFBD><EFBFBD><EFBFBD><EFBFBD>~";
Print( str3 );
str3 = str1 != str2;
Print( str3 );
Print( "-------Init Declaration <20>׽<EFBFBD>Ʈ-------" );
string sstr1 = str1;
Print( sstr1 );
string sstr2 = i1;
Print( sstr2 );
string sstr3 = f1;
Print( sstr3 );
string sstr4 = b1;
Print( sstr4 );
string sstr5 = str1 + str2;
Print( sstr5 );
string sstr6 = str1 + i2;
Print( sstr6 );
string sstr7 = str1 + f2;
Print( sstr7 );
string sstr8 = str1 + b2;
Print( sstr8 );
string sstr9 = i1 + str2;
Print( sstr9 );
string sstr10 = f1 + str2;
Print( sstr10 );
string sstr11 = b1 + str2;
Print( sstr11 );
string sstr12 = str1 == "str1<72><31><EFBFBD><EFBFBD><EFBFBD><EFBFBD>~";
Print( sstr12 );
string sstr13 = str1 != str2;
Print( sstr13 );
string sstr14 = str2 == "ũũũ";
Print( sstr14 );
Print( "-------Float <20><>Ģ<EFBFBD><C4A2><EFBFBD><EFBFBD> <20>׽<EFBFBD>Ʈ--------" );
Print( f1 + f2 );
Print( f1 - f2 );
Print( f1 * f2 );
Print( f1 / f2 );
Print( ++f1 );
Print( --f1 );
Print( f1++ );
Print( f1-- );
Print( f1 );
Print( f1 += f2 );
Print( f1 -= f2 );
Print( f1 *= f2 );
Print( f1 /= f2 );
Print( "-------------<2D>迭 <20>׽<EFBFBD>Ʈ------------" );
int arrInt[] = { 2145, 124765, 7568, 7824, 23562351 };
float arrFloat[] = { 0.325, 85.235, 82.3523, 325.1216 };
bool arrBool[] = { true, false, true, str1!=str2 };
int i = 0;
for( i = 0; i < 5; i++ )
Print( arrInt[i] );
i = 0;
while( i < 4 )
{
if( i == 2 )
{
i++;
continue;
}
Print( arrFloat[i++] );
}
for( i = 0;; i++ )
{
if( i >= 4 )
break;
string strTemp;
strTemp = arrBool[i];
Print( strTemp );
}
string arrStr[] = { "str1<72>޷<EFBFBD>", "str2ũũ", "str3<72>ֱ۷<D6B1>?"
, "str4<72><34><EFBFBD><EFBFBD><EFBFBD><EFBFBD>", 425346, 4125.5636, true, str1 };
for( i = 0; i < 8; i++ )
Print( arrStr[i] );
if( arrInt[0] != 2145 )
{
Print( "<22>ٺ<EFBFBD>" );
}
else
{
TestArith();
}
switch( arrInt[1] )
{
case 2145 :
Print( "2145<34><35><EFBFBD><EFBFBD>~" );
break;
case 124765 :
Print( "124765<36><35><EFBFBD><EFBFBD>~" );
case 7568 :
Print( "7568<36><38><EFBFBD><EFBFBD><EFBFBD><EFBFBD>~" );
break;
case 7824 :
Print( "7824<32><34><EFBFBD><EFBFBD>~" );
break;
case 23562351 :
Print( "23562351<35><31><EFBFBD><EFBFBD><EFBFBD><EFBFBD>~" );
break;
default :
Print( "default<6C><74><EFBFBD><EFBFBD>~" );
}
Print( getDouble( 10 ) );
Print( getDouble( 4.4 ) );
Print( true );
Print( false );
}

100
CryptoSource/ScriptEngine-MCF File/ScriptTest/main.cpp Normal file
View File

@@ -0,0 +1,100 @@
#include <iostream>
#include <conio.h> //getch
using namespace std;
#include "..\ScriptEngine.h"
void PrintInt( int n )
{
cout << "Print( int ) ==> " << n << endl;
}
void PrintFloat( float f )
{
cout << "Print( float ) ==> " << f << endl;
}
void PrintStr( const char * str )
{
cout << "Print( const char * ) ==> " << str << endl;
}
void PrintBOOL( BOOL b )
{
cout << "Print( bool ) ==> ";
if( b )
cout << "true";
else
cout << "false";
cout << endl;
}
void ScriptMessage( const char * msg )
{
cout << "##" << msg << "##\n";
}
void main( int argc, char *argv[] )
{
//!!!!!!!!!!<21>ð<EFBFBD><C3B0><EFBFBD><EFBFBD><EFBFBD> <20>׽<EFBFBD>Ʈ<EFBFBD><C6AE> <20><> <20><> <20>ڵ<EFBFBD>ȭ <20><> <20><>!!!!!!!!!!!//
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20>κ<EFBFBD><CEBA><EFBFBD> <20>׽<EFBFBD>Ʈ<EFBFBD><C6AE> <20>ϰ<EFBFBD> Print<6E>ؼ<EFBFBD> <20>ﵵ<EFBFBD><EFB5B5> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//<2F><><EFBFBD><EFBFBD> Ȯ<><C8AE><EFBFBD>ϰ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>... assert( test == <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ) <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ϸ<EFBFBD>
//assert<72><74> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ok<6F><6B><EFBFBD><EFBFBD> <20>ƴ<EFBFBD><C6B4><EFBFBD><EFBFBD><EFBFBD> Ȯ<><C8AE><EFBFBD>ϸ<EFBFBD> <20>ǹǷ<C7B9> <20>ξ<EFBFBD> ȿ<><C8BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
_SE_SetMessageFunction( ScriptMessage );
SCRIPT Script;
if( argc != 2 )
{
Script = _SE_Create( "TestCode.gsf" );
}
else
{
Script = _SE_Create( argv[1] );
}
if( Script == 0 )
cout << "usage : ScriptTest [gsf filename]" << endl;
_SE_RegisterFunction( Script, PrintInt, T_VOID, "Print", T_INT, T_VOID );
_SE_RegisterFunction( Script, PrintFloat, T_VOID, "Print", T_FLOAT, T_VOID );
_SE_RegisterFunction( Script, PrintStr, T_VOID, "Print", T_STRING, T_VOID );
_SE_RegisterFunction( Script, PrintBOOL, T_VOID, "Print", T_BOOL, T_VOID );
_SE_Execute( Script );
SE_FUNC ScriptMain = _SE_GetScriptFunction( Script, T_VOID, "ScriptMain", 0 );
_SE_CallScriptFunction( Script, ScriptMain );
SE_FUNC getDoubleFunc = _SE_GetScriptFunction( Script, T_INT, "getDouble", T_INT, 0 );
AnyData result = _SE_CallScriptFunction( Script, getDoubleFunc, 1000 );
cout << "getDouble() ==> " << result.intValue << endl;
SE_FUNC getDoubleFunc2 = _SE_GetScriptFunction( Script, T_FLOAT, "getDouble", T_FLOAT, 0 );
AnyData result2 = _SE_CallScriptFunction( Script, getDoubleFunc2, 0.534f );
cout << "getDouble(float) ==> " << result2.floatValue << endl;
SE_FUNC TestFloat1 = _SE_GetScriptFunction( Script, T_FLOAT, "TestFloat", T_FLOAT, T_FLOAT, 0 );
result = _SE_CallScriptFunction( Script, TestFloat1, 0.325f, 13.535f ); //4.398875
cout << "TestFloat( float, float ) ==> " << result.floatValue << endl;
SE_FUNC TestFloat2 = _SE_GetScriptFunction( Script, T_FLOAT, "TestFloat", T_FLOAT, T_FLOAT, T_FLOAT, 0 );
result = _SE_CallScriptFunction( Script, TestFloat2, 0.23415f, 8412.5325f, 212.53f ); //418640.4218
cout << "TestFloat( float, float, float ) ==> " << result.floatValue << endl;
SE_FUNC TestFloat3 = _SE_GetScriptFunction( Script, T_FLOAT, "TestFloat", T_FLOAT, T_FLOAT, T_FLOAT, T_FLOAT, 0 );
result = _SE_CallScriptFunction( Script, TestFloat3, 32.3f, 35.2f, 8.2f, 93.66f );
cout << "TestFloat( float, float, float, float ) ==> " << result.floatValue << endl; //873198.92352
cout << "Press any key to continue...\n";
// getch();
_SE_Destroy( Script );
}

8
CryptoSource/ScriptEngine-MCF File/StdAfx.cpp Normal file
View File

@@ -0,0 +1,8 @@
// stdafx.cpp : source file that includes just the standard includes
// ScriptEngine.pch will be the pre-compiled header
// stdafx.obj will contain the pre-compiled type information
#include "stdafx.h"
// TODO: reference any additional headers you need in STDAFX.H
// and not in this file

24
CryptoSource/ScriptEngine-MCF File/StdAfx.h Normal file
View File

@@ -0,0 +1,24 @@
// 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__BA59493D_1C58_4CCC_8997_52673E806120__INCLUDED_)
#define AFX_STDAFX_H__BA59493D_1C58_4CCC_8997_52673E806120__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Insert your headers here
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
#include <windows.h>
// TODO: reference additional headers your program requires here
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_STDAFX_H__BA59493D_1C58_4CCC_8997_52673E806120__INCLUDED_)

525
CryptoSource/ScriptEngine-MCF File/SymbolTable.cpp Normal file
View File

@@ -0,0 +1,525 @@
#include "SymbolTable.h"
#include <assert.h>
#include <map>
#include <string>
#include <list>
#include "GMMemory.h"
///////////////////////////////////////////////////////////////////////////////////
// <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
const char * DataTypeString[] = { "void", "bool", "int", "float", "string" };
///////////////////////////////////////////////////////////////////////////////////
//
SFuncType::SFuncType()
: m_data( 0 )
{
}
SFuncType::SFuncType( unsigned long data )
: m_data( data )
{
}
int SFuncType::GetArgCount()
{
int i = 0;
for( ; i < 7; i++ )
{
if( GetArgType( i ) == T_VOID )
break;
}
return i;
}
const char* SFuncType::ToString( const char * szFuncName )
{
static char szBuffer[128];
int n = sprintf( szBuffer, "%s %s(", DataTypeString[GetReturnType()], szFuncName );
char * pBuffer = szBuffer + n;
eDataType argType = GetArgType( 0 );
if( argType != T_VOID )
{
n = sprintf( pBuffer, " %s", DataTypeString[ argType ] );
pBuffer += n;
for( int i = 1; i < 7; i++ )
{
argType = GetArgType( i );
if( argType == T_VOID )
break;
n = sprintf( pBuffer, ", %s", DataTypeString[ argType ] );
pBuffer += n;
}
strcpy( pBuffer, " " );
pBuffer += 1;
}
strcpy( pBuffer, ")" );
return szBuffer;
}
struct ConstInfo
{
eDataType m_dataType;
int m_iOffset;
ConstInfo()
: m_dataType( T_VOID ), m_iOffset( 0 )
{}
ConstInfo( eDataType type )
: m_dataType( type ), m_iOffset( 0 )
{}
ConstInfo( eDataType type, int offset )
: m_dataType( type ), m_iOffset( offset )
{}
};
struct VarInfo
{
eDataType m_dataType;
int m_iCount; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>. <20>Ϲ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 1<>̰<EFBFBD> <20>迭<EFBFBD><E8BFAD> <20><><EFBFBD><EFBFBD> <20>迭 <20><><EFBFBD><EFBFBD>.
int m_iOffset;
VarInfo()
: m_dataType( T_VOID ), m_iCount( 0 ), m_iOffset( 0 )
{}
VarInfo( eDataType dataType, int count )
: m_dataType( dataType ), m_iCount( count ), m_iOffset( 0 )
{}
VarInfo( eDataType dataType, int count, int offset )
: m_dataType( dataType ), m_iCount( count ), m_iOffset( offset )
{}
};
typedef CSymbolTable::VAR_CONTAINER VAR_CONTAINER;
typedef VAR_CONTAINER::value_type Value_Type;
typedef struct SLocalVarInfo
{
int m_iFuncID;
VAR_CONTAINER m_ArgContainer;
VAR_CONTAINER m_VarContainer;
SLocalVarInfo()
: m_iFuncID( 0 )
{}
} LOCALVARINFO;
///////////////////////////////////////////////////////////////////////////////////
//
CSymbolTable::CSymbolTable()
: m_pConstants( new CONST_CONTAINER )
, m_pGlobalVar( new VAR_CONTAINER )
, m_pLocalVars( new LOCALVAR_CONTAINER )
, m_pCurNameSpace( m_pGlobalVar )
, m_pNameSpace2( NULL )
, m_pFunctions( new FUNC_CONTAINER )
, m_eCurrentType( T_VOID )
, m_pCurrentLocalVar( NULL )
, m_iVarOffset( 0 )
, m_iVarOffsetGlobal( 0 )
, m_iOffsetFactor( 4 )
, m_iStringOffset( 0 )
{
}
CSymbolTable::~CSymbolTable()
{
delete m_pConstants;
delete m_pGlobalVar;
delete m_pLocalVars;
delete m_pFunctions;
}
void CSymbolTable::Create()
{
}
void CSymbolTable::Destroy()
{
m_pConstants->clear();
m_pGlobalVar->clear();
m_pLocalVars->clear();
m_pFunctions->clear();
m_eCurrentType = T_VOID;
}
int CSymbolTable::AddConst( const char * szName, eDataType type )
{
int finded = FindConst( szName );
if( finded != 0 )
return finded;
pair< CONST_CONTAINER::iterator, bool > result;
if( type == T_STRING )
{
result = m_pConstants->insert( CONST_CONTAINER::value_type( szName, ConstInfo( type, m_iStringOffset ) ) );
m_iStringOffset += strlen( szName ) + 1;
}
else
result = m_pConstants->insert( CONST_CONTAINER::value_type( szName, type ) );
return int(&(*result.first));
}
int CSymbolTable::AddArrVar( const char * szName, eDataType type, int nArray )
{
pair< VAR_CONTAINER::iterator, bool > result;
if( m_pCurrentLocalVar == NULL )
{
result = m_pCurNameSpace->insert( VAR_CONTAINER::value_type( szName, VARINFO( type, nArray, m_iVarOffset ) ) );
m_iVarOffset += m_iOffsetFactor * nArray;
}
else
{
m_iVarOffset += m_iOffsetFactor * nArray;
result = m_pCurNameSpace->insert( VAR_CONTAINER::value_type( szName, VARINFO( type, nArray, m_iVarOffset ) ) );
}
if( !result.second )
return 0;
return int(&(*result.first));
}
int CSymbolTable::AddFunc( bool hasDef, const char * szName, SFuncType type )
{
typedef FUNC_CONTAINER::value_type value_type;
int finded = FindFunc( szName, type );
if( hasDef )
{
if( finded != 0 )
{
if( IsFuncDefined( finded ) )
{
return 0;
}
else
{
value_type * pValue = (value_type*)finded;
pValue->second.second = true;
return finded;
}
}
else
{
FUNC_CONTAINER::iterator result = m_pFunctions->insert( FUNC_CONTAINER::value_type( szName, FUNCINFO( type, true ) ) );
return int(&(*result));
}
}
else
{
if( finded == 0 )
{
FUNC_CONTAINER::iterator result = m_pFunctions->insert( FUNC_CONTAINER::value_type( szName, FUNCINFO( type, false ) ) );
return int(&(*result));
}
else
return finded;
}
}
int CSymbolTable::FindConst( const char * szName )
{
CONST_CONTAINER::iterator result = m_pConstants->find( szName );
if( result == m_pConstants->end() )
return 0;
return int(&(*result));
}
int CSymbolTable::FindVar( const char * szName )
{
VAR_CONTAINER::iterator result = m_pCurNameSpace->find( szName );
if( result == m_pCurNameSpace->end() )
{
if( m_pNameSpace2 )
{
result = m_pNameSpace2->find( szName );
if( result == m_pNameSpace2->end() )
{
if( m_pCurNameSpace != m_pGlobalVar )
{
result = m_pGlobalVar->find( szName );
if( result == m_pGlobalVar->end() )
return 0;
}
else
return 0;
}
}
else
{
return 0;
}
}
return int(&(*result));
}
int CSymbolTable::FindFunc( const char * szName, SFuncType type )
{
typedef FUNC_CONTAINER::iterator iterator;
pair< iterator, iterator > result = m_pFunctions->equal_range( szName );
while( result.first != result.second )
{
if( result.first->second.first == type )
return int(&(*result.first));
result.first++;
}
return 0;
}
const char* CSymbolTable::GetNameOfConst( int symbolID )
{
typedef CONST_CONTAINER::value_type value_type;
value_type * pValue = (value_type*)symbolID;
return pValue->first.c_str();
}
eDataType CSymbolTable::GetTypeOfConst( int symbolID )
{
typedef CONST_CONTAINER::value_type value_type;
value_type * pValue = (value_type*)symbolID;
return pValue->second.m_dataType;
}
int CSymbolTable::GetOffsetOfConst( int symbolID )
{
typedef CONST_CONTAINER::value_type value_type;
value_type * pValue = (value_type*)symbolID;
return pValue->second.m_iOffset;
}
const char* CSymbolTable::GetNameOfVar( int symbolID )
{
typedef VAR_CONTAINER::value_type value_type;
value_type * pValue = (value_type*)symbolID;
return pValue->first.c_str();
}
eDataType CSymbolTable::GetTypeOfVar( int symbolID )
{
typedef VAR_CONTAINER::value_type value_type;
value_type * pValue = (value_type*)symbolID;
return pValue->second.m_dataType;
}
int CSymbolTable::GetCountOfVar( int symbolID )
{
typedef VAR_CONTAINER::value_type value_type;
value_type * pValue = (value_type*)symbolID;
return pValue->second.m_iCount;
}
int CSymbolTable::GetOffsetOfVar( int varID )
{
typedef VAR_CONTAINER::value_type value_type;
value_type * pValue = (value_type*)varID;
return pValue->second.m_iOffset;
}
const char* CSymbolTable::GetNameOfFunc( int symbolID )
{
typedef FUNC_CONTAINER::value_type value_type;
value_type * pValue = (value_type*)symbolID;
return pValue->first.c_str();
}
const char* CSymbolTable::GetTypeStringOfFunc( int symbolID )
{
SFuncType type = GetTypeOfFunc( symbolID );
return type.ToString( GetNameOfFunc( symbolID ) );
}
SFuncType CSymbolTable::GetTypeOfFunc( int symbolID )
{
typedef FUNC_CONTAINER::value_type value_type;
value_type * pValue = (value_type*)symbolID;
return pValue->second.first;
}
bool CSymbolTable::IsFuncDefined( int symbolID )
{
typedef FUNC_CONTAINER::value_type value_type;
value_type * pValue = (value_type*)symbolID;
return pValue->second.second;
}
void CSymbolTable::BeginLocalNameSpace()
{
m_pLocalVars->push_back( LOCALVARINFO() );
m_pCurrentLocalVar = &m_pLocalVars->back();
m_pCurNameSpace = &m_pCurrentLocalVar->m_ArgContainer;
m_pNameSpace2 = &m_pCurrentLocalVar->m_VarContainer;
m_iVarOffsetGlobal = m_iVarOffset;
m_iVarOffset = 4;
m_iOffsetFactor = 4;
}
void CSymbolTable::EndLocalNameSpace( int FuncID )
{
m_pCurNameSpace = m_pGlobalVar;
m_pNameSpace2 = NULL;
m_pCurrentLocalVar = NULL;
if( FuncID )
{
m_pLocalVars->back().m_iFuncID = FuncID;
}
else
m_pLocalVars->pop_back();
m_iVarOffset = m_iVarOffsetGlobal;
m_iOffsetFactor = 4;
}
void CSymbolTable::EndArgument()
{
if( m_pCurrentLocalVar )
{
m_pCurNameSpace = &m_pCurrentLocalVar->m_VarContainer;
m_pNameSpace2 = &m_pCurrentLocalVar->m_ArgContainer;
m_iVarOffset = 0;
m_iOffsetFactor = -4;
}
}
int CSymbolTable::GetLocalVarSize( int FuncID )
{
int size = 0;
VAR_CONTAINER * pNameSpace = NULL;
for( LOCALVAR_CONTAINER::iterator i = m_pLocalVars->begin(); i != m_pLocalVars->end(); i++ )
{
if( i->m_iFuncID == FuncID )
{
pNameSpace = &(i->m_VarContainer);
break;
}
}
if( pNameSpace == NULL )
{
ScriptSystemError( "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20≯<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ã<><C3A3> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. (CSymbolTable::GetLocalVarSize)" );
return 0;
}
for( VAR_CONTAINER::iterator j = pNameSpace->begin(); j != pNameSpace->end(); j++ )
{
size += j->second.m_iCount * 4;
}
return size;
}
int CSymbolTable::GetGlobalVarSize()
{
int size = 0;
for( VAR_CONTAINER::iterator i = m_pGlobalVar->begin(); i != m_pGlobalVar->end(); i++ )
{
size += i->second.m_iCount * 4;
}
return size;
}
int CSymbolTable::GetStringBufferSize()
{
return m_iStringOffset;
}
void CSymbolTable::StringBuffer( void * pBuffer )
{
char * pBuf = (char*)pBuffer;
for( CONST_CONTAINER::iterator i = m_pConstants->begin(); i != m_pConstants->end(); i++ )
{
if( i->second.m_dataType == T_STRING )
{
strcpy( pBuf + i->second.m_iOffset, i->first.c_str() );
}
}
}
void ShowVariables( CSymbolTable::VAR_CONTAINER & Container, MESSAGE_FUNCTION2 Print )
{
for( CSymbolTable::VAR_CONTAINER::iterator i = Container.begin(); i!= Container.end(); i++ )
{
Print( i->first.c_str() );
if( i->second.m_iCount != 1 )
{
Print( "[%d]", i->second.m_iCount );
}
Print( " : %s <%d>\n", DataTypeString[ i->second.m_dataType ], i->second.m_iOffset );
}
}
void CSymbolTable::Show( MESSAGE_FUNCTION2 Print )
{
const char * DataTypeString[] = { "void", "bool", "int", "float", "string" };
Print( "--Constants--\n" );
for( CONST_CONTAINER::iterator i = m_pConstants->begin(); i!= m_pConstants->end(); i++ )
{
Print( "%s : %s <%d>\n", i->first.c_str(), DataTypeString[ i->second.m_dataType ], i->second.m_iOffset );
}
Print( "--Global Variables--\n" );
ShowVariables( *m_pGlobalVar, Print );
Print( "--Local Variables--\n" );
for( LOCALVAR_CONTAINER::iterator l = m_pLocalVars->begin(); l != m_pLocalVars->end(); l++ )
{
Print( "<%s>\n", this->GetNameOfFunc( l->m_iFuncID ) );
ShowVariables( l->m_ArgContainer, Print );
ShowVariables( l->m_VarContainer, Print );
}
Print( "--Functions--\n" );
for( FUNC_CONTAINER::iterator k = m_pFunctions->begin(); k != m_pFunctions->end(); k++ )
{
Print( GetTypeStringOfFunc( int(&(*k)) ) );
Print( "\n" );
}
}
///////////////////////////////////////////////////////////////////////////////////
//

121
CryptoSource/ScriptEngine-MCF File/SymbolTable.h Normal file
View File

@@ -0,0 +1,121 @@
#ifndef _SymbolTable_H_
#define _SymbolTable_H_
#include "STL.h"
#include "BaseDef.h"
#include "Message.h"
#define SYSVAR_SWITCHTEMP "<SwitchTempVar>"
#define SYSVAR_FLOATUNIT "<FloatUnit>"
#define SYSVAR_FLOATTEMP "<FloatTemp>"
#define SYSVAR_TRUE "<True>"
#define SYSVAR_FALSE "<False>"
#define SYSVAR_CONVBUFFER "<ConvBuffer>"
///////////////////////////////////////////////////////////////////////////////////
// <09>Լ<EFBFBD><D4BC><EFBFBD> <20><><EFBFBD>ڴ<EFBFBD> 7<><37><EFBFBD><EFBFBD> <20>Ѿ <20>ȵȴ<C8B5>.
struct SFuncType
{
public:
unsigned long m_data;
public:
SFuncType();
SFuncType( unsigned long );
void SetArgType( int nth, eDataType arg ) { m_data |= ( 0x0000000f & arg ) << (nth*4); }
void SetReturnType( eDataType retType ) { m_data |= ( 0x0000000f & retType ) << 28; }
eDataType GetArgType( int nth ) { return (eDataType)(m_data >> (nth*4) & 0x0000000f); }
eDataType GetReturnType() { return (eDataType)(m_data >> 28 & 0x0000000f); }
int GetArgCount();
const char* ToString( const char * szFuncName );
bool operator==( const SFuncType & rhs ) { return (m_data & 0x0fffffff) == (rhs.m_data & 0x0fffffff); }
bool operator!=( const SFuncType & rhs ) { return (m_data & 0x0fffffff) != (rhs.m_data & 0x0fffffff); }
};
///////////////////////////////////////////////////////////////////////////////////
//
class CSymbolTable
{
public:
typedef map< int, int > OFFSETMAP;
typedef unsigned char byte;
typedef struct ConstInfo CONSTINFO;
typedef map<string,CONSTINFO> CONST_CONTAINER;
typedef struct VarInfo VARINFO;
typedef map<string,VARINFO> VAR_CONTAINER;
typedef struct SLocalVarInfo LOCALVARINFO;
typedef list<LOCALVARINFO> LOCALVAR_CONTAINER;
typedef pair<SFuncType, bool> FUNCINFO;
typedef multimap<string,FUNCINFO> FUNC_CONTAINER;
protected:
CONST_CONTAINER * m_pConstants;
VAR_CONTAINER * m_pGlobalVar;
LOCALVAR_CONTAINER* m_pLocalVars;
VAR_CONTAINER * m_pCurNameSpace;
VAR_CONTAINER * m_pNameSpace2; //CurNameSpace<63><65> <20><><EFBFBD><EFBFBD> <20>̷<EFBFBD>( CurNameSpace<63><65> ArgContainer<65><72> <20><> <20>̰<EFBFBD><CCB0><EFBFBD> VarContainer, VarContainer<65><72> <20><> ArgContainer )
FUNC_CONTAINER * m_pFunctions;
LOCALVARINFO * m_pCurrentLocalVar;
eDataType m_eCurrentType;
int m_iVarOffset, m_iVarOffsetGlobal;
int m_iOffsetFactor;
int m_iStringOffset;
public:
CSymbolTable();
~CSymbolTable();
void Create();
void Destroy();
int AddConst( const char * szName, eDataType type );
int AddArrVar( const char * szName, eDataType, int nArray );
int AddArrVar( const char * szName, int nArray ) { return AddArrVar( szName, m_eCurrentType, nArray ); }
int AddVar( const char * szName, eDataType type ) { return AddArrVar( szName, type, 1 ); }
int AddVar( const char * szName ) { return AddVar( szName, m_eCurrentType ); }
int AddFunc( bool hasDef, const char * szName, SFuncType );
void SetCurrentType( eDataType type ) { m_eCurrentType = type; }
eDataType GetCurrentType() { return m_eCurrentType; }
int FindConst( const char * szName );
int FindVar( const char * szName );
int FindFunc( const char * szname, SFuncType );
void BeginLocalNameSpace();
void EndLocalNameSpace( int ); //<2F><><EFBFBD>ڷδ<DAB7> <20>Լ<EFBFBD><D4BC><EFBFBD> ID<49><44> <20>Ѱ<EFBFBD><D1B0>ش<EFBFBD>.
void EndArgument();
const char* GetNameOfConst( int );
eDataType GetTypeOfConst( int );
int GetOffsetOfConst( int );
const char* GetNameOfVar( int );
eDataType GetTypeOfVar( int );
int GetCountOfVar( int );
int GetOffsetOfVar( int ); //<2F><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> EBP<42><50> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
//<2F><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ּҿ<D6BC> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
const char* GetNameOfFunc( int );
const char* GetTypeStringOfFunc( int );
SFuncType GetTypeOfFunc( int );
bool IsFuncDefined( int );
int GetLocalVarSize( int );
int GetGlobalVarSize();
int GetStringBufferSize();
void StringBuffer( void * );
void Show( MESSAGE_FUNCTION2 Print );
};
///////////////////////////////////////////////////////////////////////////////////
#endif

551
CryptoSource/ScriptEngine-MCF File/SyntaxTree.cpp Normal file
View File

@@ -0,0 +1,551 @@
#include "SyntaxTree.h"
#include "SymbolTable.h"
#include "lex.h"
#include <assert.h>
#include <set>
#include "GMMemory.h"
///////////////////////////////////////////////////////////////////////////////
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
CSyntaxTree * g_pSynTree = 0;
CSymbolTable * g_pSymbolTable = 0;
char szBuffer[4096];
///////////////////////////////////////////////////////////////////////////////
// Parser <20>Լ<EFBFBD>
void yyerror( char *msg )
{
CompilerMessage( msg );
}
extern "C" int yywrap(void) {
return 1;
}
////////////////////////////////////////////////////////////////////////////////
// <20><><EFBFBD><EFBFBD> <20>Լ<EFBFBD>
SNode::SNode( int line, eSyntaxType type, SNode * pNode1, SNode * pNode2, SNode * pNode3 )
: m_iLine( line ), m_eType( type ), m_SymbolID( 0 ), m_eReturnType( T_VOID )
{
m_ArrPtrChilds[0] = pNode1;
m_ArrPtrChilds[1] = pNode2;
m_ArrPtrChilds[2] = pNode3;
}
const char * SyntaxTypeName[] =
{
"TYPE_STATEMENT_LIST",
"TYPE_EMPTY_STATEMENT",
"TYPE_ERROR_STATEMENT",
"TYPE_EXPRESSION",
"TYPE_IF_STATEMENT",
"TYPE_IF_ELSE_STATEMENT",
"TYPE_SWITCH_STATEMENT",
"TYPE_SWITCH_CASES",
"TYPE_CASE_ONE",
"TYPE_DEFAULT",
"TYPE_FOR_STATEMENT",
"TYPE_WHILE_STATEMENT",
"TYPE_FOR_EXPRESSION",
"TYPE_BREAK_STATEMENT",
"TYPE_CONTINUE_STATEMENT",
"TYPE_RETURN_STATEMENT",
"TYPE_DECLARATION",
"TYPE_SPECIFIER_VOID",
"TYPE_SPECIFIER_INT",
"TYPE_SPECIFIER_FLOAT",
"TYPE_SPECIFIER_BOOL",
"TYPE_SPECIFIER_STRING",
"TYPE_VARIABLE",
"TYPE_DECLARATOR_LIST",
"TYPE_INIT_DECLARATION",
"TYPE_NORMAL_DECLARATION",
"TYPE_ARRAY_INITIALIZE",
"TYPE_ARRAY_INITIALIZE2",
"TYPE_ARRAY_DECLARATION",
"TYPE_FUNCTION_DECLARATION",
"TYPE_INITIALIZER_LIST",
"TYPE_ARGUMENT_DECLARATION_LIST",
"TYPE_ARGUMENT_DECLARATION",
"TYPE_FUNCTION_DEFINITION",
"TYPE_CONSTANT_EXPRESSION",
"TYPE_EXPRESSION_LIST",
"TYPE_ASSIGNMENT_EXPESSION",
"TYPE_OR_EXPRESSION",
"TYPE_AND_EXPRESSION",
"TYPE_NOT_EXPRESSION",
"TYPE_EQUALITY_EXPRESSION",
"TYPE_NOTEQAUL_EXPRESSION",
"TYPE_LESSTHAN_EXPRESSION",
"TYPE_MORETHAN_EXPRESSION",
"TYPE_LESSTHANOREQUAL_EXPRESSION",
"TYPE_MORETHANOREQUAL_EXPRESSION",
"TYPE_ADDITION_EXPRESSION",
"TYPE_SUBTRACTION_EXPRESSION",
"TYPE_MULTIPLICATION_EXPRESSION",
"TYPE_DIVISION_EXPRESSION",
"TYPE_REMINDER_EXPRESSION",
"TYPE_COMPOUND_ADDITION",
"TYPE_COMPOUND_SUBTRACTION",
"TYPE_COMPOUND_MULTIPLICATION",
"TYPE_COMPOUND_DIVISION",
"TYPE_COMPOUND_REMINDER",
"TYPE_PREFIXINCREMENT",
"TYPE_PREFIXDECREMENT",
"TYPE_ARRAY_INDEXING",
"TYPE_FUNCTION_CALL",
"TYPE_POSTFIXINCREMENT",
"TYPE_POSTFIXDECREMENT"
};
void SNode::Show( int level, MESSAGE_FUNCTION2 Print, CSymbolTable * pSymbolTable )
{
const char * DataTypeString[] = { "void", "bool", "int", "float", "string" };
int nl = level;
if (!this) return;
if( m_eType != TYPE_STATEMENT_LIST )
{
Print( itoa( m_iLine, szBuffer, 10 ) );
Print( ": " );
for ( int i = 0; i < level; i++ )
Print( " " );
Print( SyntaxTypeName[m_eType] );
switch( m_eType )
{
case TYPE_CONSTANT_EXPRESSION :
Print( " ( " );
Print( pSymbolTable->GetNameOfConst( m_SymbolID ) );
Print( " : " );
Print( DataTypeString[ pSymbolTable->GetTypeOfConst( m_SymbolID ) ] );
Print( " )" );
break;
case TYPE_INIT_DECLARATION :
case TYPE_NORMAL_DECLARATION :
case TYPE_ARRAY_INITIALIZE :
case TYPE_ARRAY_INITIALIZE2 :
case TYPE_ARRAY_DECLARATION :
case TYPE_ARGUMENT_DECLARATION :
case TYPE_VARIABLE :
case TYPE_PREFIXINCREMENT :
case TYPE_PREFIXDECREMENT :
case TYPE_POSTFIXINCREMENT :
case TYPE_POSTFIXDECREMENT :
case TYPE_COMPOUND_ADDITION :
case TYPE_COMPOUND_SUBTRACTION :
case TYPE_COMPOUND_MULTIPLICATION :
case TYPE_COMPOUND_DIVISION :
case TYPE_COMPOUND_REMINDER :
Print( " ( " );
Print( pSymbolTable->GetNameOfVar( m_SymbolID ) );
Print( " : " );
Print( DataTypeString[ pSymbolTable->GetTypeOfVar( m_SymbolID ) ] );
Print( " )" );
break;
}
nl++;
Print("\n");
}
for( int i = 0; m_ArrPtrChilds[i] != 0 && i < 3; i++ )
m_ArrPtrChilds[i]->Show( nl, Print, pSymbolTable );
}
bool SNode::SemanticCheck( CSymbolTable * pSymbolTable )
{
static eDataType tempType, tempType2;
switch( m_eType )
{
case TYPE_ARRAY_INDEXING :
//ù<><C3B9>° int<6E>϶<EFBFBD><CFB6><EFBFBD> <20><>ȿ<EFBFBD>ϰ<EFBFBD>, <20>ɺ<EFBFBD><C9BA><EFBFBD> Ÿ<>Կ<EFBFBD> <20><><EFBFBD><EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
if( m_ArrPtrChilds[0]->m_eReturnType != T_INT )
return false;
else
m_eReturnType = pSymbolTable->GetTypeOfVar( m_SymbolID );
break;
case TYPE_EXPRESSION :
m_eReturnType = m_ArrPtrChilds[0]->m_eReturnType;
break;
case TYPE_ARRAY_DECLARATION :
//ù<><C3B9>° <20><><EFBFBD>ϵ尡 int<6E>϶<EFBFBD><CFB6><EFBFBD> <20><>ȿ<EFBFBD>ϰ<EFBFBD>, <20>ɺ<EFBFBD> Ÿ<>Կ<EFBFBD> <20><><EFBFBD><EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
if( m_ArrPtrChilds[0]->m_eReturnType != T_INT )
return false;
else
m_eReturnType = pSymbolTable->GetTypeOfVar( m_SymbolID );
break;
case TYPE_ARRAY_INITIALIZE2 :
//<2F>ɺ<EFBFBD> Ÿ<>԰<EFBFBD> <20>ι<EFBFBD><CEB9><EFBFBD> <20><><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>˻<EFBFBD><CBBB>ϰ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20>ɺ<EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
//ù<><C3B9>° <20><><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> int<6E><74><EFBFBD>̾<EFBFBD><CCBE><EFBFBD> <20><>.
m_eReturnType = pSymbolTable->GetTypeOfVar( m_SymbolID );
if( m_ArrPtrChilds[0]->m_eReturnType != T_INT )
return false;
if( m_eReturnType != m_ArrPtrChilds[1]->m_eReturnType )
return false;
break;
case TYPE_ARRAY_INITIALIZE :
//<2F>ɺ<EFBFBD> Ÿ<>԰<EFBFBD> ù<><C3B9>° <20><><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><><EFBFBD>ƾ<EFBFBD> <20><>.
m_eReturnType = pSymbolTable->GetTypeOfVar( m_SymbolID );
if( m_eReturnType != m_ArrPtrChilds[0]->m_eReturnType )
return false;
break;
case TYPE_INIT_DECLARATION :
case TYPE_ASSIGNMENT_EXPRESSION :
//<2F>ɺ<EFBFBD> Ÿ<>԰<EFBFBD> ù<><C3B9>° <20><><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>˻<EFBFBD><CBBB>ϰ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20>ɺ<EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
m_eReturnType = pSymbolTable->GetTypeOfVar( m_SymbolID );
if( m_eReturnType == T_VOID )
return false;
if( m_eReturnType != m_ArrPtrChilds[0]->m_eReturnType )
{
if( m_eReturnType != T_STRING )
return false;
}
break;
case TYPE_INITIALIZER_LIST :
m_eReturnType = m_ArrPtrChilds[0]->m_eReturnType;
if( m_eReturnType == T_STRING )
{
if( m_ArrPtrChilds[1]->m_eReturnType == T_VOID )
return false;
}
else if( m_ArrPtrChilds[1]->m_eReturnType == T_STRING )
{
if( m_eReturnType == T_VOID )
return false;
m_eReturnType = T_STRING;
}
else
{
if( m_eReturnType != m_ArrPtrChilds[1]->m_eReturnType )
break;
}
break;
case TYPE_DECLARATOR_LIST :
//ù<><C3B9>° <20><><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> <20>ι<EFBFBD>° <20><><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>˻<EFBFBD><CBBB>ϰ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><> ù<><C3B9>° <20><><EFBFBD>ϵ<EFBFBD> Ÿ<><C5B8> <20><><EFBFBD><EFBFBD>
if( m_ArrPtrChilds[0]->m_eReturnType != m_ArrPtrChilds[1]->m_eReturnType )
return false;
else
m_eReturnType = m_ArrPtrChilds[0]->m_eReturnType;
break;
case TYPE_ADDITION_EXPRESSION :
m_eReturnType = m_ArrPtrChilds[0]->m_eReturnType;
if( m_eReturnType == T_STRING )
{
if( m_ArrPtrChilds[1]->m_eReturnType == T_VOID )
return false;
}
else if( m_ArrPtrChilds[1]->m_eReturnType == T_STRING )
{
if( m_eReturnType == T_VOID )
return false;
m_eReturnType = T_STRING;
}
else
{
if( m_eReturnType != m_ArrPtrChilds[1]->m_eReturnType )
return false;
}
break;
case TYPE_SUBTRACTION_EXPRESSION :
case TYPE_MULTIPLICATION_EXPRESSION :
case TYPE_DIVISION_EXPRESSION :
//ù<><C3B9>° <20><><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> <20>ι<EFBFBD>° <20><><EFBFBD>ϵ尡 <20>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ȿ, int<6E><74> float<61><74><EFBFBD><EFBFBD> <20>ƴ<EFBFBD> <20><><EFBFBD>쿡<EFBFBD><ECBFA1> <20><>ȿ
if( m_ArrPtrChilds[0]->m_eReturnType != m_ArrPtrChilds[1]->m_eReturnType )
{
return false;
}
m_eReturnType = m_ArrPtrChilds[0]->m_eReturnType;
if( m_eReturnType != T_INT && m_eReturnType != T_FLOAT )
return false;
break;
case TYPE_REMINDER_EXPRESSION :
//ù<><C3B9>° <20><><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> <20>ι<EFBFBD>° <20><><EFBFBD>ϵ尡 <20>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ȿ, int<6E><74><EFBFBD><EFBFBD> <20>ƴ<EFBFBD> <20><><EFBFBD>쿡<EFBFBD><ECBFA1> <20><>ȿ
if( m_ArrPtrChilds[0]->m_eReturnType != m_ArrPtrChilds[1]->m_eReturnType )
{
return false;
break;
}
m_eReturnType = m_ArrPtrChilds[0]->m_eReturnType;
if( m_eReturnType != T_INT )
return false;
break;
case TYPE_PREFIXINCREMENT :
case TYPE_PREFIXDECREMENT :
case TYPE_POSTFIXINCREMENT :
case TYPE_POSTFIXDECREMENT :
//int<6E><74> float<61><74><EFBFBD><EFBFBD> <20>ƴ<EFBFBD> <20><><EFBFBD>쿡<EFBFBD><ECBFA1> <20><>ȿ.
m_eReturnType = pSymbolTable->GetTypeOfVar( m_SymbolID );
if( m_eReturnType != T_INT && m_eReturnType != T_FLOAT )
return false;
break;
case TYPE_NORMAL_DECLARATION :
case TYPE_CONSTANT_EXPRESSION :
case TYPE_VARIABLE :
//<2F>ɺ<EFBFBD><C9BA><EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
m_eReturnType = pSymbolTable->GetTypeOfVar( m_SymbolID );
break;
case TYPE_NOT_EXPRESSION :
//ù<><C3B9>° <20><><EFBFBD>ϵ尡 BOOL<4F><4C><EFBFBD><EFBFBD> <20><><EFBFBD>쿡<EFBFBD><ECBFA1> <20><>ȿ<EFBFBD><C8BF>.
if( m_ArrPtrChilds[0]->m_eReturnType != T_BOOL )
return false;
else
m_eReturnType = T_BOOL;
break;
case TYPE_OR_EXPRESSION :
case TYPE_AND_EXPRESSION :
//ù<><C3B9>° <20><><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> <20>ι<EFBFBD>° <20><><EFBFBD>ϵ尡 <20><><EFBFBD><EFBFBD> bool<6F><6C><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȿ<EFBFBD><C8BF>.
m_eReturnType = T_BOOL;
if( m_ArrPtrChilds[0]->m_eReturnType != T_BOOL || m_ArrPtrChilds[1]->m_eReturnType != T_BOOL )
{
return false;
}
break;
case TYPE_EQUALITY_EXPRESSION :
case TYPE_NOTEQAUL_EXPRESSION :
//<2F><><EFBFBD>ʰ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><><EFBFBD>ƾ<EFBFBD> <20>ϸ<EFBFBD>, void<69><64> <20><><EFBFBD><EFBFBD> <20>ȵ<EFBFBD>.
tempType = m_ArrPtrChilds[0]->m_eReturnType;
if( tempType != m_ArrPtrChilds[1]->m_eReturnType || tempType == T_VOID )
return false;
else
m_eReturnType = T_BOOL;
break;
case TYPE_LESSTHAN_EXPRESSION :
case TYPE_MORETHAN_EXPRESSION :
case TYPE_LESSTHANOREQUAL_EXPRESSION :
case TYPE_MORETHANOREQUAL_EXPRESSION :
tempType = m_ArrPtrChilds[0]->m_eReturnType;
//ù <20><>° <20><><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> <20><> <20><>° <20><><EFBFBD>ϵ尡 <20>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ȿ, int, float<61><74><EFBFBD><EFBFBD> <20>ƴ<EFBFBD> <20><><EFBFBD>쿡<EFBFBD><ECBFA1> <20><><EFBFBD><EFBFBD>
if( tempType != m_ArrPtrChilds[1]->m_eReturnType )
return false;
if( tempType != T_INT && tempType != T_FLOAT )
return false;
m_eReturnType = T_BOOL;
break;
case TYPE_COMPOUND_ADDITION :
//<2F>ɺ<EFBFBD><C9BA><EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
m_eReturnType = pSymbolTable->GetTypeOfVar( m_SymbolID );
//int<6E><74> float, string<6E><67><EFBFBD><EFBFBD> <20>ƴ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ȿ
if( m_eReturnType != T_INT && m_eReturnType != T_FLOAT && m_eReturnType != T_STRING )
return false;
//<2F>ɺ<EFBFBD> Ÿ<>԰<EFBFBD> ù<><C3B9>° <20><><EFBFBD>ϵ尡 <20>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD> <20>ɺ<EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> string<6E><67> <20><><EFBFBD>쿡<EFBFBD><ECBFA1> <20><>ȿ
if( m_eReturnType != m_ArrPtrChilds[0]->m_eReturnType )
{
if( m_eReturnType != T_STRING )
return false;
else
{
if( m_ArrPtrChilds[0]->m_eReturnType == T_VOID )
return false;
}
}
break;
case TYPE_COMPOUND_SUBTRACTION :
case TYPE_COMPOUND_MULTIPLICATION :
case TYPE_COMPOUND_DIVISION :
//<2F>ɺ<EFBFBD><C9BA><EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
m_eReturnType = pSymbolTable->GetTypeOfVar( m_SymbolID );
//<2F>ɺ<EFBFBD> Ÿ<>԰<EFBFBD> ù<><C3B9>° <20><><EFBFBD>ϵ尡 <20>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ȿ, int<6E><74> float<61><74><EFBFBD><EFBFBD> <20>ƴ<EFBFBD> <20><><EFBFBD>쿡<EFBFBD><ECBFA1> <20><>ȿ
if( m_eReturnType != m_ArrPtrChilds[0]->m_eReturnType )
{
return false;
}
if( m_eReturnType != T_INT && m_eReturnType != T_FLOAT )
return false;
break;
case TYPE_COMPOUND_REMINDER :
//<2F>ɺ<EFBFBD><C9BA><EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
m_eReturnType = pSymbolTable->GetTypeOfVar( m_SymbolID );
//<2F>ɺ<EFBFBD> Ÿ<>԰<EFBFBD> ù<><C3B9>° <20><><EFBFBD>ϵ尡 <20>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ȿ, int<6E><74><EFBFBD><EFBFBD> <20>ƴ<EFBFBD> <20><><EFBFBD>쿡<EFBFBD><ECBFA1> <20><>ȿ
if( m_eReturnType != m_ArrPtrChilds[0]->m_eReturnType )
{
return false;
}
if( m_eReturnType != T_INT )
return false;
break;
case TYPE_FUNCTION_CALL :
{
SFuncType type = pSymbolTable->GetTypeOfFunc( m_SymbolID );
m_eReturnType = type.GetReturnType();
break;
}
case TYPE_SWITCH_STATEMENT :
{
if( m_ArrPtrChilds[0]->m_eReturnType != T_INT )
return false;
m_eReturnType = T_VOID;
break;
}
case TYPE_CASE_ONE :
{
if( m_ArrPtrChilds[0]->m_eReturnType != T_INT )
return false;
m_eReturnType = T_VOID;
break;
}
default :
m_eReturnType = T_VOID;
break;
}
return true;
}
CSyntaxTree::CSyntaxTree()
: m_pRoot( 0 )
, m_pSymbolTable( new CSymbolTable )
, m_pPtrStorage( new PTRSTORAGE )
{
}
CSyntaxTree::~CSyntaxTree()
{
Destroy();
delete m_pSymbolTable;
delete m_pPtrStorage;
}
void CSyntaxTree::Create( const char * szFileName )
{
FILE * fp = fopen( szFileName, "rt" );
if( fp == NULL )
return;
yylloc.first_line = 1;
Create( fp );
}
void CSyntaxTree::Create( FILE * fp )
{
yyin = fp;
g_pSynTree = this;
g_pSymbolTable = m_pSymbolTable;
g_pSymbolTable->Create();
yylloc.first_line = 1;
yyparse();
}
void CSyntaxTree::Destroy()
{
typedef PTRSTORAGE::iterator ITERATOR;
for( ITERATOR i = m_pPtrStorage->begin(); i != m_pPtrStorage->end(); i++ )
{
delete (*i);
}
m_pPtrStorage->clear();
m_pSymbolTable->Destroy();
fclose(yyin);
}
int CSyntaxTree::Insert( int line, eSyntaxType SynType, int childID1, int childID2, int childID3 )
{
SNode * pNode = new SNode( line, SynType, (SNode*)childID1, (SNode*)childID2, (SNode*)childID3 );
assert( m_pPtrStorage->insert( pNode ).second );
if( pNode->SemanticCheck( m_pSymbolTable ) == false )
ErrorMessage( pNode->m_iLine, "Ÿ<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ʽ<EFBFBD><CABD>ϴ<EFBFBD>~\n" );
return (int)pNode;
}
int CSyntaxTree::Insert( int line, int symbolID, eSyntaxType SynType, int childID1, int childID2, int childID3 )
{
SNode * pNode = new SNode( line, SynType, (SNode*)childID1, (SNode*)childID2, (SNode*)childID3 );
assert( m_pPtrStorage->insert( pNode ).second );
pNode->m_SymbolID = symbolID;
if( pNode->SemanticCheck( m_pSymbolTable ) == false )
CompilerMessage2( "Error(line %d) : Ÿ<><C5B8><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ʽ<EFBFBD><CABD>ϴ<EFBFBD>~\n", pNode->m_iLine );
return (int)pNode;
}
void CSyntaxTree::SetRoot( int nodeID )
{
if( nodeID != 0 )
{
if( m_pRoot != NULL )
{
Destroy();
}
m_pRoot = (SNode*)nodeID;
}
}
void CSyntaxTree::Show( MESSAGE_FUNCTION2 Print )
{
if( m_pRoot != NULL )
{
m_pRoot->Show( 0, Print, m_pSymbolTable );
}
}

135
CryptoSource/ScriptEngine-MCF File/SyntaxTree.h Normal file
View File

@@ -0,0 +1,135 @@
#ifndef _SyntaxTree_H_
#define _SyntaxTree_H_
#include "BaseDef.h"
#include "Message.h"
#include "STL.h"
#define MAXCHILD 3
class CSymbol;
class CSyntaxTree;
class CSymbolTable;
struct _iobuf;
typedef struct _iobuf FILE;
enum eSyntaxType
{
TYPE_STATEMENT_LIST = 0,
TYPE_EMPTY_STATEMENT,
TYPE_ERROR_STATEMENT,
TYPE_EXPRESSION,
TYPE_IF_STATEMENT,
TYPE_IF_ELSE_STATEMENT,
TYPE_SWITCH_STATEMENT,
TYPE_SWITCH_CASES,
TYPE_CASE_ONE,
TYPE_DEFAULT,
TYPE_FOR_STATEMENT,
TYPE_WHILE_STATEMENT,
TYPE_FOR_EXPRESSION,
TYPE_BREAK_STATEMENT,
TYPE_CONTINUE_STATEMENT,
TYPE_RETURN_STATEMENT,
TYPE_DECLARATION,
TYPE_SPECIFIER_VOID,
TYPE_SPECIFIER_INT,
TYPE_SPECIFIER_FLOAT,
TYPE_SPECIFIER_BOOL,
TYPE_SPECIFIER_STRING,
TYPE_VARIABLE,
TYPE_DECLARATOR_LIST,
TYPE_INIT_DECLARATION,
TYPE_NORMAL_DECLARATION,
TYPE_ARRAY_INITIALIZE,
TYPE_ARRAY_INITIALIZE2,
TYPE_ARRAY_DECLARATION,
TYPE_FUNCTION_DECLARATION,
TYPE_INITIALIZER_LIST,
TYPE_ARGUMENT_DECLARATION_LIST,
TYPE_ARGUMENT_DECLARATION,
TYPE_FUNCTION_DEFINITION,
TYPE_CONSTANT_EXPRESSION,
TYPE_EXPRESSION_LIST,
TYPE_ASSIGNMENT_EXPRESSION,
TYPE_OR_EXPRESSION,
TYPE_AND_EXPRESSION,
TYPE_NOT_EXPRESSION,
TYPE_EQUALITY_EXPRESSION,
TYPE_NOTEQAUL_EXPRESSION,
TYPE_LESSTHAN_EXPRESSION,
TYPE_MORETHAN_EXPRESSION,
TYPE_LESSTHANOREQUAL_EXPRESSION,
TYPE_MORETHANOREQUAL_EXPRESSION,
TYPE_ADDITION_EXPRESSION,
TYPE_SUBTRACTION_EXPRESSION,
TYPE_MULTIPLICATION_EXPRESSION,
TYPE_DIVISION_EXPRESSION,
TYPE_REMINDER_EXPRESSION,
TYPE_COMPOUND_ADDITION,
TYPE_COMPOUND_SUBTRACTION,
TYPE_COMPOUND_MULTIPLICATION,
TYPE_COMPOUND_DIVISION,
TYPE_COMPOUND_REMINDER,
TYPE_PREFIXINCREMENT,
TYPE_PREFIXDECREMENT,
TYPE_ARRAY_INDEXING,
TYPE_FUNCTION_CALL,
TYPE_POSTFIXINCREMENT,
TYPE_POSTFIXDECREMENT = 61,
};
///////////////////////////////////////////////////////////////////////////////////
//
struct SNode
{
int m_iLine;
eSyntaxType m_eType;
SNode * m_ArrPtrChilds[MAXCHILD];
int m_SymbolID;
eDataType m_eReturnType;
public:
SNode( int, eSyntaxType, SNode *, SNode *, SNode * );
void Show( int, MESSAGE_FUNCTION2, CSymbolTable * );
bool SemanticCheck( CSymbolTable * );
};
class CSyntaxTree
{
protected:
SNode * m_pRoot;
CSymbolTable * m_pSymbolTable;
typedef set<void *> PTRSTORAGE;
PTRSTORAGE * m_pPtrStorage;
public:
CSyntaxTree();
~CSyntaxTree();
void Create( const char * ); //Ư<><C6AF> <20><>ũ<EFBFBD><C5A9>Ʈ ȭ<><C8AD><EFBFBD><EFBFBD> <20>о SyntaxƮ<78><C6AE><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
void Create( FILE * );
void Destroy();
int Insert( int line, eSyntaxType, int childID1 = 0, int childID2 = 0, int childID3 = 0 );
int Insert( int line, int symbolID, eSyntaxType, int childID1 = 0, int childID2 = 0, int childID3 = 0 );
void SetRoot( int nodeID );
void Show( MESSAGE_FUNCTION2 );
CSymbolTable * GetSymbolTable() { return m_pSymbolTable; }
SNode * GetRoot() { return m_pRoot; }
};
///////////////////////////////////////////////////////////////////////////////////
#endif

680
CryptoSource/ScriptEngine-MCF File/VirtualMachine.cpp Normal file
View File

@@ -0,0 +1,680 @@
#include "VirtualMachine.h"
#include "IntermediateCode.h"
#include "SymbolTable.h"
#include "RelocTable.h"
#include <map>
#include <string>
#include <stdarg.h>
#include <fstream>
#include <set>
#include "GMMemory.h"
typedef unsigned char byte;
static const int xor_key_value = 0x82fac623;
///////////////////////////////////////////////////////////////////////////////////
//
CVirtualMachine::ALLOCATED * pAllocatedPtrs = NULL;
void RegisterAllocatedMemory( void * p )
{
pAllocatedPtrs->insert( p );
// CompilerMessage2( "[[[Register Allocated Memory : %d]]]", int(p) );
}
void UnregisterAllocatedMemory( void * p )
{
pAllocatedPtrs->erase( p );
// CompilerMessage2( "[[[Unregister Allocated Memory : %d]]]", int(p) );
}
///////////////////////////////////////////////////////////////////////////////////
//
ScriptFunc::ScriptFunc( void * pfunc, long type )
: pFunc( pfunc ), Type( type )
{}
CVirtualMachine::CVirtualMachine()
: m_pBuffer( NULL )
, m_pGlobalVars( NULL )
, m_pStringBuffer( NULL )
, m_pCodeBuffer( NULL )
, m_iCodeSize( 0 )
, m_pFunctionMap( new FUNCMAP )
, m_pRelocation( new CRelocTable )
, m_bRelocated( false )
, m_pAllocatedPtrs( new ALLOCATED )
, m_pSysVarBuffer( new char[32] )
{
pAllocatedPtrs = m_pAllocatedPtrs;
}
CVirtualMachine::~CVirtualMachine()
{
Destroy();
delete m_pFunctionMap;
delete m_pRelocation;
delete m_pAllocatedPtrs;
delete [] m_pSysVarBuffer;
}
///////////////////////////////////////////////////////////////////////////////////
//
void Data_XOR( char * pDataBuf, unsigned size, int keyValue )
{
int * pIntData = (int*)pDataBuf;
int IntDataSize = size/sizeof(int);
for( int i = 0; i < IntDataSize; i++ )
{
pIntData[i] = pIntData[i] ^ keyValue;
}
}
///////////////////////////////////////////////////////////////////////////////////
//
void File_XOR( const char * szSrcFilename, const char * szDstFilename, int keyValue )
{
fstream infile( szSrcFilename, ios_base::in | ios_base::binary );
if( !infile.is_open() )
{
ErrorMessage2( "ȭ<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>.(At File_XOR) : %s", szSrcFilename );
}
fstream outfile( szDstFilename, ios_base::out | ios_base::binary );
if( !outfile.is_open() )
{
ErrorMessage2( "ȭ<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>.(At File_XOR) : %s", szDstFilename );
}
infile.seekg( 0, ios_base::end );
unsigned filesize = infile.tellg();
infile.seekg( 0, ios_base::beg );
char * pDataBuf = new char[ filesize ];
infile.read( pDataBuf, filesize );
Data_XOR( pDataBuf, filesize, keyValue );
outfile.write( pDataBuf, filesize );
delete [] pDataBuf;
}
///////////////////////////////////////////////////////////////////////////////////
//
void CVirtualMachine::Create( const char * szFilename )
{
ifstream file( szFilename, ios::binary | ios::in );
if( !file.is_open() )
ErrorMessage2( "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ȭ<><C8AD><EFBFBD><EFBFBD> ã<><C3A3> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. (At CVirtualMachine::Create) : %s", szFilename );
file.seekg( 0, ios_base::end );
unsigned filesize = file.tellg();
file.seekg( 0, ios_base::beg );
char * pBuf = new char[filesize];
int xor_key_valueT = xor_key_value^0x601f1ac4;
file.read( pBuf, filesize );
Data_XOR( pBuf, filesize, xor_key_valueT );
Create( pBuf, filesize );
delete [] pBuf;
file.close();
/*
Destroy();
ifstream file( szFilename, ios::binary | ios::in );
if( !file.is_open() )
ErrorMessage2( "<22><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ȭ<><C8AD><EFBFBD><EFBFBD> ã<><C3A3> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. (At CVirtualMachine::Create) : %s", szFilename );
m_pRelocation->Create( file );
int GlobalVarBufferSize, StringBufferSize, TotalBufferSize;
file.read( (char*)&GlobalVarBufferSize, sizeof(int) );
file.read( (char*)&StringBufferSize, sizeof(int) );
file.read( (char*)&m_iCodeSize, sizeof(int) );
TotalBufferSize = GlobalVarBufferSize + StringBufferSize + m_iCodeSize;
m_pGlobalVars = m_pBuffer = new char[TotalBufferSize];
m_pStringBuffer = ((byte*)m_pGlobalVars) + GlobalVarBufferSize;
m_pCodeBuffer = ((byte*)m_pStringBuffer) + StringBufferSize;
memset( m_pGlobalVars, 0, GlobalVarBufferSize );
file.read( (char*)m_pStringBuffer, StringBufferSize );
file.read( (char*)m_pCodeBuffer, m_iCodeSize );
long FuncMapSize;
file.read( (char*)&FuncMapSize, sizeof(long) );
string str;
char endChar;
long type, offset;
for( int i = 0; i < FuncMapSize; i++ )
{
file >> str;
file.read( &endChar, 1 );
file.read( (char*)&type, sizeof(long) );
file.read( (char*)&offset, sizeof(long) );
offset += long( m_pCodeBuffer );
m_pFunctionMap->insert( FUNCMAP::value_type( str, FUNCINFO( type, (void*)offset ) ) );
}
file.read( (char*)m_pSysVarOffset, sizeof(int)*4 );
file.close();
m_pRelocation->Relocate( m_pGlobalVars, m_pStringBuffer, m_pCodeBuffer );
m_bRelocated = true;
SetSysVars();
*/
}
#define READ_INT( p, var ) { var = *((int*)p); p += sizeof(int); }
#define READ_LONG( p, var ) { var = *((long*)p); p += sizeof(long); }
#define READ_CHAR( p, var ) { var = *p; p += sizeof(char); }
const char * ReadLine( const char * szBuf, char * szOut, char endChar = '\0' )
{
const char * p = szBuf;
char * pDst = szOut;
while( *p != endChar )
{
*pDst = *p;
p++, pDst++;
}
*pDst = '\0';
return p + 1;
}
void CVirtualMachine::Create( const void * pDataBuf, unsigned DataSize )
{
Destroy();
const char * pData = (const char*)m_pRelocation->Create( pDataBuf, DataSize );
int GlobalVarBufferSize, StringBufferSize, TotalBufferSize;
READ_INT( pData, GlobalVarBufferSize );
READ_INT( pData, StringBufferSize );
READ_INT( pData, m_iCodeSize );
TotalBufferSize = GlobalVarBufferSize + StringBufferSize + m_iCodeSize;
m_pGlobalVars = m_pBuffer = new char[TotalBufferSize];
m_pStringBuffer = ((byte*)m_pGlobalVars) + GlobalVarBufferSize;
m_pCodeBuffer = ((byte*)m_pStringBuffer) + StringBufferSize;
memset( m_pGlobalVars, 0, GlobalVarBufferSize );
memcpy( m_pStringBuffer, pData, StringBufferSize );
pData += StringBufferSize;
memcpy( m_pCodeBuffer, pData, m_iCodeSize );
pData += m_iCodeSize;
long FuncMapSize;
READ_LONG( pData, FuncMapSize );
long type, offset;
for( int i = 0; i < FuncMapSize; i++ )
{
char szStr[256];
pData = ReadLine( pData, szStr, '\n' );
READ_LONG( pData, type );
READ_LONG( pData, offset );
offset += long( m_pCodeBuffer );
m_pFunctionMap->insert( FUNCMAP::value_type( szStr, FUNCINFO( type, (void*)offset ) ) );
}
memcpy( m_pSysVarOffset, pData, sizeof(int)*4 );
pData += sizeof(int)*4;
m_pRelocation->Relocate( m_pGlobalVars, m_pStringBuffer, m_pCodeBuffer );
m_bRelocated = true;
SetSysVars();
}
void CVirtualMachine::Create( CIntermediateCode & IMCode, CSymbolTable & SymbolTable )
{
Destroy();
m_iCodeSize = IMCode.Addressing( 0 );
int GlobalVarsSize = SymbolTable.GetGlobalVarSize();
int StringBufferSize = SymbolTable.GetStringBufferSize();
int BufSize = GlobalVarsSize + StringBufferSize + m_iCodeSize;
m_pGlobalVars = m_pBuffer = new char[ BufSize ];
memset( m_pGlobalVars, 0, GlobalVarsSize );
m_pStringBuffer = (char*)m_pBuffer + GlobalVarsSize;
SymbolTable.StringBuffer( m_pStringBuffer );
m_pCodeBuffer = (char*)m_pStringBuffer + StringBufferSize;
if( IMCode.ToMachineCode( m_pCodeBuffer, m_pRelocation ) != m_iCodeSize )
ScriptSystemError( "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><20>ٸ<EFBFBD><D9B8>ϴ<EFBFBD>.( at CVirtualMachine::Create )" );
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̼<EFBFBD>
m_pRelocation->Relocate( m_pGlobalVars, m_pStringBuffer, m_pCodeBuffer );
m_bRelocated = true;
//<2F>Լ<EFBFBD> <20><><EFBFBD>̺<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
typedef CIntermediateCode::FUNCTABLE FUNCTABLE;
FUNCTABLE & funcTable = IMCode.GetFuncTable();
byte * pCode = (byte*)m_pCodeBuffer;
for( FUNCTABLE::iterator i = funcTable.begin(); i != funcTable.end(); i++ )
{
const char * pFuncName = SymbolTable.GetNameOfFunc( i->first );
SFuncType FuncType = SymbolTable.GetTypeOfFunc( i->first );
void * pFunc = pCode + i->second;
m_pFunctionMap->insert( FUNCMAP::value_type( pFuncName, FUNCINFO( FuncType, pFunc ) ) );
}
m_pSysVarOffset[0] = SymbolTable.GetOffsetOfVar( SymbolTable.FindVar( SYSVAR_FLOATUNIT ) );
m_pSysVarOffset[1] = SymbolTable.GetOffsetOfVar( SymbolTable.FindVar( SYSVAR_TRUE ) );
m_pSysVarOffset[2] = SymbolTable.GetOffsetOfVar( SymbolTable.FindVar( SYSVAR_FALSE ) );
m_pSysVarOffset[3] = SymbolTable.GetOffsetOfVar( SymbolTable.FindVar( SYSVAR_CONVBUFFER ) );
SetSysVars();
}
void CVirtualMachine::SetSysVars()
{
int * pVarBuffer = (int*)m_pGlobalVars;
float floatunit = 1.0f;
pVarBuffer[ m_pSysVarOffset[0]/4 ] = *((int*)&floatunit); //0x3f800000
pVarBuffer[ m_pSysVarOffset[1]/4 ] = (int)strcpy( m_pSysVarBuffer, "true" );
pVarBuffer[ m_pSysVarOffset[2]/4 ] = (int)strcpy( m_pSysVarBuffer + 5, "false" );
pVarBuffer[ m_pSysVarOffset[3]/4 ] = int(m_pSysVarBuffer + 11);
}
void CVirtualMachine::Destroy()
{
delete [] m_pBuffer;
m_pBuffer = m_pGlobalVars = m_pStringBuffer = m_pCodeBuffer = NULL;
m_iCodeSize = 0;
m_pFunctionMap->clear();
m_pRelocation->Destroy();
for( ALLOCATED::iterator i = m_pAllocatedPtrs->begin(); i != m_pAllocatedPtrs->end(); i++ )
{
free( *i );
// CompilerMessage2( "[[[free : %d]]]", int(*i) );
}
m_pAllocatedPtrs->clear();
}
///////////////////////////////////////////////////////////////////////////////////
// ȭ<><C8AD> <20><><EFBFBD><EFBFBD>
// 1. <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> Relocation <20><><EFBFBD><EFBFBD>(int)
// 2. <20><><EFBFBD>ڿ<EFBFBD> <20><><EFBFBD><EFBFBD> Relocation <20><><EFBFBD><EFBFBD>(int)
// 3. <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> Relocation Table
// 4. <20><><EFBFBD>ڿ<EFBFBD> <20><><EFBFBD><EFBFBD> Relocation Table
// 5. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ũ<><C5A9>(int)
// 6. <20><><EFBFBD>ڿ<EFBFBD> <20><><EFBFBD><EFBFBD> ũ<><C5A9>(int)
// 7. <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD> ũ<><C5A9>(int)
// 8. <20><><EFBFBD>ڿ<EFBFBD> <20><><EFBFBD><EFBFBD>
// 9. <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD>
// 10. <20>Լ<EFBFBD><D4BC><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// 11. < <20><><EFBFBD>ڿ<EFBFBD>, <20>Լ<EFBFBD> Ÿ<><C5B8>(long), <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(long) > * <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
///////////////////////////////////////////////////////////////////////////////////
bool CVirtualMachine::Save( const char * szFilename )
{
if( m_pBuffer == NULL || m_pGlobalVars == NULL || m_pStringBuffer == NULL || m_pCodeBuffer == NULL )
{
return false;
}
ofstream file( szFilename, ios::binary | ios::out );
if( !file.is_open() )
{
return false;
}
if( m_bRelocated )
{
m_pRelocation->Unlocate( m_pGlobalVars, m_pStringBuffer, m_pCodeBuffer );
m_bRelocated = false;
}
m_pRelocation->Save( file );
int GlobalVarBufferSize = ((byte*)m_pStringBuffer) - ((byte*)m_pGlobalVars);
int StringBufferSize = ((byte*)m_pCodeBuffer) - ((byte*)m_pStringBuffer);
file.write( (const char*)&GlobalVarBufferSize, sizeof(int) );
file.write( (const char*)&StringBufferSize, sizeof(int) );
file.write( (const char*)&m_iCodeSize, sizeof(int) );
file.write( (const char*)m_pStringBuffer, StringBufferSize );
file.write( (const char*)m_pCodeBuffer, m_iCodeSize );
int FuncMapSize = m_pFunctionMap->size();
file.write( (const char*)&FuncMapSize, sizeof(int) );
for( FUNCMAP::iterator it = m_pFunctionMap->begin(); it != m_pFunctionMap->end(); it++ )
{
file << it->first << '\n';
file.write( (const char*)&it->second.first.m_data, sizeof(long) );
long offset = long( it->second.second ) - long(m_pCodeBuffer);
file.write( (const char*)&offset, sizeof(long) );
}
file.write( (const char*)m_pSysVarOffset, sizeof(int)*4 );
file.close();
m_pRelocation->Relocate( m_pGlobalVars, m_pStringBuffer, m_pCodeBuffer );
char tempFilename[256];
sprintf( tempFilename, "%s+", szFilename );
int xor_key_valueT = xor_key_value^0x601f1ac4;
File_XOR( szFilename, tempFilename, xor_key_valueT );
remove( szFilename );
rename( tempFilename, szFilename );
return true;
}
void CVirtualMachine::Execute()
{
void * pCodeBuffer = m_pCodeBuffer;
__asm call pCodeBuffer;
}
SFuncType MakeFuncType( eDataType returnType, va_list args )
{
SFuncType type;
type.SetReturnType( returnType );
for( int i = 0; i < 7; i++ )
{
eDataType dataType = va_arg( args, eDataType );
if( dataType == T_VOID )
break;
type.SetArgType( i, dataType );
}
return type;
}
void * GetFuncPtr( CVirtualMachine::FUNCMAP & funcMap, const char * szFuncName, SFuncType funcType )
{
typedef CVirtualMachine::FUNCMAP::iterator iterator;
pair< iterator, iterator > result = funcMap.equal_range( szFuncName );
while( result.first != result.second )
{
SFuncType ftype = result.first->second.first;
if( ftype == funcType )
{
return result.first->second.second;
}
result.first++;
}
return NULL;
}
union long_byte
{
long longValue;
char byteValue[4];
};
///////////////////////////////////////////////////////////////////////////////////
//Native<76>Լ<EFBFBD><D4BC><EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ<EFBFBD><C6AE> <20><><EFBFBD>ε<EFBFBD> <20>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD>
//
//<2F><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> : <20>Լ<EFBFBD><D4BC><EFBFBD> <20><> <20><> <20><>ġ<EFBFBD><C4A1> <20>Ѵ<EFBFBD>. ( <20><><EFBFBD><EFBFBD> <20>ӵ<EFBFBD><D3B5><EFBFBD> <20><> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. )
// 1-1. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ְ<EFBFBD>, <20><><EFBFBD>ǰ<EFBFBD> <20><><EFBFBD><EFBFBD> <20>Լ<EFBFBD><D4BC>鸸 <20>Լ<EFBFBD> <20>ڵ忡<DAB5><E5BFA1> ó<><C3B3> <20>κп<CEBA> 5<><35><EFBFBD><EFBFBD>Ʈ <20>̻<EFBFBD><CCBB><EFBFBD> <20><><EFBFBD><EFBFBD>(nop)<29><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD>.
// 1-2. RegisterFunction<6F><6E> ȣ<><C8A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> 1-1<><31><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>κп<CEBA> call <native function><3E><> ret<65><74> <20><><EFBFBD><EFBFBD><EFBFBD>ִ´<D6B4>.
// <09>󸶳<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>? <20><><EFBFBD><EFBFBD> <20>Լ<EFBFBD><D4BC><EFBFBD> nop<6F><70> 2<><32> <20>̻<EFBFBD> <20>߰<EFBFBD><DFB0>ǰ<EFBFBD>, native call<6C><6C> <20><><EFBFBD><EFBFBD> ȣ<><C8A3><EFBFBD><EFBFBD> <20>ȴ<EFBFBD>.
// Empty Function<6F><6E> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
//
//<2F>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD> : <20><><EFBFBD><EFBFBD><EFBFBD>Ϸ<EFBFBD><CFB7><EFBFBD> <20>Լ<EFBFBD><D4BC><EFBFBD> ȣ<><C8A3><EFBFBD>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD> <20>κ<EFBFBD><CEBA><EFBFBD> <20>Լ<EFBFBD> <20>ּҸ<D6BC> <20>ٲ۴<D9B2>.( <20><><EFBFBD><EFBFBD> <20>ӵ<EFBFBD><D3B5><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. )
// 2-1. <20><><EFBFBD><EFBFBD> <20>Լ<EFBFBD> ȣ<><C8A3> <20>κ<EFBFBD><CEBA><EFBFBD> Relocation Tableó<65><C3B3> call table<6C><65> <20><><EFBFBD><EFBFBD><EFBFBD>صд<D8B5>.
// 2-2. RegisterFunction<6F><6E> ȣ<><C8A3><EFBFBD>Ǿ<EFBFBD><C7BE><EFBFBD> <20><> call table<6C><65> <20><><EFBFBD><EFBFBD><EFBFBD>ؼ<EFBFBD> call<6C>ϰ<EFBFBD> <20>ִ<EFBFBD> <20>κ<EFBFBD><CEBA><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ٲ۴<D9B2>.
// call table<6C><65>? map< string, pair< SFuncType, vector<int> > >
///////////////////////////////////////////////////////////////////////////////////
void CVirtualMachine::RegisterFunction( ANY_FUNCTION FuncPtr, eDataType returnType, const char * szFuncName, ... )
{
va_list args;
va_start( args, szFuncName );
RegisterFunction( FuncPtr, returnType, szFuncName, args );
}
void CVirtualMachine::RegisterFunction( ANY_FUNCTION FuncPtr, eDataType returnType, const char * szFuncName, va_list args )
{
SFuncType funcType = MakeFuncType( returnType, args );
byte * pFunc = (byte*)GetFuncPtr( *m_pFunctionMap, szFuncName, funcType );
if( pFunc == NULL )
ErrorMessage2( "<EFBFBD>Լ<EFBFBD> <20><><EFBFBD>Ͽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>߽<EFBFBD><DFBD>ϴ<EFBFBD>. <20>Լ<EFBFBD><D4BC><EFBFBD> ã<><C3A3> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. : %s", funcType.ToString( szFuncName ) );
if( pFunc[3] != 0x90 ) //nop<6F><70> <20>ƴ<EFBFBD> <20><>
ScriptSystemError( "RegisterFunction Error!!( at CVirtualMachine::RegisterFunction )" );
int nArg = funcType.GetArgCount();
pFunc += 3;
for( int i = 0; i < nArg; i++ )
{
*(pFunc++) = 0xff;
*(pFunc++) = 0x75;
*(pFunc++) = 0xff & (8+4*i);
}
*(pFunc++) = 0xe8;
long_byte FuncOffset;
FuncOffset.longValue = long(FuncPtr) - long(pFunc+4);
*(pFunc++) = FuncOffset.byteValue[0];
*(pFunc++) = FuncOffset.byteValue[1];
*(pFunc++) = FuncOffset.byteValue[2];
*(pFunc++) = FuncOffset.byteValue[3];
}
ScriptFunc CVirtualMachine::GetScriptFunction( eDataType returnType, const char * szFuncName, ... )
{
va_list args;
va_start( args, szFuncName );
return GetScriptFunction( returnType, szFuncName, args );
}
ScriptFunc CVirtualMachine::GetScriptFunction( eDataType returnType, const char * szFuncName, va_list args )
{
SFuncType funcType = MakeFuncType( returnType, args );
void * pFunc = GetFuncPtr( *m_pFunctionMap, szFuncName, funcType );
if( pFunc == NULL )
ErrorMessage2( "<EFBFBD><EFBFBD>ũ<EFBFBD><EFBFBD>Ʈ <20>Լ<EFBFBD><D4BC><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>µ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>߽<EFBFBD><DFBD>ϴ<EFBFBD>. <20>Լ<EFBFBD><D4BC><EFBFBD> ã<><C3A3> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. : %s", funcType.ToString( szFuncName ) );
return ScriptFunc( pFunc, funcType.m_data );
}
void * CVirtualMachine::CallScriptFunction( ScriptFunc Func )
{
__asm call Func.pFunc;
}
void * CVirtualMachine::CallScriptFunction( ScriptFunc Func, AnyData arg1 )
{
__asm
{
push arg1;
call Func.pFunc;
add esp, 4;
}
}
void * CVirtualMachine::CallScriptFunction( ScriptFunc Func, AnyData arg1, AnyData arg2 )
{
__asm
{
push arg2;
push arg1;
call Func.pFunc;
add esp, 8;
}
}
void * CVirtualMachine::CallScriptFunction( ScriptFunc Func, AnyData arg1, AnyData arg2, AnyData arg3 )
{
__asm
{
push arg3;
push arg2;
push arg1;
call Func.pFunc;
add esp, 12;
}
}
void * CVirtualMachine::CallScriptFunction( ScriptFunc Func, AnyData arg1, AnyData arg2, AnyData arg3, AnyData arg4 )
{
__asm
{
push arg4;
push arg3;
push arg2;
push arg1;
call Func.pFunc;
add esp, 16;
}
}
void * CVirtualMachine::CallScriptFunction( ScriptFunc Func, AnyData args[], int nArgs )
{
for( int i = nArgs - 1; i >= 0; i-- )
__asm push args[i];
__asm call Func.pFunc;
nArgs *= 4;
__asm add esp, nArgs;
}
void * CVirtualMachine::CallScriptFunction( ScriptFunc Func, AnyData arg0, AnyData arg1, AnyData arg2, AnyData arg3, AnyData arg4,
AnyData arg5, AnyData arg6, AnyData arg7, AnyData arg8, AnyData arg9,
AnyData arg10, AnyData arg11, AnyData arg12, AnyData arg13, AnyData arg14,
AnyData arg15, AnyData arg16, AnyData arg17, AnyData arg18, AnyData arg19,
AnyData arg20, AnyData arg21, AnyData arg22, AnyData arg23, AnyData arg24,
AnyData arg25, AnyData arg26, AnyData arg27, AnyData arg28, AnyData arg29,
AnyData arg30, AnyData arg31, AnyData arg32, AnyData arg33, AnyData arg34 )
{
__asm
{
push arg34;
push arg33;
push arg32;
push arg31;
push arg30;
push arg29;
push arg28;
push arg27;
push arg26;
push arg25;
push arg24;
push arg23;
push arg22;
push arg21;
push arg20;
push arg19;
push arg18;
push arg17;
push arg16;
push arg15;
push arg14;
push arg13;
push arg12;
push arg11;
push arg10;
push arg9;
push arg8;
push arg7;
push arg6;
push arg5;
push arg4;
push arg3;
push arg2;
push arg1;
push arg0;
call Func.pFunc;
add esp, 140;
}
}
/*
int CVirtualMachine::CallScriptFunction( ScriptFunc Func, va_list args )
{
int nArgs = SFuncType( Func.Type ).GetArgCount();
for( int i = 0; i < nArgs; i++ )
{
AnyData data = va_arg( args, AnyData );
__asm push data;
}
void * pFunc = Func.pFunc;
int n = nArgs * 4;
__asm
{
call pFunc;
add esp, n;
}
}
int CVirtualMachine::CallScriptFunction( ScriptFunc Func, ... )
{
va_list args;
va_start( args, Func );
return CallScriptFunction( Func, args );
}
*/

84
CryptoSource/ScriptEngine-MCF File/VirtualMachine.h Normal file
View File

@@ -0,0 +1,84 @@
#ifndef _VirtualMachine_H_
#define _VirtualMachine_H_
#include "STL.h"
#include "BaseDef.h"
class CIntermediateCode;
class CSymbolTable;
struct SFuncType;
class CRelocTable;
typedef char * va_list;
///////////////////////////////////////////////////////////////////////////////////
//
void RegisterAllocatedMemory( void * );
void UnregisterAllocatedMemory( void * );
///////////////////////////////////////////////////////////////////////////////////
//
class CVirtualMachine
{
public:
typedef pair<SFuncType, void*> FUNCINFO;
typedef multimap<string, FUNCINFO> FUNCMAP;
typedef set<void*> ALLOCATED;
protected:
void * m_pBuffer;
void * m_pGlobalVars; //<2F><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
void * m_pStringBuffer; //m_pBuffer<65><72><EFBFBD><EFBFBD> Const<73><74><EFBFBD>۰<EFBFBD> <20><><EFBFBD>۵Ǵ<DBB5> <20><><EFBFBD><EFBFBD>
void * m_pCodeBuffer; //m_pBuffer<65><72><EFBFBD><EFBFBD> Code<64><65><EFBFBD>۰<EFBFBD> <20><><EFBFBD>۵Ǵ<DBB5> <20><><EFBFBD><EFBFBD>
int m_iCodeSize;
FUNCMAP * m_pFunctionMap; //Ŀ<><C4BF><EFBFBD><EFBFBD> <20>Լ<EFBFBD><D4BC><EFBFBD> <20≯<EFBFBD>, <20><><EFBFBD>ڿ<EFBFBD> <20>Լ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̺<EFBFBD>
CRelocTable * m_pRelocation; //Relocation Table
int m_pSysVarOffset[4]; //<2F>ý<EFBFBD><C3BD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>鿡 <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
char * m_pSysVarBuffer;
bool m_bRelocated;
ALLOCATED * m_pAllocatedPtrs;
protected:
void SetSysVars();
public:
CVirtualMachine();
~CVirtualMachine();
void Create( const char * szFilename );
void Create( const void * pDataBuf, unsigned DataSize ); //<2F>޸<EFBFBD><DEB8><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>κ<EFBFBD><CEBA><EFBFBD> <20><><EFBFBD><EFBFBD>
void Create( CIntermediateCode &, CSymbolTable & );
void Destroy();
bool Save( const char * szFilename );
void Execute();
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> T_VOID<49><44> <20><> <20>־<EFBFBD><D6BE>־<EFBFBD><D6BE><EFBFBD> <20><>!!!
void RegisterFunction( ANY_FUNCTION, eDataType returnType, const char *, ... );
void RegisterFunction( ANY_FUNCTION, eDataType, const char *, va_list );
ScriptFunc GetScriptFunction( eDataType returnType, const char *, ... );
ScriptFunc GetScriptFunction( eDataType, const char *, va_list );
void * CallScriptFunction( ScriptFunc );
void * CallScriptFunction( ScriptFunc, AnyData );
void * CallScriptFunction( ScriptFunc, AnyData, AnyData );
void * CallScriptFunction( ScriptFunc, AnyData, AnyData, AnyData );
void * CallScriptFunction( ScriptFunc, AnyData, AnyData, AnyData, AnyData );
void * CallScriptFunction( ScriptFunc, AnyData args[], int nArgs );
void * CallScriptFunction( ScriptFunc Func, AnyData arg0, AnyData arg1, AnyData arg2, AnyData arg3, AnyData arg4,
AnyData arg5, AnyData arg6, AnyData arg7, AnyData arg8, AnyData arg9,
AnyData arg10, AnyData arg11, AnyData arg12, AnyData arg13, AnyData arg14,
AnyData arg15, AnyData arg16, AnyData arg17, AnyData arg18, AnyData arg19,
AnyData arg20, AnyData arg21, AnyData arg22, AnyData arg23, AnyData arg24,
AnyData arg25, AnyData arg26, AnyData arg27, AnyData arg28, AnyData arg29,
AnyData arg30, AnyData arg31, AnyData arg32, AnyData arg33, AnyData arg34 ) ;
// int CallScriptFunction( ScriptFunc, va_list );
// int CallScriptFunction( ScriptFunc, ... );
};
///////////////////////////////////////////////////////////////////////////////////
#endif

BIN
CryptoSource/ScriptEngine-MCF File/bison.exe Normal file
View File

Binary file not shown.

668
CryptoSource/ScriptEngine-MCF File/bison.hairy Normal file
View File

@@ -0,0 +1,668 @@
extern int timeclock;
int yyerror; /* Yyerror and yycost are set by guards. */
int yycost; /* If yyerror is set to a nonzero value by a */
/* guard, the reduction with which the guard */
/* is associated is not performed, and the */
/* error recovery mechanism is invoked. */
/* Yycost indicates the cost of performing */
/* the reduction given the attributes of the */
/* symbols. */
/* YYMAXDEPTH indicates the size of the parser's state and value */
/* stacks. */
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 500
#endif
/* YYMAXRULES must be at least as large as the number of rules that */
/* could be placed in the rule queue. That number could be determined */
/* from the grammar and the size of the stack, but, as yet, it is not. */
#ifndef YYMAXRULES
#define YYMAXRULES 100
#endif
#ifndef YYMAXBACKUP
#define YYMAXBACKUP 100
#endif
short yyss[YYMAXDEPTH]; /* the state stack */
YYSTYPE yyvs[YYMAXDEPTH]; /* the semantic value stack */
YYLTYPE yyls[YYMAXDEPTH]; /* the location stack */
short yyrq[YYMAXRULES]; /* the rule queue */
int yychar; /* the lookahead symbol */
YYSTYPE yylval; /* the semantic value of the */
/* lookahead symbol */
YYSTYPE yytval; /* the semantic value for the state */
/* at the top of the state stack. */
YYSTYPE yyval; /* the variable used to return */
/* semantic values from the action */
/* routines */
YYLTYPE yylloc; /* location data for the lookahead */
/* symbol */
YYLTYPE yytloc; /* location data for the state at the */
/* top of the state stack */
int yynunlexed;
short yyunchar[YYMAXBACKUP];
YYSTYPE yyunval[YYMAXBACKUP];
YYLTYPE yyunloc[YYMAXBACKUP];
short *yygssp; /* a pointer to the top of the state */
/* stack; only set during error */
/* recovery. */
YYSTYPE *yygvsp; /* a pointer to the top of the value */
/* stack; only set during error */
/* recovery. */
YYLTYPE *yyglsp; /* a pointer to the top of the */
/* location stack; only set during */
/* error recovery. */
/* Yyget is an interface between the parser and the lexical analyzer. */
/* It is costly to provide such an interface, but it avoids requiring */
/* the lexical analyzer to be able to back up the scan. */
yyget()
{
if (yynunlexed > 0)
{
yynunlexed--;
yychar = yyunchar[yynunlexed];
yylval = yyunval[yynunlexed];
yylloc = yyunloc[yynunlexed];
}
else if (yychar <= 0)
yychar = 0;
else
{
yychar = yylex();
if (yychar < 0)
yychar = 0;
else yychar = YYTRANSLATE(yychar);
}
}
yyunlex(chr, val, loc)
int chr;
YYSTYPE val;
YYLTYPE loc;
{
yyunchar[yynunlexed] = chr;
yyunval[yynunlexed] = val;
yyunloc[yynunlexed] = loc;
yynunlexed++;
}
yyrestore(first, last)
register short *first;
register short *last;
{
register short *ssp;
register short *rp;
register int symbol;
register int state;
register int tvalsaved;
ssp = yygssp;
yyunlex(yychar, yylval, yylloc);
tvalsaved = 0;
while (first != last)
{
symbol = yystos[*ssp];
if (symbol < YYNTBASE)
{
yyunlex(symbol, yytval, yytloc);
tvalsaved = 1;
ssp--;
}
ssp--;
if (first == yyrq)
first = yyrq + YYMAXRULES;
first--;
for (rp = yyrhs + yyprhs[*first]; symbol = *rp; rp++)
{
if (symbol < YYNTBASE)
state = yytable[yypact[*ssp] + symbol];
else
{
state = yypgoto[symbol - YYNTBASE] + *ssp;
if (state >= 0 && state <= YYLAST && yycheck[state] == *ssp)
state = yytable[state];
else
state = yydefgoto[symbol - YYNTBASE];
}
*++ssp = state;
}
}
if ( ! tvalsaved && ssp > yyss)
{
yyunlex(yystos[*ssp], yytval, yytloc);
ssp--;
}
yygssp = ssp;
}
int
yyparse()
{
register int yystate;
register int yyn;
register short *yyssp;
register short *yyrq0;
register short *yyptr;
register YYSTYPE *yyvsp;
int yylen;
YYLTYPE *yylsp;
short *yyrq1;
short *yyrq2;
yystate = 0;
yyssp = yyss - 1;
yyvsp = yyvs - 1;
yylsp = yyls - 1;
yyrq0 = yyrq;
yyrq1 = yyrq0;
yyrq2 = yyrq0;
yychar = yylex();
if (yychar < 0)
yychar = 0;
else yychar = YYTRANSLATE(yychar);
yynewstate:
if (yyssp >= yyss + YYMAXDEPTH - 1)
{
yyabort("Parser Stack Overflow");
YYABORT;
}
*++yyssp = yystate;
yyresume:
yyn = yypact[yystate];
if (yyn == YYFLAG)
goto yydefault;
yyn += yychar;
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar)
goto yydefault;
yyn = yytable[yyn];
if (yyn < 0)
{
yyn = -yyn;
goto yyreduce;
}
else if (yyn == 0)
goto yyerrlab;
yystate = yyn;
yyptr = yyrq2;
while (yyptr != yyrq1)
{
yyn = *yyptr++;
yylen = yyr2[yyn];
yyvsp -= yylen;
yylsp -= yylen;
yyguard(yyn, yyvsp, yylsp);
if (yyerror)
goto yysemerr;
yyaction(yyn, yyvsp, yylsp);
*++yyvsp = yyval;
yylsp++;
if (yylen == 0)
{
yylsp->timestamp = timeclock;
yylsp->first_line = yytloc.first_line;
yylsp->first_column = yytloc.first_column;
yylsp->last_line = (yylsp-1)->last_line;
yylsp->last_column = (yylsp-1)->last_column;
yylsp->text = 0;
}
else
{
yylsp->last_line = (yylsp+yylen-1)->last_line;
yylsp->last_column = (yylsp+yylen-1)->last_column;
}
if (yyptr == yyrq + YYMAXRULES)
yyptr = yyrq;
}
if (yystate == YYFINAL)
YYACCEPT;
yyrq2 = yyptr;
yyrq1 = yyrq0;
*++yyvsp = yytval;
*++yylsp = yytloc;
yytval = yylval;
yytloc = yylloc;
yyget();
goto yynewstate;
yydefault:
yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;
yyreduce:
*yyrq0++ = yyn;
if (yyrq0 == yyrq + YYMAXRULES)
yyrq0 = yyrq;
if (yyrq0 == yyrq2)
{
yyabort("Parser Rule Queue Overflow");
YYABORT;
}
yyssp -= yyr2[yyn];
yyn = yyr1[yyn];
yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
yystate = yytable[yystate];
else
yystate = yydefgoto[yyn - YYNTBASE];
goto yynewstate;
yysemerr:
*--yyptr = yyn;
yyrq2 = yyptr;
yyvsp += yyr2[yyn];
yyerrlab:
yygssp = yyssp;
yygvsp = yyvsp;
yyglsp = yylsp;
yyrestore(yyrq0, yyrq2);
yyrecover();
yystate = *yygssp;
yyssp = yygssp;
yyvsp = yygvsp;
yyrq0 = yyrq;
yyrq1 = yyrq0;
yyrq2 = yyrq0;
goto yyresume;
}
$

1362
CryptoSource/ScriptEngine-MCF File/bison.simple Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
CryptoSource/ScriptEngine-MCF File/flex.exe Normal file
View File

Binary file not shown.

1955
CryptoSource/ScriptEngine-MCF File/lex.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

167
CryptoSource/ScriptEngine-MCF File/lex.h Normal file
View File

@@ -0,0 +1,167 @@
// lex.h: lexer defines & declarations
#ifndef _LEX_H_
#define _LEX_H_
#include <stdio.h>
#ifdef _LEX_CPP_
int lineno = 1; // line number count; this will be used for error messages later
#else
// Import some variables
extern int lineno;
extern FILE *yyin; // the input stream
// Function prototype
int yylex ();
#endif
int yyparse ();
#ifndef YYLTYPE
typedef
struct yyltype
{
int timestamp;
int first_line;
int first_column;
int last_line;
int last_column;
char *text;
}
yyltype;
#define YYLTYPE yyltype
#endif
extern YYLTYPE yylloc;
/*
enum {
TOKEN_BEGIN = 258,
TOKEN_INCLUDE,
TOKEN_DEFINE,
TOKEN_INTEGERVALUE,
TOKEN_FLOATVALUE,
TOKEN_BOOLVALUE,
TOKEN_STRINGVALUE,
TOKEN_VOID,
TOKEN_INT,
TOKEN_FLOAT,
TOKEN_BOOL,
TOKEN_STRING,
TOKEN_FOR,
TOKEN_WHILE,
TOKEN_IF,
TOKEN_ELSE,
TOKEN_SWITCH,
TOKEN_CASE,
TOKEN_DEFAULT,
TOKEN_CONTINUE,
TOKEN_BREAK,
TOKEN_RETURN,
TOKEN_ID,
TOKEN_ADDITION,
TOKEN_SUBTRACTION,
TOKEN_MULTIPLICATION,
TOKEN_DIVISION,
TOKEN_REMINDER,
TOKEN_ASSIGNMENT,
TOKEN_COMPOUNDADDITION,
TOKEN_COMPOUNDSUBTRACTION,
TOKEN_COMPOUNDMULTIPLICATION,
TOKEN_COMPOUNDDIVISION,
TOKEN_COMPOUNDREMINDER,
TOKEN_INCREMENT,
TOKEN_DECREMENT,
TOKEN_NOT,
TOKEN_LESSTHAN,
TOKEN_LESSTHANOREQUAL,
TOKEN_MORETHAN,
TOKEN_MORETHANOREQUAL,
TOKEN_EQUALITY,
TOKEN_NOTEQUAL,
TOKEN_AND,
TOKEN_OR,
TOKEN_ENDSTATEMENT,
TOKEN_LEFTPARENTHESIS,
TOKEN_RIGHTPARENTHESIS,
TOKEN_LEFTBRACE,
TOKEN_RIGHTBRACE,
TOKEN_LEFTBRACKET,
TOKEN_RIGHTBRACKET,
TOKEN_COMMA,
TOKEN_COLON,
TOKEN_ERROR,
TOKEN_END
};
*/
#define TOKEN_ID 258
#define TOKEN_INTEGERVALUE 259
#define TOKEN_FLOATVALUE 260
#define TOKEN_BOOLVALUE 261
#define TOKEN_STRINGVALUE 262
#define TOKEN_INT 263
#define TOKEN_FLOAT 264
#define TOKEN_BOOL 265
#define TOKEN_STRING 266
#define TOKEN_VOID 267
#define TOKEN_FOR 268
#define TOKEN_WHILE 269
#define TOKEN_IF 270
#define TOKEN_ELSE 271
#define TOKEN_SWITCH 272
#define TOKEN_CASE 273
#define TOKEN_DEFAULT 274
#define TOKEN_CONTINUE 275
#define TOKEN_BREAK 276
#define TOKEN_RETURN 277
#define TOKEN_ENDSTATEMENT 278
#define TOKEN_LEFTPARENTHESIS 279
#define TOKEN_RIGHTPARENTHESIS 280
#define TOKEN_LEFTBRACE 281
#define TOKEN_RIGHTBRACE 282
#define TOKEN_LEFTBRACKET 283
#define TOKEN_RIGHTBRACKET 284
#define TOKEN_ERROR 285
#define TOKEN_COMMA 286
#define TOKEN_COLON 287
#define TOKEN_ASSIGNMENT 288
#define TOKEN_COMPOUNDADDITION 289
#define TOKEN_COMPOUNDSUBTRACTION 290
#define TOKEN_COMPOUNDMULTIPLICATION 291
#define TOKEN_COMPOUNDDIVISION 292
#define TOKEN_COMPOUNDREMINDER 293
#define TOKEN_AND 294
#define TOKEN_OR 295
#define TOKEN_LESSTHAN 296
#define TOKEN_LESSTHANOREQUAL 297
#define TOKEN_MORETHAN 298
#define TOKEN_MORETHANOREQUAL 299
#define TOKEN_EQUALITY 300
#define TOKEN_NOTEQUAL 301
#define TOKEN_ADDITION 302
#define TOKEN_SUBTRACTION 303
#define TOKEN_MULTIPLICATION 304
#define TOKEN_DIVISION 305
#define TOKEN_REMINDER 306
#define TOKEN_NOT 307
#define PREFIXINCREMENT 308
#define PREFIXDECREMENT 309
#define TOKEN_INCREMENT 310
#define TOKEN_DECREMENT 311
#define TOKEN_INCLUDE 312
#define TOKEN_DEFINE 313
#endif

80
CryptoSource/ScriptEngine-MCF File/lexsymb.h Normal file
View File

@@ -0,0 +1,80 @@
typedef union {
int symbolID; // entry from symbol table
int nodeID; // node in the syntax tree
char szIdentifier[4096];
char szConstant[4096];
} YYSTYPE;
#ifndef YYLTYPE
typedef
struct yyltype
{
int timestamp;
int first_line;
int first_column;
int last_line;
int last_column;
char *text;
}
yyltype;
#define YYLTYPE yyltype
#endif
#define TOKEN_ID 258
#define TOKEN_INTEGERVALUE 259
#define TOKEN_FLOATVALUE 260
#define TOKEN_BOOLVALUE 261
#define TOKEN_STRINGVALUE 262
#define TOKEN_INT 263
#define TOKEN_FLOAT 264
#define TOKEN_BOOL 265
#define TOKEN_STRING 266
#define TOKEN_VOID 267
#define TOKEN_FOR 268
#define TOKEN_WHILE 269
#define TOKEN_IF 270
#define TOKEN_ELSE 271
#define TOKEN_SWITCH 272
#define TOKEN_CASE 273
#define TOKEN_DEFAULT 274
#define TOKEN_CONTINUE 275
#define TOKEN_BREAK 276
#define TOKEN_RETURN 277
#define TOKEN_ENDSTATEMENT 278
#define TOKEN_LEFTPARENTHESIS 279
#define TOKEN_RIGHTPARENTHESIS 280
#define TOKEN_LEFTBRACE 281
#define TOKEN_RIGHTBRACE 282
#define TOKEN_LEFTBRACKET 283
#define TOKEN_RIGHTBRACKET 284
#define TOKEN_ERROR 285
#define TOKEN_COMMA 286
#define TOKEN_COLON 287
#define TOKEN_ASSIGNMENT 288
#define TOKEN_COMPOUNDADDITION 289
#define TOKEN_COMPOUNDSUBTRACTION 290
#define TOKEN_COMPOUNDMULTIPLICATION 291
#define TOKEN_COMPOUNDDIVISION 292
#define TOKEN_COMPOUNDREMINDER 293
#define TOKEN_AND 294
#define TOKEN_OR 295
#define TOKEN_LESSTHAN 296
#define TOKEN_LESSTHANOREQUAL 297
#define TOKEN_MORETHAN 298
#define TOKEN_MORETHANOREQUAL 299
#define TOKEN_EQUALITY 300
#define TOKEN_NOTEQUAL 301
#define TOKEN_ADDITION 302
#define TOKEN_SUBTRACTION 303
#define TOKEN_MULTIPLICATION 304
#define TOKEN_DIVISION 305
#define TOKEN_REMINDER 306
#define TOKEN_NOT 307
#define PREFIXINCREMENT 308
#define PREFIXDECREMENT 309
#define TOKEN_INCREMENT 310
#define TOKEN_DECREMENT 311
extern YYSTYPE yylval;

2425
CryptoSource/ScriptEngine-MCF File/parse.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

186
CryptoSource/ScriptEngine-MCF File/string.l Normal file
View File

@@ -0,0 +1,186 @@
%{
/* ------------------------------------------------------------------
Initial code (copied verbatim to the output file)
------------------------------------------------------------------ */
#include <io.h> // isatty
#define _LEX_CPP_ // make sure our variables get created
#include "lex.h"
#include "lexsymb.h"
#include "SymbolTable.h"
#include <string>
#ifdef MSVC
#define isatty _isatty // for some reason isatty is called _isatty in VC..
#endif
extern "C" int yywrap (); // the yywrap function is declared by the caller
void EatCComment();
void EatCppComment();
extern CSymbolTable * g_pSymbolTable;
%}
/* ------------------------------------------------------------------
Some macros (standard regular expressions)
------------------------------------------------------------------ */
LETTER [a-zA-Z_]
DIGIT [0-9]
HEXLETTER [a-fA-F0-9]
HEXVALUE 0[xX]{HEXLETTER}+
INTEGERVALUE {DIGIT}+
FLOATVALUE {DIGIT}+[.]{DIGIT}+
BOOLVALUE true|false
STRINGVALUE \"[^\"]*\"
ID {LETTER}({LETTER}|{DIGIT})*
WSPACE [ \t]+
INCLUDE "#include"{WSPACE}*{STRINGVALUE}
DEFINEoptPARAM {WSPACE}*","{WSPACE}*{ID}
DEFINEopt {WSPACE}*"("{WSPACE}*{ID}{DEFINEoptPARAM}*{WSPACE}*")"
DEFINEtokenstring {WSPACE}+{ID}
DEFINE "#define"{WSPACE}+{ID}{DEFINEopt}?{DEFINEtokenstring}?
/* ------------------------------------------------------------------
The lexer rules
------------------------------------------------------------------ */
%%
{INCLUDE} { return TOKEN_INCLUDE; }
{DEFINE} { return TOKEN_DEFINE; }
{HEXVALUE} { strcpy( yylval.szConstant, yytext );
return TOKEN_INTEGERVALUE; }
{INTEGERVALUE} { strcpy( yylval.szConstant, yytext );
return TOKEN_INTEGERVALUE; }
{FLOATVALUE} { strcpy( yylval.szConstant, yytext );
return TOKEN_FLOATVALUE; }
{BOOLVALUE} { strcpy( yylval.szConstant, yytext );
return TOKEN_BOOLVALUE; }
{STRINGVALUE} { strcpy( yylval.szConstant, yytext + 1 );
yylval.szConstant[ strlen( yylval.szConstant ) - 1 ] = '\0';
return TOKEN_STRINGVALUE; }
"void" { return TOKEN_VOID; }
"int" { return TOKEN_INT; }
"float" { return TOKEN_FLOAT; }
"bool" { return TOKEN_BOOL; }
"string" { return TOKEN_STRING; }
"for" { return TOKEN_FOR; }
"while" { return TOKEN_WHILE; }
"break" { return TOKEN_BREAK; }
"if" { return TOKEN_IF; }
"else" { return TOKEN_ELSE; }
"switch" { return TOKEN_SWITCH; }
"case" { return TOKEN_CASE; }
"default" { return TOKEN_DEFAULT; }
"continue" { return TOKEN_CONTINUE; }
"return" { return TOKEN_RETURN; }
{ID} { strcpy( yylval.szIdentifier, yytext );
return TOKEN_ID; }
"+" { return TOKEN_ADDITION; }
"-" { return TOKEN_SUBTRACTION; }
"*" { return TOKEN_MULTIPLICATION; }
"/" { return TOKEN_DIVISION; }
"%" { return TOKEN_REMINDER; }
"=" { return TOKEN_ASSIGNMENT; }
"+=" { return TOKEN_COMPOUNDADDITION; }
"-=" { return TOKEN_COMPOUNDSUBTRACTION; }
"*=" { return TOKEN_COMPOUNDMULTIPLICATION; }
"/=" { return TOKEN_COMPOUNDDIVISION; }
"%=" { return TOKEN_COMPOUNDREMINDER; }
"!" { return TOKEN_NOT; }
"<" { return TOKEN_LESSTHAN; }
"<=" { return TOKEN_LESSTHANOREQUAL; }
">" { return TOKEN_MORETHAN; }
">=" { return TOKEN_MORETHANOREQUAL; }
"==" { return TOKEN_EQUALITY; }
"!=" { return TOKEN_NOTEQUAL; }
"++" { return TOKEN_INCREMENT; }
"--" { return TOKEN_DECREMENT; }
";" { return TOKEN_ENDSTATEMENT; }
"(" { return TOKEN_LEFTPARENTHESIS; }
")" { return TOKEN_RIGHTPARENTHESIS; }
"[" { return TOKEN_LEFTBRACE; }
"]" { return TOKEN_RIGHTBRACE; }
"{" { return TOKEN_LEFTBRACKET; }
"}" { return TOKEN_RIGHTBRACKET; }
"," { return TOKEN_COMMA; }
":" { return TOKEN_COLON; }
"||" { return TOKEN_OR; }
"&&" { return TOKEN_AND; }
"//" { EatCppComment(); }
"/*" { EatCComment(); }
\n { yylloc.first_line = ++lineno; }
{WSPACE} {} //<2F><><EFBFBD><EFBFBD><EFBFBD>ع<EFBFBD><D8B9><EFBFBD>
. { return TOKEN_ERROR; } //<2F><> <20><><EFBFBD><EFBFBD> <20>͵<EFBFBD><CDB5><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>!
%%
/* ------------------------------------------------------------------
Additional code (again copied verbatim to the output file)
------------------------------------------------------------------ */
void EatCppComment()
{
char c;
while( (c = yyinput()) != '\n' && c != 0 );
yylloc.first_line = ++lineno;
}
void EatCComment()
{
char c, c0 = ' ';
while( true )
{
c = yyinput();
if( c0 == '*' && c == '/' )
break;
if( c == '\n' )
yylloc.first_line = ++lineno;
c0 = c;
}
}

588
CryptoSource/ScriptEngine-MCF File/string.y Normal file
View File

@@ -0,0 +1,588 @@
%{
/* ------------------------------------------------------------------
Initial code (copied verbatim to the output file)
------------------------------------------------------------------ */
#include <malloc.h> // _alloca is used by the parser
#include <string> // strcpy
#include <assert.h>
#include <stdlib.h>
#include "lex.h" // the lexer
#include "SyntaxTree.h"
#include "SymbolTable.h"
#include "BaseDef.h"
#include "Message.h"
// Some yacc (bison) defines
#define YYDEBUG 1 // Generate debug code; needed for YYERROR_VERBOSE
#define YYERROR_VERBOSE // Give a more specific parse error message
// Forward references
void yyerror (char *msg);
extern CSyntaxTree * g_pSynTree;
extern CSymbolTable * g_pSymbolTable;
SFuncType GetFunctionType( int nodeID );
SFuncType GetFunctionType( int nodeID1, int nodeID2 );
SFuncType GetFuncCallType( int nodeID );
int CountArrayElements( int nodeID );
int GetConstantValue( int nodeID );
%}
/* ------------------------------------------------------------------
Yacc declarations
------------------------------------------------------------------ */
%union {
int symbolID; // entry from symbol table
int nodeID; // node in the syntax tree
char szIdentifier[4096];
char szConstant[4096];
}
%type <symbolID> variable new_variable
%type <nodeID> program statement_list statement compound_statement expression_statement selection_statement
%type <nodeID> cases case_one default iteration_statement for_expression for_init_statement optional_expression
%type <nodeID> jump_statement declaration decl_specifiers declarator_list init_declarator
%type <nodeID> array_initializer initializer_list argument_declaration_list argument_declaration function_definition
%type <nodeID> constant_expression expression assignment_expression logical_or_expression logical_and_expression
%type <nodeID> equality_expression relational_expression additive_expression multiplicative_expression unary_expression
%type <nodeID> postfix_expression primary_expression
%type <szIdentifier> function_name
%type <nodeID> function_decl_end
%token <szIdentifier> TOKEN_ID
%token <szConstant> TOKEN_INTEGERVALUE TOKEN_FLOATVALUE TOKEN_BOOLVALUE TOKEN_STRINGVALUE
%token TOKEN_INT TOKEN_FLOAT TOKEN_BOOL TOKEN_STRING TOKEN_VOID
%token TOKEN_FOR TOKEN_WHILE TOKEN_IF TOKEN_ELSE TOKEN_SWITCH TOKEN_CASE
%token TOKEN_DEFAULT TOKEN_CONTINUE TOKEN_BREAK TOKEN_RETURN
%token TOKEN_ENDSTATEMENT TOKEN_LEFTPARENTHESIS TOKEN_RIGHTPARENTHESIS
%token TOKEN_LEFTBRACE TOKEN_RIGHTBRACE TOKEN_LEFTBRACKET TOKEN_RIGHTBRACKET
%token TOKEN_ERROR
/*<2A>ؿ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>켱<EFBFBD><ECBCB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.*/
%left TOKEN_COMMA TOKEN_COLON
%right TOKEN_ASSIGNMENT TOKEN_COMPOUNDADDITION TOKEN_COMPOUNDSUBTRACTION TOKEN_COMPOUNDMULTIPLICATION TOKEN_COMPOUNDDIVISION TOKEN_COMPOUNDREMINDER
%left TOKEN_AND TOKEN_OR
%left TOKEN_LESSTHAN TOKEN_LESSTHANOREQUAL TOKEN_MORETHAN TOKEN_MORETHANOREQUAL TOKEN_EQUALITY TOKEN_NOTEQUAL
%left TOKEN_ADDITION TOKEN_SUBTRACTION
%right TOKEN_MULTIPLICATION TOKEN_DIVISION TOKEN_REMINDER
%right TOKEN_NOT
%left PREFIXINCREMENT PREFIXDECREMENT /*Context-Dependent Precedence(<28><>¥ <20>ɺ<EFBFBD>)*/
%left TOKEN_INCREMENT TOKEN_DECREMENT
%right TOKEN_LEFTPARENTHESIS
%left TOKEN_RIGHTPARENTHESIS
%expect 1 /* shift/reduce conflict: dangling ELSE */
/* declaration */
%%
/* ------------------------------------------------------------------
Yacc grammar rules
------------------------------------------------------------------ */
program
: statement_list { assert( g_pSynTree != NULL );
g_pSynTree->SetRoot( $1 ); }
;
statement_list
: statement_list statement { $$ = g_pSynTree->Insert( @1.first_line, TYPE_STATEMENT_LIST, $1, $2 ); }
| /* empty */ { $$ = g_pSynTree->Insert( @1.first_line, TYPE_EMPTY_STATEMENT ); }
;
statement
: compound_statement { $$ = $1; }
| expression_statement { $$ = $1; }
| selection_statement { $$ = $1; }
| iteration_statement { $$ = $1; }
| jump_statement { $$ = $1; }
| error TOKEN_ENDSTATEMENT { $$ = g_pSynTree->Insert( @1.first_line, TYPE_ERROR_STATEMENT ); }
| declaration { $$ = $1; }
| function_definition { $$ = $1; }
;
compound_statement
: TOKEN_LEFTBRACKET statement_list TOKEN_RIGHTBRACKET
{ $$ = $2; }
;
expression_statement
: TOKEN_ENDSTATEMENT { $$ = g_pSynTree->Insert( @1.first_line, TYPE_EMPTY_STATEMENT ); }
| expression TOKEN_ENDSTATEMENT { $$ = g_pSynTree->Insert( @1.first_line, TYPE_EXPRESSION, $1 ); }
;
selection_statement
: TOKEN_IF TOKEN_LEFTPARENTHESIS expression TOKEN_RIGHTPARENTHESIS statement
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_IF_STATEMENT, $3, $5 ); }
| TOKEN_IF TOKEN_LEFTPARENTHESIS expression TOKEN_RIGHTPARENTHESIS statement TOKEN_ELSE statement
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_IF_ELSE_STATEMENT, $3, $5, $7 ); }
| TOKEN_SWITCH TOKEN_LEFTPARENTHESIS expression TOKEN_RIGHTPARENTHESIS
TOKEN_LEFTBRACKET cases default TOKEN_RIGHTBRACKET
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_SWITCH_STATEMENT, $3, $6, $7 ); }
;
cases
: case_one cases { $$ = g_pSynTree->Insert( @1.first_line, TYPE_SWITCH_CASES, $1, $2 ); }
| case_one { $$ = $1; }
;
case_one
: TOKEN_CASE constant_expression TOKEN_COLON statement_list
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_CASE_ONE, $2, $4 ); }
;
default
: TOKEN_DEFAULT TOKEN_COLON statement_list { $$ = g_pSynTree->Insert( @1.first_line, TYPE_DEFAULT, $3 ); }
| { $$ = 0; }
;
iteration_statement
: TOKEN_FOR TOKEN_LEFTPARENTHESIS for_expression TOKEN_RIGHTPARENTHESIS statement
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_FOR_STATEMENT, $3, $5 ); }
| TOKEN_WHILE TOKEN_LEFTPARENTHESIS expression TOKEN_RIGHTPARENTHESIS statement
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_WHILE_STATEMENT, $3, $5 ); }
;
for_expression
: for_init_statement optional_expression TOKEN_ENDSTATEMENT optional_expression
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_FOR_EXPRESSION, $1, $2, $4 ); }
;
for_init_statement
: expression_statement { $$ = $1; }
| declaration { $$ = $1; }
;
optional_expression
: expression { $$ = $1; }
| { $$ = 0; }
;
jump_statement
: TOKEN_BREAK TOKEN_ENDSTATEMENT { $$ = g_pSynTree->Insert( @1.first_line, TYPE_BREAK_STATEMENT ); }
| TOKEN_CONTINUE TOKEN_ENDSTATEMENT { $$ = g_pSynTree->Insert( @1.first_line, TYPE_CONTINUE_STATEMENT ); }
| TOKEN_RETURN optional_expression TOKEN_ENDSTATEMENT
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_RETURN_STATEMENT, $2 ); }
;
declaration
: decl_specifiers declarator_list TOKEN_ENDSTATEMENT
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_DECLARATION, $1, $2 );
g_pSymbolTable->SetCurrentType( T_VOID ); }
;
decl_specifiers
: TOKEN_VOID { $$ = g_pSynTree->Insert( @1.first_line, TYPE_SPECIFIER_VOID ); }
| TOKEN_INT { g_pSymbolTable->SetCurrentType( T_INT );
$$ = g_pSynTree->Insert( @1.first_line, TYPE_SPECIFIER_INT ); }
| TOKEN_FLOAT { g_pSymbolTable->SetCurrentType( T_FLOAT );
$$ = g_pSynTree->Insert( @1.first_line, TYPE_SPECIFIER_FLOAT ); }
| TOKEN_BOOL { g_pSymbolTable->SetCurrentType( T_BOOL );
$$ = g_pSynTree->Insert( @1.first_line, TYPE_SPECIFIER_BOOL ); }
| TOKEN_STRING { g_pSymbolTable->SetCurrentType( T_STRING );
$$ = g_pSynTree->Insert( @1.first_line, TYPE_SPECIFIER_STRING ); }
;
variable
: TOKEN_ID {
$$ = g_pSymbolTable->FindVar( $1 );
if( $$ == 0 )
ErrorMessage2( @1.first_line, "undefined symbol : %s", $1 );
}
;
new_variable
: TOKEN_ID {
$$ = g_pSymbolTable->AddVar( $1 );
if( $$ == 0 )
ErrorMessage2( @1.first_line, "<22>̹<EFBFBD> <20><><EFBFBD><EFBFBD> <20>Ǿ<EFBFBD> <20>ִ<EFBFBD> <20>ɺ<EFBFBD><C9BA>Դϴ<D4B4>. : %s", $1 );
}
;
declarator_list
: init_declarator { $$ = $1; }
| declarator_list TOKEN_COMMA init_declarator { $$ = g_pSynTree->Insert( @1.first_line, TYPE_DECLARATOR_LIST, $1, $3 ); }
;
init_declarator
: new_variable TOKEN_ASSIGNMENT assignment_expression { $$ = g_pSynTree->Insert( @1.first_line, $1, TYPE_INIT_DECLARATION, $3 ); }
| new_variable { $$ = g_pSynTree->Insert( @1.first_line, $1, TYPE_NORMAL_DECLARATION ); }
| TOKEN_ID TOKEN_LEFTBRACE TOKEN_RIGHTBRACE array_initializer
{ $$ = g_pSynTree->Insert( @1.first_line, g_pSymbolTable->AddArrVar( $1, CountArrayElements( $4 ) ), TYPE_ARRAY_INITIALIZE, $4 ); }
| TOKEN_ID TOKEN_LEFTBRACE constant_expression TOKEN_RIGHTBRACE array_initializer
{ $$ = g_pSynTree->Insert( @1.first_line, g_pSymbolTable->AddArrVar( $1, GetConstantValue( $3 ) ), TYPE_ARRAY_INITIALIZE2, $3, $5 ); }
| TOKEN_ID TOKEN_LEFTBRACE constant_expression TOKEN_RIGHTBRACE
{ $$ = g_pSynTree->Insert( @1.first_line, g_pSymbolTable->AddArrVar( $1, GetConstantValue( $3 ) ), TYPE_ARRAY_DECLARATION, $3 ); }
;
array_initializer
: TOKEN_ASSIGNMENT TOKEN_LEFTBRACKET initializer_list TOKEN_RIGHTBRACKET
{ $$ = $3; }
;
initializer_list
: assignment_expression { $$ = $1; }
| assignment_expression TOKEN_COMMA initializer_list
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_INITIALIZER_LIST, $1, $3 ); }
;
argument_declaration_list
: argument_declaration { $$ = $1; }
| argument_declaration TOKEN_COMMA argument_declaration_list
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_ARGUMENT_DECLARATION_LIST, $1, $3 ); }
| { $$ = 0; }
;
argument_declaration
: decl_specifiers new_variable { $$ = g_pSynTree->Insert( @1.first_line, $2, TYPE_ARGUMENT_DECLARATION, $1 ); }
| decl_specifiers { $$ = $1; }
;
function_name
: TOKEN_ID { strcpy( $$, $1 );
g_pSymbolTable->BeginLocalNameSpace(); }
;
function_decl_end
: TOKEN_ENDSTATEMENT { g_pSymbolTable->EndLocalNameSpace( 0 ); }
;
function_def_start
: TOKEN_LEFTBRACKET { g_pSymbolTable->EndArgument(); }
;
function_definition
: decl_specifiers function_name TOKEN_LEFTPARENTHESIS argument_declaration_list TOKEN_RIGHTPARENTHESIS function_def_start statement_list TOKEN_RIGHTBRACKET
{
int symbID = g_pSymbolTable->AddFunc( true, $2, GetFunctionType( $1, $4 ) );
if( symbID == 0 )
ErrorMessage( @1.first_line, "<22><><EFBFBD><EFBFBD> <20>Լ<EFBFBD><D4BC><EFBFBD> <20>ߺ<EFBFBD><DFBA>Ͽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>߽<EFBFBD><DFBD>ϴ<EFBFBD>." );
$$ = g_pSynTree->Insert( @1.first_line, symbID, TYPE_FUNCTION_DEFINITION, $4, $7 );
g_pSymbolTable->SetCurrentType( T_VOID );
g_pSymbolTable->EndLocalNameSpace( symbID );
}
| decl_specifiers function_name TOKEN_LEFTPARENTHESIS argument_declaration_list TOKEN_RIGHTPARENTHESIS function_decl_end
{ $$ = g_pSynTree->Insert( @1.first_line, g_pSymbolTable->AddFunc( false, $2, GetFunctionType( $1, $4 ) ), TYPE_FUNCTION_DECLARATION, $4 );
g_pSymbolTable->SetCurrentType( T_VOID ); }
;
constant_expression
: TOKEN_INTEGERVALUE { $$ = g_pSynTree->Insert( @1.first_line, g_pSymbolTable->AddConst( $1, T_INT ), TYPE_CONSTANT_EXPRESSION ); }
| TOKEN_FLOATVALUE { $$ = g_pSynTree->Insert( @1.first_line, g_pSymbolTable->AddConst( $1, T_FLOAT ), TYPE_CONSTANT_EXPRESSION ); }
| TOKEN_BOOLVALUE { $$ = g_pSynTree->Insert( @1.first_line, g_pSymbolTable->AddConst( $1, T_BOOL ), TYPE_CONSTANT_EXPRESSION ); }
| TOKEN_STRINGVALUE { $$ = g_pSynTree->Insert( @1.first_line, g_pSymbolTable->AddConst( $1, T_STRING ), TYPE_CONSTANT_EXPRESSION ); }
;
expression
: assignment_expression { $$ = $1; }
| assignment_expression TOKEN_COMMA expression { $$ = g_pSynTree->Insert( @1.first_line, TYPE_EXPRESSION_LIST, $1, $3 ); }
;
assignment_expression
: logical_or_expression { $$ = $1; }
| variable TOKEN_ASSIGNMENT assignment_expression
{ $$ = g_pSynTree->Insert( @1.first_line, $1, TYPE_ASSIGNMENT_EXPRESSION, $3 ); }
| variable TOKEN_COMPOUNDADDITION assignment_expression
{ $$ = g_pSynTree->Insert( @1.first_line, $1, TYPE_COMPOUND_ADDITION, $3 ); }
| variable TOKEN_COMPOUNDSUBTRACTION assignment_expression
{ $$ = g_pSynTree->Insert( @1.first_line, $1, TYPE_COMPOUND_SUBTRACTION, $3 ); }
| variable TOKEN_COMPOUNDMULTIPLICATION assignment_expression
{ $$ = g_pSynTree->Insert( @1.first_line, $1, TYPE_COMPOUND_MULTIPLICATION, $3 ); }
| variable TOKEN_COMPOUNDDIVISION assignment_expression
{ $$ = g_pSynTree->Insert( @1.first_line, $1, TYPE_COMPOUND_DIVISION, $3 ); }
| variable TOKEN_COMPOUNDREMINDER assignment_expression
{ $$ = g_pSynTree->Insert( @1.first_line, $1, TYPE_COMPOUND_REMINDER, $3 ); }
;
logical_or_expression
: logical_and_expression { $$ = $1; }
| logical_or_expression TOKEN_OR logical_and_expression
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_OR_EXPRESSION, $1, $3 ); }
;
logical_and_expression
: equality_expression { $$ = $1; }
| logical_and_expression TOKEN_AND equality_expression
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_AND_EXPRESSION, $1, $3 ); }
;
equality_expression
: relational_expression { $$ = $1; }
| equality_expression TOKEN_EQUALITY relational_expression
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_EQUALITY_EXPRESSION, $1, $3 ); }
| equality_expression TOKEN_NOTEQUAL relational_expression
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_NOTEQAUL_EXPRESSION, $1, $3 ); }
;
relational_expression
: additive_expression { $$ = $1; }
| relational_expression TOKEN_LESSTHAN additive_expression
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_LESSTHAN_EXPRESSION, $1, $3 ); }
| relational_expression TOKEN_MORETHAN additive_expression
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_MORETHAN_EXPRESSION, $1, $3 ); }
| relational_expression TOKEN_LESSTHANOREQUAL additive_expression
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_LESSTHANOREQUAL_EXPRESSION, $1, $3 ); }
| relational_expression TOKEN_MORETHANOREQUAL additive_expression
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_MORETHANOREQUAL_EXPRESSION, $1, $3 ); }
;
additive_expression
: multiplicative_expression { $$ = $1; }
| additive_expression TOKEN_ADDITION multiplicative_expression
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_ADDITION_EXPRESSION, $1, $3 ); }
| additive_expression TOKEN_SUBTRACTION multiplicative_expression
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_SUBTRACTION_EXPRESSION, $1, $3 ); }
;
multiplicative_expression
: unary_expression { $$ = $1; }
| multiplicative_expression TOKEN_MULTIPLICATION unary_expression
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_MULTIPLICATION_EXPRESSION, $1, $3 ); }
| multiplicative_expression TOKEN_DIVISION unary_expression
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_DIVISION_EXPRESSION, $1, $3 ); }
| multiplicative_expression TOKEN_REMINDER unary_expression
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_REMINDER_EXPRESSION, $1, $3 ); }
;
unary_expression
: postfix_expression { $$ = $1; }
| TOKEN_INCREMENT variable %prec PREFIXINCREMENT
{ $$ = g_pSynTree->Insert( @1.first_line, $2, TYPE_PREFIXINCREMENT ); }
| TOKEN_DECREMENT variable %prec PREFIXDECREMENT
{ $$ = g_pSynTree->Insert( @1.first_line, $2, TYPE_PREFIXDECREMENT ); }
| TOKEN_NOT unary_expression { $$ = g_pSynTree->Insert( @1.first_line, TYPE_NOT_EXPRESSION, $2 ); }
;
postfix_expression
: primary_expression { $$ = $1; }
| variable TOKEN_LEFTBRACE expression TOKEN_RIGHTBRACE
{ $$ = g_pSynTree->Insert( @1.first_line, $1, TYPE_ARRAY_INDEXING, $3 ); }
| TOKEN_ID TOKEN_LEFTPARENTHESIS expression TOKEN_RIGHTPARENTHESIS
{
int symbolID = g_pSymbolTable->FindFunc( $1, GetFuncCallType( $3 ) );
if( symbolID == 0 )
ErrorMessage2( "Error(line %d) : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Լ<EFBFBD><D4BC><EFBFBD> ã<><C3A3> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>.\n", @1.first_line );
$$ = g_pSynTree->Insert( @1.first_line, symbolID, TYPE_FUNCTION_CALL, $3 );
}
| TOKEN_ID TOKEN_LEFTPARENTHESIS TOKEN_RIGHTPARENTHESIS
{
int symbolID = g_pSymbolTable->FindFunc( $1, 0 );
if( symbolID == 0 )
ErrorMessage2( "Error(line %d) : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Լ<EFBFBD><D4BC><EFBFBD> ã<><C3A3> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>.\n", @1.first_line );
$$ = g_pSynTree->Insert( @1.first_line, symbolID, TYPE_FUNCTION_CALL );
}
| variable TOKEN_INCREMENT { $$ = g_pSynTree->Insert( @1.first_line, $1, TYPE_POSTFIXINCREMENT ); }
| variable TOKEN_DECREMENT { $$ = g_pSynTree->Insert( @1.first_line, $1, TYPE_POSTFIXDECREMENT ); }
;
primary_expression
: constant_expression { $$ = $1; }
| TOKEN_LEFTPARENTHESIS expression TOKEN_RIGHTPARENTHESIS
{ $$ = g_pSynTree->Insert( @1.first_line, TYPE_EXPRESSION, $2 ); }
| variable { $$ = g_pSynTree->Insert( @1.first_line, $1, TYPE_VARIABLE ); }
;
%%
/* ------------------------------------------------------------------
Additional code (again copied verbatim to the output file)
------------------------------------------------------------------ */
eDataType GetType( SNode * pNode )
{
switch( pNode->m_eType )
{
case TYPE_ARGUMENT_DECLARATION :
return GetType( pNode->m_ArrPtrChilds[0] );
case TYPE_SPECIFIER_INT :
return T_INT;
case TYPE_SPECIFIER_FLOAT :
return T_FLOAT;
case TYPE_SPECIFIER_BOOL :
return T_BOOL;
case TYPE_SPECIFIER_STRING :
return T_STRING;
}
return T_VOID;
}
SFuncType GetFunctionType( eDataType retType, int nodeID )
{
SNode * pNode = (SNode*)nodeID;
SFuncType FuncType;
int i = 0;
while( pNode != NULL )
{
if( pNode->m_eType == TYPE_ARGUMENT_DECLARATION_LIST )
{
FuncType.SetArgType( i++, GetType( pNode->m_ArrPtrChilds[0] ) );
pNode = pNode->m_ArrPtrChilds[1];
}
else //TYPE_ARGUMENT_DECLARATION<4F><4E> TYPE_SPECIFIER_XXX <20>迭<EFBFBD><E8BFAD> <20><>
{
FuncType.SetArgType( i++, GetType( pNode ) );
break;
}
}
assert( i <= 36 );
FuncType.SetReturnType( retType );
return FuncType;
}
SFuncType GetFunctionType( int nodeID )
{
return GetFunctionType( g_pSymbolTable->GetCurrentType(), nodeID );
}
SFuncType GetFunctionType( int nodeID1, int nodeID2 )
{
SNode * pNode = (SNode*)nodeID1;
if( pNode != NULL )
{
return GetFunctionType( GetType( pNode ), nodeID2 );
}
return 0;
}
SFuncType GetFuncCallType( int nodeID )
{
SNode * pNode = (SNode*)nodeID;
SFuncType FuncType;
int i = 0;
while( pNode != NULL )
{
if( pNode->m_eType == TYPE_EXPRESSION_LIST )
{
FuncType.SetArgType( i++, pNode->m_ArrPtrChilds[0]->m_eReturnType );
pNode = pNode->m_ArrPtrChilds[1];
}
else
{
FuncType.SetArgType( i++, pNode->m_eReturnType );
break;
}
}
assert( i <= 36 );
FuncType.SetReturnType( T_VOID );
return FuncType;
}
int CountArrayElements( int nodeID )
{
if( nodeID == 0 )
return 0;
SNode * pNode = (SNode*)nodeID;
//initializer_list
int i = 0;
while( pNode != NULL )
{
if( pNode->m_eType == TYPE_INITIALIZER_LIST )
{
i++;
pNode = pNode->m_ArrPtrChilds[1];
}
else
{
i++;
break;
}
}
return i;
}
int GetConstantValue( int nodeID )
{
//constant expression
SNode * pNode = (SNode*)nodeID;
if( pNode->m_eType == TYPE_CONSTANT_EXPRESSION )
{
if( g_pSymbolTable->GetTypeOfConst( pNode->m_SymbolID ) == T_INT )
{
const char * pStr = g_pSymbolTable->GetNameOfConst( pNode->m_SymbolID );
return strtol( pStr, NULL, 0 );
}
}
return 0;
}

0
CryptoSource/ScriptEngine-MCF File/unistd.h Normal file
View File

137
CryptoSource/ScriptEngine-MCF File/version.txt Normal file
View File

@@ -0,0 +1,137 @@
[[[<5B>ذ<EFBFBD><D8B0>ؾ<EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>]]]
=> <20>޴<EFBFBD><DEB4><EFBFBD> <20><><EFBFBD><EFBFBD>
=> <20><>ó<EFBFBD><C3B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ֱ<EFBFBD>
=> <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD>ȭ <20>˰<EFBFBD><CBB0><EFBFBD><EFBFBD><EFBFBD> <20>ֱ<EFBFBD>
=> ++, --, =<3D><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> <20>س<EFBFBD><D8B3>µ<EFBFBD>, <20>迭 <20>ε<EFBFBD><CEB5><EFBFBD>(a[2])<29><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> <20>ٲ<EFBFBD> <20><>.
=> <20>Լ<EFBFBD><D4BC><EFBFBD> <20>迭<EFBFBD><E8BFAD> <20>Ѱ<EFBFBD><D1B0><EFBFBD> <20><> <20>ֵ<EFBFBD><D6B5><EFBFBD> <20><> <20><>.
=> <20><><EFBFBD>κ<EFBFBD><CEBA><EFBFBD> <20><><EFBFBD>ɿ<EFBFBD><C9BF><EFBFBD> <20>ӽ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>μ<EFBFBD> ECX, EDX<44><58><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD> <20><><EFBFBD>µ<EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̶<EFBFBD><CCB6><EFBFBD>
<20>ߺ<EFBFBD><DFBA><EFBFBD> <20><><EFBFBD>찡 <20><><EFBFBD><EFBFBD> <20><> <20>ִµ<D6B4>, <20>̷<EFBFBD> <20><><EFBFBD>쿡 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>߸<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ȴ<EFBFBD>.
<09><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> int a = func( 4 ) + 10; <20>̷<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ڵ<EFBFBD><DAB5><EFBFBD> <20>ٲ<EFBFBD> <20><>
1.MOV ECX, 10
2.MOV ECX, 4
3.PUSH ECX
4.CALL func
5.ADD ESP, 4
6.ADD ECX, EDX
7.MOV a, ECX
<09>̷<EFBFBD><CCB7><EFBFBD> <20>ٲ<EFBFBD><D9B2>µ<EFBFBD>, 1<><31> <20><><EFBFBD>ɿ<EFBFBD><C9BF><EFBFBD> ECX<43><58><EFBFBD><EFBFBD> <20>ӽ÷<D3BD> 10<31><30> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>µ<EFBFBD>
2<><32> <20><><EFBFBD>ɿ<EFBFBD><C9BF><EFBFBD> <20>ӽ÷<D3BD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ִ´ٰ<C2B4> 4<><34> <20>־<EFBFBD><D6BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20≯<EFBFBD> <20>־<EFBFBD>
<09><><EFBFBD><EFBFBD> <20><> 10<31><30> <20>Ҿ<EFBFBD><D2BE><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>쵵 <20><><EFBFBD><EFBFBD> <20><> <20>ִ<EFBFBD>.
->PUSH, POP<4F><50><EFBFBD><EFBFBD> <20>ذ<EFBFBD><D8B0><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ִµ<D6B4>... <20>̷<EFBFBD> <20><><EFBFBD><EFBFBD> <20>ʹ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ȴ<EFBFBD>.
-><3E><> <20><><EFBFBD>ɸ<EFBFBD><C9B8><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>¸<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, <20><><EFBFBD>ο<EFBFBD> Statement<6E><74> <20><><EFBFBD>۵ɶ<DBB5><C9B6><EFBFBD><EFBFBD><EFBFBD>
<20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>¸<EFBFBD> <20>ʱ<EFBFBD>ȭ <20>ϵ<EFBFBD><CFB5><EFBFBD> <20>س<EFBFBD><D8B3><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>¿<EFBFBD> <20><><EFBFBD><EFBFBD>
<20>ӽ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> <20>ϴ<EFBFBD> <20>͵<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>...
=> EAX <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʹ<EFBFBD> <20>Լ<EFBFBD><D4BC><EFBFBD> <20><><EFBFBD>ϰ<EFBFBD><CFB0><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>س<EFBFBD><D8B3><EFBFBD> <20><><EFBFBD>µ<EFBFBD>, <20>̰Ͱ<CCB0> <20>ߺ<EFBFBD><DFBA><EFBFBD> <20><><EFBFBD>쿡<EFBFBD><ECBFA1>
<09><><EFBFBD><EFBFBD>ġ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><> <20>ִ<EFBFBD>.
=> <20><><EFBFBD>ڿ<EFBFBD><DABF><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><> <20>ӽ<EFBFBD> <20><><EFBFBD>ڿ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ǵµ<C7B4>, <20>̰<EFBFBD><CCB0><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD> <20>˰<EFBFBD><CBB0><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
<09><><EFBFBD>߿<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>.
[0.9]
[0.8]
=>string<6E><67><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>߰<EFBFBD>.( +, +=, = )
[0.78]
=>VirtualMachine Ŭ<><C5AC><EFBFBD><EFBFBD> <20>߰<EFBFBD>, <20>Լ<EFBFBD> <20><><EFBFBD>ε<EFBFBD> <20>߰<EFBFBD>
[0.77]
=>IntermediateCode -> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ڵ<EFBFBD> <20>κп<CEBA> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>׵<EFBFBD> <20><><EFBFBD><EFBFBD>.
[0.75]
=>IntermediateCode -> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ڵ<EFBFBD> <20>κ<EFBFBD> <20>߰<EFBFBD>.
=>TYPE_FUNCTION_CALL<4C><4C> <20><><EFBFBD><EFBFBD> Ÿ<><C5B8> üũ <20>߰<EFBFBD>
[0.7]
=>IntermediateCode<64><65><EFBFBD><EFBFBD> <20>ٷ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ڵ带 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20>ֵ<EFBFBD><D6B5><EFBFBD> <20>ϱ<EFBFBD> <20><><EFBFBD><EFBFBD>
IntermediateCode Ŭ<><C5AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20>ڵ<EFBFBD>
[0.6.2]
=>0.5 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> Intermediate<74>ڵ<EFBFBD> Ŭ<><C5AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Լ<EFBFBD><D4BC><EFBFBD> <20>迭<EFBFBD><E8BFAD> <20><><EFBFBD><EFBFBD> <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>߰<EFBFBD>
=>IntermediateCode Ŭ<><C5AC><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD>
[0.6.1]
=><3E>Լ<EFBFBD><D4BC><EFBFBD> <20>迭<EFBFBD><E8BFAD> <20><><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> SymbolTable<6C><65> SyntaxTree<65><65> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
[0.6]
=>Virtual Machine<6E><65> <20><><EFBFBD><EFBFBD><EFBFBD> Intermediate <20>ڵ尡 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20>ֵ<EFBFBD><D6B5><EFBFBD> <20><>.
[0.5]
=>Intermediate <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>߰<EFBFBD>.
[0.4]
=>syntax tree<65><65><EFBFBD><EFBFBD> Ÿ<><C5B8> üŷ <20>߰<EFBFBD>
[0.3]
=>symbol table<6C><65> syntax tree <20>߰<EFBFBD>
[0.2]
=><3E>⺻ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> parser <20>ڵ<EFBFBD>
[0.1]
=><3E>⺻ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> lexer <20>ڵ<EFBFBD>
<20><>ó<EFBFBD><C3B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ʾ<EFBFBD><CABE><EFBFBD>.
[<5B><>ó<EFBFBD><C3B3><EFBFBD><EFBFBD>]
#include
#define
[<5B>ּ<EFBFBD>]
//
/* ... */
[<5B><><EFBFBD><EFBFBD>]
int<6E><74><EFBFBD><EFBFBD>
float<61><74><EFBFBD><EFBFBD>
bool<6F><6C><EFBFBD><EFBFBD>
string<6E><67><EFBFBD><EFBFBD>
vector<6F><72><EFBFBD><EFBFBD>
[Ű<><C5B0><EFBFBD><EFBFBD>]
(<28><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> Ű<><C5B0><EFBFBD><EFBFBD>)
int
float
bool
string
vector
(<28><><EFBFBD><EFBFBD> Ű<><C5B0><EFBFBD><EFBFBD>)
for
while
(<28>б<EFBFBD> Ű<><C5B0><EFBFBD><EFBFBD>)
if
else
switch
(<28><><EFBFBD><EFBFBD> Ű<><C5B0><EFBFBD><EFBFBD>)
break
continue
default
case
return
[<5B>ɺ<EFBFBD>]
[<5B><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>]
<09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+, -, *, /, %
+=, -=, *=, /=, %=
++, --
=
<09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
&&, ||
<09>񱳿<EFBFBD><F1B1B3BF><EFBFBD><EFBFBD><EFBFBD>
<, <=, >, >=, ==, !=
[<5B><>Ÿ]
;
()
[] - <20>ε<EFBFBD><CEB5><EFBFBD>
{}
[<5B>Լ<EFBFBD>]
<09><><EFBFBD><EFBFBD>
ȣ<><C8A3>
<09><><EFBFBD><EFBFBD>