Index: /trunk/ab5.0/abdev/BasicCompiler32/BasicCompiler.rc
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/BasicCompiler.rc (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/BasicCompiler.rc (revision 440)
@@ -0,0 +1,396 @@
+// 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
+
+/////////////////////////////////////////////////////////////////////////////
+// 日本語 resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_JPN)
+#ifdef _WIN32
+LANGUAGE LANG_JAPANESE, SUBLANG_DEFAULT
+#pragma code_page(932)
+#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
+ "\r\n"
+ "\0"
+END
+
+#endif // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+#if defined(APSTUDIO_INVOKED) || defined(JPN)
+#if defined(APSTUDIO_INVOKED)
+IDD_MAIN$(JPN) DIALOG 0, 0, 205, 229
+#else
+IDD_MAIN DIALOG 0, 0, 205, 229
+#endif
+STYLE DS_SETFONT | DS_MODALFRAME | WS_CAPTION | WS_SYSMENU
+CAPTION "ActiveBasic Compiler&Debugger"
+FONT 9, "ＭＳ Ｐゴシック"
+BEGIN
+ DEFPUSHBUTTON "コンパイル",IDOK,148,208,50,14
+ LTEXT "出力先:",IDC_STATIC,7,10,23,8
+ EDITTEXT IDC_EXEPATH,34,7,164,14,ES_AUTOHSCROLL
+ CONTROL "Progress1",IDC_PROGRESS,"msctls_progress32",0x0,13,56,179,14
+ GROUPBOX "進行状況",IDC_STATIC,7,31,191,45
+ LTEXT "準備中...",IDC_MESSAGE,13,44,161,8
+ GROUPBOX "メッセージ リスト",IDC_STATIC,7,83,191,117
+ EDITTEXT IDC_ERRORLIST,13,113,179,80,ES_MULTILINE | ES_AUTOVSCROLL | ES_AUTOHSCROLL | WS_DISABLED | WS_VSCROLL | WS_HSCROLL
+ CONTROL "エラー",IDC_SHOWERROR,"Button",BS_AUTORADIOBUTTON | BS_PUSHLIKE,13,97,35,10
+ CONTROL "デバッグ",IDC_SHOWDEBUG,"Button",BS_AUTORADIOBUTTON | BS_PUSHLIKE,50,97,35,10
+ EDITTEXT IDC_DEBUGLIST,13,113,179,80,ES_MULTILINE | ES_AUTOVSCROLL | ES_AUTOHSCROLL | NOT WS_VISIBLE | WS_DISABLED | WS_VSCROLL | WS_HSCROLL
+ LTEXT "Version",IDC_STATIC_VERSION,7,214,140,8
+END
+#endif
+
+#if defined(APSTUDIO_INVOKED) || defined(JPN)
+#if defined(APSTUDIO_INVOKED)
+IDD_VARLIST$(JPN) DIALOG 0, 0, 215, 199
+#else
+IDD_VARLIST DIALOG 0, 0, 215, 199
+#endif
+STYLE DS_SETFONT | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME
+CAPTION "ブレーク ポイント"
+FONT 9, "ＭＳ Ｐゴシック"
+BEGIN
+ PUSHBUTTON "閉じる",IDCANCEL,165,6,50,14
+ LTEXT "対象領域:",IDC_STATIC,2,9,30,8
+ LTEXT "対象スレッド:",IDC_STATIC,2,26,38,8
+ COMBOBOX IDC_THREADCOMBO,43,24,69,100,CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP
+ CONTROL "Tree1",IDC_VARTREE,"SysTreeView32",TVS_HASBUTTONS | TVS_HASLINES | TVS_LINESATROOT | WS_BORDER | WS_TABSTOP,0,88,215,111
+ CONTROL "グローバル",IDC_GLOBAL,"Button",BS_AUTORADIOBUTTON | BS_PUSHLIKE,43,6,47,14
+ CONTROL "ローカル",IDC_LOCAL,"Button",BS_AUTORADIOBUTTON | BS_PUSHLIKE,92,6,47,14
+ LTEXT "プロシージャ:",IDC_STATIC,2,43,39,8
+ COMBOBOX IDC_PROCCOMBO,43,40,69,116,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP
+ CONTROL "システム変数を表示しない",IDC_HIDESYSVAR,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,117,44,93,10
+ PUSHBUTTON "ステップ(IN)",IDC_STEPIN,4,64,50,14
+ CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,59,215,1
+ CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,81,215,1
+ PUSHBUTTON "ステップ(OVER)",IDC_STEPOVER,57,64,50,14
+END
+#endif
+
+#if defined(APSTUDIO_INVOKED) || defined(JPN)
+#if defined(APSTUDIO_INVOKED)
+IDD_CLIPMAIN$(JPN) DIALOGEX 0, 0, 332, 88
+#else
+IDD_CLIPMAIN DIALOGEX 0, 0, 332, 88
+#endif
+STYLE DS_SETFONT | WS_CHILD
+FONT 9, "ＭＳ Ｐゴシック", 0, 0, 0x1
+BEGIN
+ PUSHBUTTON "コンパイル",IDOK,0,0,37,13
+ EDITTEXT IDC_EXEPATH,285,57,24,12,ES_AUTOHSCROLL | ES_READONLY | NOT WS_VISIBLE
+ EDITTEXT IDC_ERRORLIST,38,14,129,74,ES_MULTILINE | ES_AUTOVSCROLL | ES_AUTOHSCROLL | WS_DISABLED | WS_VSCROLL | WS_HSCROLL
+ CONTROL "ビルド",IDC_SHOWERROR,"Button",BS_AUTORADIOBUTTON | BS_PUSHLIKE,0,20,37,12
+ CONTROL "デバッグ",IDC_SHOWDEBUG,"Button",BS_AUTORADIOBUTTON | BS_PUSHLIKE,0,34,37,12
+ EDITTEXT IDC_DEBUGLIST,38,15,179,73,ES_MULTILINE | ES_AUTOVSCROLL | ES_AUTOHSCROLL | NOT WS_VISIBLE | WS_DISABLED | WS_VSCROLL | WS_HSCROLL
+ CONTROL "Progress1",IDC_PROGRESS,"msctls_progress32",0x1,38,1,293,12
+ LTEXT "準備中...",IDC_MESSAGE,286,47,24,8,NOT WS_VISIBLE,WS_EX_TRANSPARENT
+ CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,16,39,1
+END
+#endif
+
+#if defined(APSTUDIO_INVOKED) || defined(ENG)
+#if defined(APSTUDIO_INVOKED)
+IDD_CLIPMAIN$(ENG) DIALOGEX 0, 0, 332, 88
+#else
+IDD_CLIPMAIN DIALOGEX 0, 0, 332, 88
+#endif
+STYLE DS_SETFONT | WS_CHILD
+FONT 9, "ＭＳ Ｐゴシック", 0, 0, 0x1
+BEGIN
+ PUSHBUTTON "Compile",IDOK,0,0,37,11
+ EDITTEXT IDC_EXEPATH,285,57,24,12,ES_AUTOHSCROLL | ES_READONLY | NOT WS_VISIBLE
+ EDITTEXT IDC_ERRORLIST,38,13,129,75,ES_MULTILINE | ES_AUTOVSCROLL | ES_AUTOHSCROLL | WS_DISABLED | WS_VSCROLL | WS_HSCROLL
+ CONTROL "Error",IDC_SHOWERROR,"Button",BS_AUTORADIOBUTTON | BS_PUSHLIKE,0,17,37,10
+ CONTROL "Debug",IDC_SHOWDEBUG,"Button",BS_AUTORADIOBUTTON | BS_PUSHLIKE,0,28,37,10
+ EDITTEXT IDC_DEBUGLIST,38,14,179,74,ES_MULTILINE | ES_AUTOVSCROLL | ES_AUTOHSCROLL | NOT WS_VISIBLE | WS_DISABLED | WS_VSCROLL | WS_HSCROLL
+ CONTROL "Progress1",IDC_PROGRESS,"msctls_progress32",0x1,38,0,293,12
+ LTEXT "Waiting...",IDC_MESSAGE,286,47,24,8,NOT WS_VISIBLE,WS_EX_TRANSPARENT
+ CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,13,39,1
+END
+#endif
+
+#if defined(APSTUDIO_INVOKED) || defined(ENG)
+#if defined(APSTUDIO_INVOKED)
+IDD_MAIN$(ENG) DIALOG 0, 0, 205, 229
+#else
+IDD_MAIN DIALOG 0, 0, 205, 229
+#endif
+STYLE DS_SETFONT | DS_MODALFRAME | WS_CAPTION | WS_SYSMENU
+CAPTION "ActiveBasic Compiler&Debugger"
+FONT 9, "ＭＳ Ｐゴシック"
+BEGIN
+ DEFPUSHBUTTON "Compile",IDOK,148,208,50,14
+ LTEXT "Output:",IDC_STATIC,7,10,22,8
+ EDITTEXT IDC_EXEPATH,34,7,164,14,ES_AUTOHSCROLL
+ CONTROL "Progress1",IDC_PROGRESS,"msctls_progress32",0x0,13,56,179,14
+ GROUPBOX "Advance situation",IDC_STATIC,7,31,191,45
+ LTEXT "ready...",IDC_MESSAGE,13,44,161,8
+ GROUPBOX "Message list",IDC_STATIC,7,83,191,117
+ EDITTEXT IDC_ERRORLIST,13,113,179,80,ES_MULTILINE | ES_AUTOVSCROLL | ES_AUTOHSCROLL | WS_DISABLED | WS_VSCROLL | WS_HSCROLL
+ CONTROL "Error",IDC_SHOWERROR,"Button",BS_AUTORADIOBUTTON | BS_PUSHLIKE,13,97,30,10
+ CONTROL "Debug",IDC_SHOWDEBUG,"Button",BS_AUTORADIOBUTTON | BS_PUSHLIKE,50,97,35,10
+ EDITTEXT IDC_DEBUGLIST,13,113,179,80,ES_MULTILINE | ES_AUTOVSCROLL | ES_AUTOHSCROLL | NOT WS_VISIBLE | WS_DISABLED | WS_VSCROLL | WS_HSCROLL
+ LTEXT "Version 4.00 Global Edition beta1",IDC_STATIC,7,214,98,8
+END
+#endif
+
+#if defined(APSTUDIO_INVOKED) || defined(ENG)
+#if defined(APSTUDIO_INVOKED)
+IDD_VARLIST$(ENG) DIALOG 0, 0, 215, 199
+#else
+IDD_VARLIST DIALOG 0, 0, 215, 199
+#endif
+STYLE DS_SETFONT | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME
+CAPTION "Breakpoint"
+FONT 9, "ＭＳ Ｐゴシック"
+BEGIN
+ PUSHBUTTON "Close",IDCANCEL,165,6,50,14
+ LTEXT "Level:",IDC_STATIC,2,9,18,8
+ LTEXT "Thread:",IDC_STATIC,2,26,22,8
+ COMBOBOX IDC_THREADCOMBO,43,24,69,100,CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP
+ CONTROL "Tree1",IDC_VARTREE,"SysTreeView32",TVS_HASBUTTONS | TVS_HASLINES | TVS_LINESATROOT | WS_BORDER | WS_TABSTOP,0,88,215,111
+ CONTROL "Global",IDC_GLOBAL,"Button",BS_AUTORADIOBUTTON | BS_PUSHLIKE,43,6,47,14
+ CONTROL "Local",IDC_LOCAL,"Button",BS_AUTORADIOBUTTON | BS_PUSHLIKE,92,6,47,14
+ LTEXT "Procedure:",IDC_STATIC,2,43,31,8
+ COMBOBOX IDC_PROCCOMBO,43,40,69,116,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP
+ CONTROL "Hide system variables",IDC_HIDESYSVAR,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,117,44,81,10
+ PUSHBUTTON "Step In",IDC_STEPIN,4,64,50,14
+ CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,59,215,1
+ CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,81,215,1
+ PUSHBUTTON "Step Over",IDC_STEPOVER,57,64,50,14
+END
+#endif
+
+#if defined(APSTUDIO_INVOKED) || defined(JPN)
+#if defined(APSTUDIO_INVOKED)
+IDD_DEBUGGER$(JPN) DIALOGEX 0, 0, 291, 148
+#else
+IDD_DEBUGGER DIALOGEX 0, 0, 291, 148
+#endif
+STYLE DS_SETFONT | WS_CHILD
+FONT 9, "ＭＳ Ｐゴシック", 0, 0, 0x1
+BEGIN
+ LTEXT "対象スレッド:",IDC_STATIC,5,21,38,8
+ COMBOBOX IDC_THREADCOMBO,5,30,69,100,CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP
+ LTEXT "プロシージャ:",IDC_STATIC,5,49,39,8
+ COMBOBOX IDC_PROCCOMBO,5,58,69,116,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP
+ CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,15,99,1
+ LTEXT "dummy",IDC_VARPOS,98,0,35,41,NOT WS_VISIBLE,WS_EX_STATICEDGE
+ CONTROL "List2",IDC_WATCHLIST,"SysListView32",LVS_REPORT | LVS_EDITLABELS | WS_BORDER | WS_TABSTOP,171,9,60,50,WS_EX_ACCEPTFILES
+ LTEXT "コマンド",IDC_STATIC,3,3,23,8
+END
+#endif
+
+IDD_DEBUGGER_TOOLBARBASE DIALOG 0, 0, 62, 15
+STYLE DS_SETFONT | WS_CHILD | WS_VISIBLE
+FONT 9, "ＭＳ Ｐゴシック"
+BEGIN
+END
+
+#if defined(APSTUDIO_INVOKED) || defined(ENG)
+#if defined(APSTUDIO_INVOKED)
+IDD_DEBUGGER$(ENG) DIALOGEX 0, 0, 291, 148
+#else
+IDD_DEBUGGER DIALOGEX 0, 0, 291, 148
+#endif
+STYLE DS_SETFONT | WS_CHILD
+FONT 9, "ＭＳ Ｐゴシック", 0, 0, 0x1
+BEGIN
+ LTEXT "Thread:",IDC_STATIC,5,21,22,8
+ COMBOBOX IDC_THREADCOMBO,5,30,69,100,CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP
+ LTEXT "Procedure:",IDC_STATIC,5,49,31,8
+ COMBOBOX IDC_PROCCOMBO,5,58,69,116,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP
+ CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,15,99,1
+ LTEXT "dummy",IDC_VARPOS,98,0,35,41,NOT WS_VISIBLE,WS_EX_STATICEDGE
+ CONTROL "List2",IDC_WATCHLIST,"SysListView32",LVS_REPORT | LVS_EDITLABELS | WS_BORDER | WS_TABSTOP,171,9,60,50,WS_EX_ACCEPTFILES
+ LTEXT "コマンド",IDC_STATIC,3,3,23,8
+END
+#endif
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// DESIGNINFO
+//
+
+#ifdef APSTUDIO_INVOKED
+GUIDELINES DESIGNINFO
+BEGIN
+ "IDD_MAIN$(JPN)", DIALOG
+ BEGIN
+ LEFTMARGIN, 7
+ RIGHTMARGIN, 198
+ TOPMARGIN, 7
+ BOTTOMMARGIN, 222
+ END
+
+ "IDD_VARLIST$(JPN)", DIALOG
+ BEGIN
+ BOTTOMMARGIN, 161
+ END
+
+ "IDD_MAIN$(ENG)", DIALOG
+ BEGIN
+ LEFTMARGIN, 7
+ RIGHTMARGIN, 198
+ TOPMARGIN, 7
+ BOTTOMMARGIN, 222
+ END
+
+ "IDD_VARLIST$(ENG)", DIALOG
+ BEGIN
+ BOTTOMMARGIN, 161
+ END
+
+ IDD_DEBUGGER_TOOLBARBASE, DIALOG
+ BEGIN
+ LEFTMARGIN, 7
+ RIGHTMARGIN, 55
+ TOPMARGIN, 7
+ BOTTOMMARGIN, 8
+ END
+END
+#endif // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+IDI_MAIN ICON "icon1.ico"
+IDI_VARSTRUCT ICON "VarStruct.ico"
+IDI_VARDATA ICON "VarData.ico"
+IDI_VARSTR ICON "VarStr.ico"
+IDI_VARARRAY ICON "VarArray.ico"
+IDI_VARPTRSTRUCT ICON "VarPtrStruct.ico"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Toolbar
+//
+
+IDR_DEBUGGERTOOLBAR TOOLBAR 16, 15
+BEGIN
+ BUTTON IDC_DEBUG_START
+ BUTTON IDC_DEBUG_STEPOVER
+ BUTTON IDC_DEBUG_STEPIN
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Bitmap
+//
+
+IDR_DEBUGGERTOOLBAR BITMAP "toolbar_debugger.bmp"
+IDR_DEBUGGERTOOLBAR_DISABLED BITMAP "toolbar_debugger_disable.bmp"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+IDR_DEBUGGER_VARLIST_MENU MENU
+BEGIN
+ POPUP "dummy"
+ BEGIN
+ MENUITEM "一般システム変数を表示する", IDM_SHOW_DEFAULTSYSTEM_VAR
+ MENUITEM "RADシステム変数を表示する", IDM_SHOW_RAD_VAR
+ MENUITEM "GUID変数を表示する", IDM_SHOW_GUID_VAR
+ END
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION 5,0,0,0
+ PRODUCTVERSION 5,0,0,0
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x1L
+ FILESUBTYPE 0x0L
+BEGIN
+ BLOCK "StringFileInfo"
+ BEGIN
+ BLOCK "041104b0"
+ BEGIN
+ VALUE "CompanyName", "Discoversoft"
+ VALUE "FileDescription", "ActiveBasic"
+ VALUE "FileVersion", "5, 0, 0, 0"
+ VALUE "InternalName", "ActiveBasic"
+ VALUE "LegalCopyright", "Copyright (C) 2007"
+ VALUE "OriginalFilename", "BasicCompiler32.exe"
+ VALUE "ProductName", "ActiveBasic"
+ VALUE "ProductVersion", "5, 0, 0, 0"
+ END
+ END
+ BLOCK "VarFileInfo"
+ BEGIN
+ VALUE "Translation", 0x411, 1200
+ END
+END
+
+#endif // 日本語 resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif // not APSTUDIO_INVOKED
+
Index: /trunk/ab5.0/abdev/BasicCompiler32/BasicCompiler.vcproj
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/BasicCompiler.vcproj (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/BasicCompiler.vcproj (revision 440)
@@ -0,0 +1,1615 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Index: /trunk/ab5.0/abdev/BasicCompiler32/BasicCompiler32.sln
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/BasicCompiler32.sln (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/BasicCompiler32.sln (revision 440)
@@ -0,0 +1,23 @@
+
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual C++ Express 2005
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "BasicCompiler32", "BasicCompiler.vcproj", "{11F0E9AB-EAEC-4616-A9DD-838073342CBB}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Win32 = Debug|Win32
+ English_Rel|Win32 = English_Rel|Win32
+ Release|Win32 = Release|Win32
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {11F0E9AB-EAEC-4616-A9DD-838073342CBB}.Debug|Win32.ActiveCfg = Debug|Win32
+ {11F0E9AB-EAEC-4616-A9DD-838073342CBB}.Debug|Win32.Build.0 = Debug|Win32
+ {11F0E9AB-EAEC-4616-A9DD-838073342CBB}.English_Rel|Win32.ActiveCfg = English_Rel|Win32
+ {11F0E9AB-EAEC-4616-A9DD-838073342CBB}.English_Rel|Win32.Build.0 = English_Rel|Win32
+ {11F0E9AB-EAEC-4616-A9DD-838073342CBB}.Release|Win32.ActiveCfg = Release|Win32
+ {11F0E9AB-EAEC-4616-A9DD-838073342CBB}.Release|Win32.Build.0 = Release|Win32
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
Index: /trunk/ab5.0/abdev/BasicCompiler32/CParameter.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/CParameter.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/CParameter.cpp (revision 440)
@@ -0,0 +1,404 @@
+#include "stdafx.h"
+
+#include
+
+#include "../BasicCompiler_Common/common.h"
+#include "opcode.h"
+
+int ParamImpl::NewTempParameters( const string &procName, const Parameters ¶ms, int SecondParmNum ){
+ if( SecondParmNum == -1 ) SecondParmNum = (int)params.size();
+
+ ///////////////////////////////////////////////////////
+ // 一時オブジェクトをあらかじめスタックに積んでおく
+ ///////////////////////////////////////////////////////
+
+ useTempObject = false;
+
+ //一時参照の数
+ nCountOfTempObjects = 0;
+
+ BOOL bEllipse;
+ if(params.size()){
+ if(params[params.size()-1]->GetBasicType()==DEF_ELLIPSE) bEllipse=1;
+ else bEllipse=0;
+ }
+ else bEllipse=0;
+
+ for(int i2=ParmsNum-1;i2>=0;i2--){
+ useTempParameters[i2] = false;
+
+ if(bEllipse&&i2<=(int)params.size()-2) bEllipse=0;
+
+ if(i2==0){
+ if( params[i2]->GetVarName() == "_System_LocalThis" ){
+ //オブジェクトメンバの第一パラメータのThisポインタ
+ continue;
+ }
+ }
+ if( i2==0||i2==1 ){
+ if( params[i2]->GetVarName() == procName ){
+ //オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト
+ continue;
+ }
+ }
+
+ Type dummyType;
+ BOOL bByVal;
+ if(bEllipse){
+ NumOpe_GetType( Parms[i2], Type(), dummyType );
+ bByVal=1;
+ }
+ else{
+ dummyType = *params[i2];
+ bByVal = ( params[i2]->IsRef() == false ) ? TRUE:FALSE;
+ }
+
+
+ if( !bByVal ){
+ //ポインタ参照
+ if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
+ //ポインタ指定
+ continue;
+ }
+
+ if( !GetVarType( Parms[i2], Type(), FALSE ) ){
+ //変数ではないとき
+ Type calcType;
+ bool isNeedHeapFreeStructure;
+ NumOpe( Parms[i2], dummyType, calcType, &isNeedHeapFreeStructure );
+ //↑ここでスタックに積む
+
+ nCountOfTempObjects++;
+
+ if( !calcType.IsStruct() ){
+ //一時参照を作成
+
+ //push esp
+ compiler.codeGenerator.op_push( REG_ESP );
+
+ nCountOfTempObjects++;
+ }
+
+ bool result = CheckDifferentType(
+ dummyType,
+ calcType,
+ procName.c_str(),
+ i2);
+
+ if( result )
+ {
+ useTempParameters[i2] = true;
+ isNeedFreeStructures[i2] = isNeedHeapFreeStructure;
+ useTempObject = true;
+
+ types[i2] = calcType;
+ }
+ }
+ }
+ }
+
+ return nCountOfTempObjects * PTR_SIZE;
+}
+
+void ParamImpl::DeleteTempParameters(){
+ ///////////////////////////////////////////////////////
+ // 一時オブジェクトを破棄
+ ///////////////////////////////////////////////////////
+ if( !useTempObject ) return;
+
+ for(int i2=ParmsNum-1;i2>=0;i2--){
+ if( useTempParameters[i2] ){
+ if( types[i2].IsStruct() )
+ {
+ // 構造体の一時メモリ
+
+ if( isNeedFreeStructures[i2] )
+ {
+ //メモリを解放する
+
+ //call free
+ extern const UserProc *pSub_free;
+ compiler.codeGenerator.op_call(pSub_free);
+ }
+ else
+ {
+ //pop ... 参照を消す
+ compiler.codeGenerator.op_add_esp( PTR_SIZE );
+ }
+ }
+ else
+ {
+ if( types[i2].Is64() )
+ {
+ //pop ... 参照を消す
+ //pop ... 上位32ビット
+ //pop ... 下位32ビット
+ compiler.codeGenerator.op_add_esp( PTR_SIZE * 3 );
+ }
+ else
+ {
+ //pop ... 参照を消す
+ //pop ... 値を消す
+ compiler.codeGenerator.op_add_esp( PTR_SIZE * 2 );
+ }
+ }
+ }
+ }
+}
+
+void ParamImpl::SetStructParameter( const Type &baseType, const char *expression ){
+ int object_size = baseType.GetClass().GetSize();
+
+ //push object_size
+ compiler.codeGenerator.op_push_V(object_size);
+
+ //call calloc
+ extern const UserProc *pSub_calloc;
+ compiler.codeGenerator.op_call(pSub_calloc);
+
+ //push eax（ここでプッシュされた値が実際にパラメータとして引き渡される）
+ compiler.codeGenerator.op_push(REG_EAX);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+ Type calcType;
+ bool isNeedHeapFreeStructure;
+ NumOpe( expression,
+ baseType,
+ calcType,
+ &isNeedHeapFreeStructure );
+
+ // ※スタックにある二つのデータ（コピー先、コピー元）の値を必要とする
+ SetStructVariable( baseType, calcType, isNeedHeapFreeStructure );
+}
+
+int ParamImpl::SetParameter( const string &procName, const Parameters ¶ms, int SecondParmNum, const UserProc *pUserProc ){
+ if( SecondParmNum == -1 ) SecondParmNum = (int)params.size();
+
+ ///////////////////////////////////////////////////////////
+ // パラメータをレジスタ及びスタックフレームにセット
+ ///////////////////////////////////////////////////////////
+ int i2,i3;
+
+ BOOL bEllipse;
+ if( params.size() ){
+ if(params[params.size()-1]->GetBasicType()==DEF_ELLIPSE) bEllipse=1;
+ else bEllipse=0;
+ }
+ else bEllipse=0;
+
+ BOOL bHas_System_LocalThis=0;
+ if(ParmsNum>=1){
+ if( params[0]->GetVarName() == "_System_LocalThis" ){
+ bHas_System_LocalThis=1;
+ }
+ }
+
+ //戻り値用の変数名を取得
+ const char *lpszVarNameToReturn = (procName[0]==1&&procName[1]==ESC_OPERATOR)?"_System_ReturnValue":procName.c_str();
+
+ //パラメータをレジスタとスタックに格納
+ int ParmSize=0;
+ RELATIVE_VAR RelativeVar;
+ int nCountOfNowTempObjects = 0;
+ for(i2=ParmsNum-1;i2>=0;i2--){
+ if(bEllipse&&i2<=(int)params.size()-2) bEllipse=0;
+
+ if(i2==0){
+ if( params[i2]->GetVarName() == "_System_LocalThis" ){
+ //オブジェクトメンバの第一パラメータのThisポインタ
+ continue;
+ }
+ }
+ if(i2==0||i2==1){
+ if( params[i2]->GetVarName() == lpszVarNameToReturn ){
+ //オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト
+ continue;
+ }
+ }
+
+ Type dummyType;
+ BOOL bByVal;
+ if(bEllipse){
+ NumOpe_GetType( Parms[i2], Type(), dummyType );
+ bByVal=1;
+ }
+ else{
+ dummyType = *params[i2];
+ bByVal = ( params[i2]->IsRef() == false ) ? TRUE:FALSE;
+
+ // 型パラメータを解決
+ ResolveFormalGenericTypeParameter( dummyType, leftType, pUserProc );
+ }
+
+ if(bByVal==1){
+ //値参照
+/*
+ if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
+ char temp2[255];
+ sprintf(temp2,"%s関数の第%dパラメータ",procName.c_str(),i2+1);
+ SetError(19,temp2,cp);
+ continue;
+ }
+*/
+ if( dummyType.IsStruct() ){
+ SetStructParameter( dummyType, Parms[i2] );
+ goto next;
+ }
+
+ Type calcType;
+ bool isNeedHeapFreeStructure;
+ if( !NumOpe( Parms[i2], dummyType, calcType, &isNeedHeapFreeStructure ) )
+ {
+ break;
+ }
+
+ if( calcType.IsObject() )
+ {
+ if( !dummyType.IsObject()
+ ||
+ dummyType.IsObject() &&
+ !dummyType.GetClass().IsEqualsOrSubClass( &calcType.GetClass() ) )
+ {
+ //キャスト演算子のオーバーロードに対応する
+ CallCastOperatorProc( calcType, isNeedHeapFreeStructure,dummyType );
+ }
+ }
+
+ if(!bEllipse){
+ //型チェック
+ // TODO: _System_ReturnValueが考慮されていない？
+ if(bHas_System_LocalThis) i3=i2-1;
+ else i3=i2;
+ CheckDifferentType(
+ dummyType,
+ calcType,
+ procName.c_str(),
+ i3);
+ }
+
+ if( dummyType.IsDouble() ){
+ ChangeTypeToDouble( calcType.GetBasicType() );
+ ParmSize+=sizeof(long)*2;
+ }
+ else if( dummyType.IsSingle() ){
+ ChangeTypeToSingle( calcType.GetBasicType() );
+ ParmSize+=sizeof(long);
+ }
+ else if( dummyType.Is64() ){
+ ChangeTypeToInt64( calcType.GetBasicType() );
+ ParmSize+=sizeof(long)*2;
+ }
+ else if( dummyType.IsLong() || dummyType.IsDWord()
+ || dummyType.IsPointer()
+ || dummyType.IsObject() || dummyType.IsStruct() ){
+ ChangeTypeToLong( calcType.GetBasicType() );
+ ParmSize+=sizeof(long);
+ }
+ else if( dummyType.IsInteger() || dummyType.IsWord() ){
+ ChangeTypeToInteger( calcType.GetBasicType() );
+ ParmSize+=sizeof(long);
+ }
+ else if( dummyType.IsSByte() || dummyType.IsByte() || dummyType.IsBoolean() ){
+ ChangeTypeToByte( calcType.GetBasicType() );
+ ParmSize+=sizeof(long);
+ }
+ else{
+ SetError(300,NULL,cp);
+ }
+ }
+ else{
+ //ポインタ参照
+ if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
+ //ポインタ指定
+
+ Type calcType;
+ if( !NumOpe( Parms[i2]+2, dummyType, calcType) ){
+ break;
+ }
+
+ ChangeTypeToLong( calcType.GetBasicType() );
+
+ dummyType.PtrLevelUp();
+
+ //型チェック
+ if(bHas_System_LocalThis) i3=i2-1;
+ else i3=i2;
+ CheckDifferentType(
+ dummyType,
+ calcType,
+ procName.c_str(),
+ i3);
+ }
+ else{
+ if( useTempParameters[i2] ){
+ //一時オブジェクトをコピー
+
+ if( !types[i2].IsStruct() ){
+ // 一時参照のための領域を考慮する
+ nCountOfNowTempObjects++;
+ }
+
+ nCountOfNowTempObjects++;
+
+ //mov eax, dword ptr[esp+offset]
+ compiler.codeGenerator.op_mov_RM(
+ sizeof(long),
+ REG_EAX,
+ REG_ESP,
+ ( ( ParmsNum - i2 - 1 ) + ( nCountOfTempObjects - nCountOfNowTempObjects ) ) * PTR_SIZE,
+ MOD_BASE_DISP32 );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else{
+ //変数のアドレスを取得
+ Type varType;
+ if(GetVarOffset(
+ false,
+ false,
+ Parms[i2],
+ &RelativeVar,
+ varType)){
+ if( !dummyType.IsAny() ){
+ //型チェックを行う
+ if( dummyType.GetBasicType() == varType.GetBasicType() ){
+ if( dummyType.IsObject() ){
+ if( !dummyType.GetClass().IsEqualsOrSubClass( &varType.GetClass() ) ){
+ SetError(11,Parms[i2],cp);
+ }
+ }
+ else if( dummyType.IsStruct() ){
+ if( !dummyType.GetClass().IsEquals( &varType.GetClass() ) ){
+ SetError(11,Parms[i2],cp);
+ }
+ }
+ }
+ else if( (varType.GetBasicType()&FLAG_PTR)
+ &&((varType.GetBasicType()^FLAG_PTR)==dummyType.GetBasicType())){
+ //仮引数がポインタ参照で、実引数が配列の先頭ポインタのとき
+ }
+ else{
+ SetError(11,Parms[i2],cp);
+ }
+ }
+
+ //変数アドレスをレジスタにセット
+ SetVarPtrToEax(&RelativeVar);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ }
+ }
+
+ ParmSize+=PTR_SIZE;
+ }
+
+next:;
+ }
+
+ return ParmSize;
+}
Index: /trunk/ab5.0/abdev/BasicCompiler32/Compile_Calc.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/Compile_Calc.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/Compile_Calc.cpp (revision 440)
@@ -0,0 +1,652 @@
+#include "stdafx.h"
+
+#include
+
+#include
+
+#include "../BasicCompiler_Common/common.h"
+#include "Opcode.h"
+
+void ChangeTypeToDouble_ToFpuReg(int OldType){
+ //現在のスタックの内容を実数レジスタに保存する
+ //NumOpeの直後専用
+ if(OldType==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else if(OldType==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if(OldType==DEF_LONG){
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if(OldType==DEF_DWORD){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //push 0
+ compiler.codeGenerator.op_push_V(0);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.PutOld(
+ (char)0xDF,
+ (char)0x2C,
+ (char)0x24
+ );
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+}
+void ChangeTypeToDouble(int OldType){
+ //現在のスタックの内容をdouble型に変換する
+ //NumOpeの直後専用
+ if(OldType==DEF_DOUBLE) return;
+ else if(OldType==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ //fstp qword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
+ }
+ else if(OldType==DEF_INT64||OldType==DEF_QWORD){
+ //64ビット整数型
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //fstp qword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
+ }
+ else if(IsWholeNumberType(OldType)){
+ //その他整数型
+
+ if(IsSignedType(OldType)){
+ //符号あり
+
+ if(OldType==DEF_INTEGER || (Smoothie::IsUnicode()&&OldType==DEF_CHAR)){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //movsx eax,ax
+ compiler.codeGenerator.op_movsx_R32R16( REG_EAX );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else if(OldType==DEF_SBYTE || (Smoothie::IsUnicode()==false&&OldType==DEF_CHAR)){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //movsx eax,al
+ compiler.codeGenerator.op_movsx_R32R8( REG_EAX );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+ }
+ else{
+ //符号なし
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //push 0
+ compiler.codeGenerator.op_push_V(0);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.PutOld(
+ (char)0xDF,
+ (char)0x2C,
+ (char)0x24
+ );
+ }
+
+ //fstp qword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
+ }
+ else SetError(9,NULL,cp);
+}
+void ChangeTypeToSingle(int OldType){
+ //現在のスタックの内容をfloat型に変換する
+ //NumOpeの直後専用
+ if(OldType==DEF_SINGLE) return;
+ else if(OldType==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+
+ //fstp dword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
+ }
+ else if(OldType==DEF_INT64||OldType==DEF_QWORD){
+ //64ビット整数型
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+
+ //fstp dword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
+ }
+ else if(IsWholeNumberType(OldType)){
+ //その他整数型
+
+ if(IsSignedType(OldType)){
+ //符号あり
+
+ if(OldType==DEF_INTEGER || (Smoothie::IsUnicode()&&OldType==DEF_CHAR)){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //movsx eax,ax
+ compiler.codeGenerator.op_movsx_R32R16( REG_EAX );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else if(OldType==DEF_SBYTE || (Smoothie::IsUnicode()==false&&OldType==DEF_CHAR)){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //movsx eax,al
+ compiler.codeGenerator.op_movsx_R32R8( REG_EAX );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+ }
+ else{
+ //符号なし
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+ }
+
+ //fstp dword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
+ }
+ else SetError(9,NULL,cp);
+}
+
+void ChangeTypeToInt64(int OldType){
+ //現在のスタックの内容をInt64型に変換する
+ //NumOpeの直後専用
+ if(Is64Type(OldType)) return;
+
+ else if(OldType==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //fistp qword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
+ }
+ else if(OldType==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ //fistp qword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
+ }
+ else if(IsWholeNumberType(OldType)){
+ //その他整数
+
+ if(IsSignedType(OldType)){
+ //符号あり
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //cdq
+ compiler.codeGenerator.op_cdq();
+
+ //push edx
+ compiler.codeGenerator.op_push(REG_EDX);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else{
+ //符号なし
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //push 0
+ compiler.codeGenerator.op_push_V(0);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ }
+ else SetError(9,NULL,cp);
+}
+void ChangeTypeToLong(int OldType){
+ //現在のスタックの内容をLong型に変換する
+ //NumOpeの直後専用
+ if(OldType==DEF_DOUBLE){
+
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+ }
+ else if(OldType==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+ }
+ else if(OldType==DEF_INT64||OldType==DEF_QWORD){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+}
+void ChangeTypeToInteger(int OldType){
+ //現在のスタックの内容をInteger型に変換する
+ if(OldType==DEF_BOOLEAN||
+ OldType==DEF_BYTE||
+ OldType==DEF_WORD||OldType==DEF_INTEGER || (Smoothie::IsUnicode()&&OldType==DEF_CHAR)) return;
+ else if(OldType==DEF_SBYTE || (Smoothie::IsUnicode()==false&&OldType==DEF_CHAR)){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //movsx eax,al
+ compiler.codeGenerator.op_movsx_R32R8( REG_EAX );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else{
+ ChangeTypeToLong(OldType);
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //and eax,0000FFFFh
+ compiler.codeGenerator.op_and_RV( REG_EAX, 0x0000FFFF );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+}
+void ChangeTypeToByte(int OldType){
+ //現在のスタックの内容をbyte型に変換する
+ if(OldType==DEF_BYTE||OldType==DEF_SBYTE || (Smoothie::IsUnicode()==false&&OldType==DEF_CHAR)) return;
+
+ ChangeTypeToLong(OldType);
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //and eax,000000FFh
+ compiler.codeGenerator.op_and_RV( REG_EAX, 0x000000FF );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+}
+
+
+
+
+
+
+
+
+
+void RestoreDefaultRegisterFromStackMemory( int type ){
+ //現在のスタックの内容を実数レジスタに保存する
+ //NumOpeの直後専用
+ if(type==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else if(type==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if( Is64Type( type ) ){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //pop edx
+ compiler.codeGenerator.op_pop(REG_EDX);
+ }
+ else{
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+ }
+}
+
+void SetVariableFromEax( const Type &varType,int CalcType,RELATIVE_VAR *pRelativeVar){
+ /////////////////////////////////////////////////
+ // eaxの内容を変数にコピーするコードを抽出
+ /////////////////////////////////////////////////
+
+ if( varType.IsBoolean() )
+ {
+ //bool
+ SetBooleanVariable(CalcType,pRelativeVar);
+ }
+ else if( varType.IsReal() )
+ {
+ // Double/Single型変数へレジスタの値を代入
+ SetRealVariable(varType.GetBasicType(), CalcType, pRelativeVar);
+ }
+ else if( varType.IsWhole() || varType.IsObject() )
+ {
+ int typeSize = varType.GetSize();
+
+ //整数変数へraxの値を格納する
+ SetWholeVariable( typeSize, CalcType, pRelativeVar );
+ }
+ else{
+ SetError(300,NULL,cp);
+ }
+}
+
+void OpcodeCalc( const char *Command ){
+ int i,i2,i3;
+ char variable[VN_SIZE];
+
+
+
+ //////////////////////////////////////
+ // インクリメント・デクリメント
+ //////////////////////////////////////
+
+ for(i=0;;i++){
+ if(Command[i]=='\"'){
+ //ダブルクォートは不正なのでエラー扱い
+ variable[i]=0;
+ SetError(3,variable,cp);
+ return;
+ }
+
+ if(Command[i]=='('){
+ i2=GetStringInPare(variable+i,Command+i);
+ i+=i2-1;
+ continue;
+ }
+ if(Command[i]=='['){
+ i2=GetStringInBracket(variable+i,Command+i);
+ i+=i2-1;
+ continue;
+ }
+ if(Command[i]=='\0'){
+
+ ///////////////////////////////////
+ // インクリメント・デクリメント
+ ///////////////////////////////////
+
+ if(i>2){
+ if(Command[i-2]=='+'&&Command[i-1]=='+'){
+ //インクリメント
+ variable[i-2]=0;
+ IncDec(CALC_ADDITION,variable,"1");
+ return;
+ }
+ else if(Command[i-2]=='-'&&Command[i-1]=='-'){
+ //デクリメント
+ variable[i-2]=0;
+ IncDec(CALC_SUBTRACTION,variable,"1");
+ return;
+ }
+ }
+
+
+ //先端部分の識別子をエラーキーワードにする
+ for(i=0;;i++){
+ if(!IsVariableChar(Command[i])){
+ variable[i]=0;
+ break;
+ }
+ variable[i]=Command[i];
+ }
+
+ if(GetVarType(variable,Type(),0)){
+ //変数リストに該当したとき
+ SetError(1,NULL,cp);
+ }
+ else{
+ if( compiler.GetObjectModule().meta.GetGlobalConsts().IsExist(variable)
+ || compiler.GetObjectModule().meta.GetGlobalConstMacros().IsExist(variable) )
+ {
+ //定数リストに該当したとき
+ SetError(1,NULL,cp);
+ }
+ else{
+ //変数リスト、定数リストに該当しないとき
+ SetError(3,variable,cp);
+ }
+ }
+ return;
+ }
+
+ i2=GetCalcId(Command+i,&i3);
+ if(i2){
+ variable[i]=0;
+
+ if(Command[i]=='=') break;
+
+ if(Command[i+1+i3]=='='){
+ IncDec(i2,variable,Command+i+1+i3+1);
+ return;
+ }
+ }
+
+ variable[i]=Command[i];
+ }
+
+ if(Command[i+1]=='\0'){
+ SetError(1,NULL,cp);
+ return;
+ }
+
+
+ ///////////////////////////////////////////////////////////////
+ // インデクサのsetアクセサ（[]=演算子のオーバーロードに対応）
+ ///////////////////////////////////////////////////////////////
+
+ char ObjName[VN_SIZE],array_element[VN_SIZE];
+ GetArrayElement(variable,ObjName,array_element);
+ if(array_element[0]){
+ Type varType;
+ if( GetVarType(ObjName,varType,0) && varType.IsObject() ){
+ char temporary[VN_SIZE];
+ sprintf(temporary,"%s.%c%c%c",ObjName,1,ESC_OPERATOR,CALC_ARRAY_SET);
+
+ char temp2[VN_SIZE];
+ sprintf(temp2,"%s,%s",array_element,Command+i+1);
+
+ int idProc;
+ void *pProc;
+ idProc=GetProc(temporary,(void **)&pProc);
+ if( idProc )
+ {
+ CallProc(
+ idProc,
+ pProc,
+ temporary,
+ temp2,
+ Type(), // ベースタイプはなし
+ Type()
+ );
+ return;
+ }
+ }
+ }
+
+
+ if( lstrcmpi( variable, "This" ) == 0 ){
+ SetError(133,NULL,cp);
+ return;
+ }
+
+
+ ////////////////////////////////////////
+ // 変数のタイプ型を識別して、演算を行う
+ ////////////////////////////////////////
+
+ Type varType;
+
+ //型を識別
+ if( !GetTermTypeOnlyVariable(variable,varType) ){
+
+ // プロパティ用のメソッドを呼び出す
+ if(!CallPropertyMethod( variable, Command+i+1, Type() )){
+ //エラーを表示
+ GetVarType(variable,varType,true);
+ }
+
+ return;
+ }
+
+ RELATIVE_VAR VarRelativeVar;
+ if( varType.IsStruct() ){
+ //代入コピーに備える
+
+ //変数アドレスを取得
+ if(!GetVarOffsetReadWrite(
+ variable,
+ &VarRelativeVar,
+ varType)) return;
+
+ SetVarPtrToEax(&VarRelativeVar);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+
+ //NumOpe...（スタックに答えが格納される）
+ Type calcType;
+ bool isNeedHeapFreeStructure;
+ if( !NumOpe(Command+i+1,varType,calcType,&isNeedHeapFreeStructure) ){
+ return;
+ }
+
+ if( calcType.IsObject() && !calcType.Equals( varType ) ){
+ bool isUpCast = false;
+ if( varType.IsObject() ){
+ if( varType.GetClass().IsEqualsOrSubClass( &calcType.GetClass() ) ){
+ isUpCast = true;
+ }
+ }
+ if( !isUpCast ){
+ //キャスト演算子のオーバーロードに対応する
+ CallCastOperatorProc(calcType,isNeedHeapFreeStructure,varType);
+ }
+ }
+
+ //変数アドレスを取得
+ if( !TermOpeOnlyVariable( variable, varType, VarRelativeVar, true ) )
+ {
+ SetError();
+ return;
+ }
+
+ if(varType.GetBasicType()&FLAG_PTR){
+ SetError(14,variable,cp);
+ return;
+ }
+
+ if( varType.IsStruct() ){
+ //構造体インスタンスへの代入
+ SetStructVariable(varType,calcType,isNeedHeapFreeStructure);
+ return;
+ }
+
+
+ if( varType.IsObject() && compiler.GetObjectModule().meta.GetBlittableTypes().IsExist( calcType ) ){
+ // Blittable型をオブジェクトとして扱う
+ vector userProcs;
+ compiler.GetObjectModule().meta.GetBlittableTypes().GetClass( calcType ).GetStaticMethods().Enum( "_Create", userProcs );
+ if( userProcs.size() != 1 ){
+ SetError();
+ return;
+ }
+ const UserProc *pUserProc = userProcs[0];
+
+ // call System.[TypeClass]._Create
+ compiler.codeGenerator.op_call( pUserProc );
+
+ // push eax
+ compiler.codeGenerator.op_push( REG_EAX );
+
+ calcType = pUserProc->ReturnType();
+ }
+
+
+ /////////////////////////////////
+ // 右辺、左辺の型チェックを行う
+ /////////////////////////////////
+
+ CheckDifferentType(varType,calcType,0,0);
+
+
+ /////////////////////////////////////////////////
+ // スタックの内容を変数にコピーするコードを抽出
+ /////////////////////////////////////////////////
+
+ //eax、edx:eax、またはst(0)にスタック上のデータを取り出す
+ RestoreDefaultRegisterFromStackMemory( calcType.GetBasicType() );
+
+ SetVariableFromEax(varType,calcType.GetBasicType(),&VarRelativeVar);
+
+
+ // コード生成過程で発生した構造体の一時メモリを破棄する
+ compiler.codeGenerator.op_FreeTempStructure();
+}
Index: /trunk/ab5.0/abdev/BasicCompiler32/Compile_Calc_PushVar.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/Compile_Calc_PushVar.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/Compile_Calc_PushVar.cpp (revision 440)
@@ -0,0 +1,218 @@
+#include "stdafx.h"
+
+#include
+
+#include "../BasicCompiler_Common/common.h"
+#include "Opcode.h"
+
+void SetReg_RealVariable(int type,RELATIVE_VAR *pRelativeVar){
+ if(pRelativeVar->dwKind==VAR_GLOBAL){
+ if(pRelativeVar->bOffsetOffset){
+ //fld ptr[ecx+offset]
+ compiler.codeGenerator.op_fld_base_offset(type,REG_ECX,(int)pRelativeVar->offset, Schedule::GlobalVar );
+ }
+ else{
+ //mov ecx,offset
+ compiler.codeGenerator.op_mov_RV(REG_ECX,(int)pRelativeVar->offset, Schedule::GlobalVar );
+
+ //fld ptr[ecx]
+ compiler.codeGenerator.op_fld_basereg(type,REG_ECX);
+ }
+ }
+ else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
+ SetError(300,NULL,cp);
+ }
+ else if(pRelativeVar->dwKind==VAR_LOCAL){
+ if(pRelativeVar->bOffsetOffset){
+ //fld ptr[ebp+ecx+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_fld_base_offset_ex(type,REG_EBP,REG_ECX,(int)pRelativeVar->offset,USE_OFFSET, Schedule::None, true )
+ );
+ }
+ else{
+ //fld ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_fld_base_offset(type,REG_EBP,(int)pRelativeVar->offset, Schedule::None, true )
+ );
+ }
+ }
+ else if(pRelativeVar->dwKind==VAR_REFLOCAL){
+ if(pRelativeVar->bOffsetOffset){
+ //add ecx,qword ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_add_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+ else{
+ //mov ecx,qword ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+
+ goto directmem;
+ }
+ else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
+directmem:
+ //fld ptr[ecx]
+ compiler.codeGenerator.op_fld_basereg(type,REG_ECX);
+ }
+}
+void SetReg_WholeVariable( const Type &type, RELATIVE_VAR *pRelativeVar,int reg, bool is64Head)
+{
+ int varSize;
+
+ varSize = type.GetSize();
+
+ if(varSize==sizeof(_int64)){
+ //64ビットの場合はedx:eaxにロード
+ if(reg!=REG_EAX){
+ SetError(300,NULL,cp);
+ return;
+ }
+
+ //下位32ビットをeaxにロード
+ SetReg_WholeVariable( Type(DEF_LONG),pRelativeVar,REG_EAX);
+
+ //上位32ビットをedxにロード
+ SetReg_WholeVariable( Type(DEF_LONG),pRelativeVar,REG_EDX, true);
+
+ return;
+ }
+
+ int offsetOf64Head = 0;
+ if( is64Head ){
+ offsetOf64Head = sizeof(long);
+ }
+
+ if(pRelativeVar->dwKind==VAR_GLOBAL){
+ if(pRelativeVar->bOffsetOffset){
+ //mov reg, ptr[ecx+offset]
+ compiler.codeGenerator.op_mov_RM(varSize,reg,REG_ECX,(int)pRelativeVar->offset + offsetOf64Head,MOD_BASE_DISP32, Schedule::GlobalVar );
+ }
+ else{
+ //mov reg, ptr[offset]
+ compiler.codeGenerator.op_mov_RM(varSize,reg,0,(int)pRelativeVar->offset + offsetOf64Head,MOD_DISP32, Schedule::GlobalVar );
+ }
+ }
+ else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
+ if(pRelativeVar->bOffsetOffset){
+ //add ecx,qword ptr[offset]
+ compiler.codeGenerator.op_add_RM(varSize,REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32, Schedule::GlobalVar );
+ }
+ else{
+ //mov ecx,qword ptr[offset]
+ compiler.codeGenerator.op_mov_RM(varSize,REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32, Schedule::GlobalVar );
+ }
+
+ goto directmem;
+ }
+ else if(pRelativeVar->dwKind==VAR_LOCAL){
+ if(pRelativeVar->bOffsetOffset){
+ //mov reg, ptr[ebp+ecx+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_RM_ex(varSize,reg,REG_EBP,REG_ECX,(int)pRelativeVar->offset + offsetOf64Head,USE_OFFSET, Schedule::None, true )
+ );
+ }
+ else{
+ //mov reg, ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_RM(varSize,reg,REG_EBP,(int)pRelativeVar->offset + offsetOf64Head,MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+ }
+ else if(pRelativeVar->dwKind==VAR_REFLOCAL){
+ if(pRelativeVar->bOffsetOffset){
+ //add ecx,qword ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_add_RM(varSize,REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+ else{
+ //mov ecx,qword ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_RM(varSize,REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+
+ goto directmem;
+ }
+ else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
+directmem:
+ if( is64Head ){
+ //mov reg, ptr[ecx]
+ compiler.codeGenerator.op_mov_RM(varSize,reg,REG_ECX,offsetOf64Head,MOD_BASE_DISP8);
+ }
+ else{
+ //mov reg, ptr[ecx]
+ compiler.codeGenerator.op_mov_RM(varSize,reg,REG_ECX,0,MOD_BASE);
+ }
+ }
+}
+
+
+
+void PushLongVariable(RELATIVE_VAR *pRelativeVar){
+ if(pRelativeVar->dwKind==VAR_GLOBAL){
+ if(pRelativeVar->bOffsetOffset){
+ //push dword ptr[ecx+offset]
+ compiler.codeGenerator.op_push_M( REG_ECX, pRelativeVar->offset, Schedule::GlobalVar );
+ }
+ else{
+ //push dword ptr[offset]
+ compiler.codeGenerator.op_push_M( REG_NON, pRelativeVar->offset, Schedule::GlobalVar );
+ }
+ }
+ else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
+ //mov eax,dword ptr[offset]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32, Schedule::GlobalVar );
+
+ if(pRelativeVar->bOffsetOffset){
+ //add eax,ecx
+ compiler.codeGenerator.op_add_RR( REG_EAX, REG_ECX );
+ }
+
+ //push dword ptr[eax]
+ compiler.codeGenerator.op_push_M( REG_EAX );
+ }
+ else if(pRelativeVar->dwKind==VAR_LOCAL){
+ if(pRelativeVar->bOffsetOffset){
+ //add ecx,offset
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_add_RV( REG_ECX, pRelativeVar->offset, Schedule::None, true )
+ );
+
+ //push dword ptr[ebp+ecx]
+ compiler.codeGenerator.PutOld(
+ (char)0xFF,
+ (char)0x74,
+ (char)0x0D,
+ (char)0x00
+ );
+ }
+ else{
+ //push dword ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_push_M( REG_EBP, pRelativeVar->offset, Schedule::None, true )
+ );
+ }
+ }
+ else if(pRelativeVar->dwKind==VAR_REFLOCAL){
+ //mov eax,dword ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EBP, pRelativeVar->offset, MOD_BASE_DISP32, Schedule::None, true )
+ );
+
+ if(pRelativeVar->bOffsetOffset){
+ //add eax,ecx
+ compiler.codeGenerator.op_add_RR( REG_EAX, REG_ECX );
+ }
+
+ //push dword ptr[eax]
+ compiler.codeGenerator.op_push_M( REG_EAX );
+ }
+ else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
+ //push dword ptr[ecx]
+ compiler.codeGenerator.op_push_M( REG_ECX );
+ }
+}
Index: /trunk/ab5.0/abdev/BasicCompiler32/Compile_CallProc.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/Compile_CallProc.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/Compile_CallProc.cpp (revision 440)
@@ -0,0 +1,573 @@
+#include "stdafx.h"
+
+#include
+
+#include
+
+#include "../BasicCompiler_Common/common.h"
+#include "Opcode.h"
+
+void Call_DebugSys_SaveContext(){
+ //call _System_GetEip
+ extern const UserProc *pSub_System_GetEip;
+ compiler.codeGenerator.op_call(pSub_System_GetEip);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+ //push ebp
+ compiler.codeGenerator.op_push(REG_EBP);
+
+ //call _DebugSys_SaveContext
+ extern const UserProc *pSub_DebugSys_SaveContext;
+ compiler.codeGenerator.op_call(pSub_DebugSys_SaveContext);
+}
+
+bool Opcode_CallProcPtr( const char *variable, const char *lpszParms,ProcPointer *pProcPointer){
+
+ extern BOOL bDebugCompile;
+ extern BOOL bDebugSupportProc;
+ if(bDebugCompile&&bDebugSupportProc==0)
+ Call_DebugSys_SaveContext();
+
+
+ ////////////////////////
+ // パラメータのセット
+ ////////////////////////
+
+ //パラメータオブジェクトを生成
+ ParamImpl *pobj_parameter=0;
+ pobj_parameter=new ParamImpl(lpszParms);
+
+ // デフォルト引数を適用
+ pobj_parameter->ApplyDefaultParameters( pProcPointer->Params() );
+
+ //エラーチェック
+ if( !pobj_parameter->ErrorCheck(variable,pProcPointer->Params() ) ){
+ //パラメータにエラーがあるときは処理を終える
+ return false;
+ }
+
+ //一時オブジェクトを生成
+ pobj_parameter->NewTempParameters( variable,pProcPointer->Params() );
+
+ //レジスタ、スタックフレームにセット
+ pobj_parameter->SetParameter(variable,pProcPointer->Params() );
+
+
+
+ ////////////////////////
+ // call
+ ////////////////////////
+ RELATIVE_VAR RelativeVar;
+ GetVarOffsetReadOnly(variable,&RelativeVar,Type());
+ SetVarPtrToEax(&RelativeVar);
+
+ //mov eax,dword ptr[eax]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
+
+ //call eax
+ compiler.codeGenerator.op_call_R( REG_EAX );
+
+
+
+ //一時オブジェクトを破棄
+ pobj_parameter->DeleteTempParameters();
+
+ //パラメータオブジェクトを破棄
+ delete pobj_parameter;
+
+ return true;
+}
+
+bool Opcode_CallProc(const char *Parameter,const UserProc *pUserProc,DWORD dwFlags,const char *ObjectName )
+{
+ if( pUserProc->IsMacro() ){
+ if( lstrcmpi( pUserProc->GetName().c_str(), "Print" ) == 0 ){
+ Opcode_Print(Parameter,0);
+ return true;
+ }
+ if( lstrcmpi( pUserProc->GetName().c_str(), "Input" ) == 0 ){
+ Opcode_Input(Parameter);
+ return true;
+ }
+ if( lstrcmpi( pUserProc->GetName().c_str(), "Write" ) == 0 ){
+ Opcode_Print(Parameter,1);
+ return true;
+ }
+ }
+
+ pUserProc->Using();
+
+ bool isStatic = false;
+ const CClass *pobj_c = NULL;
+ const CMethod *pMethod = NULL;
+ Type leftType;
+ bool isFixedClass = false;
+ if( pUserProc->GetParentClassPtr() ){
+ //クラスのメンバ関数を呼び出す場合はアクセスチェックを行う
+ if(ObjectName[0] && (dwFlags&PROCFLAG_NEW)==0)
+ {
+ if(lstrcmpi(ObjectName,"Super")==0)
+ {
+ //クラスメンバ関数内から基底クラスの呼び出し
+ pobj_c=&compiler.pCompilingClass->GetSuperClass();
+
+ isFixedClass = true;
+ }
+ else
+ {
+ //"->"によってオブジェクトを指定する通常のメンバ関数呼び出し
+ Type varType;
+ if( GetTermType( ObjectName, varType ) )
+ {
+ if( varType.IsObject() )
+ {
+ pobj_c = &varType.GetClass();
+ leftType = varType;
+ }
+ }
+
+ if( !pobj_c )
+ {
+ pobj_c=compiler.GetObjectModule().meta.GetClasses().Find(ObjectName);
+ if( pobj_c ){
+ isStatic = true;
+ }
+ else{
+ SetError(300,NULL,cp);
+ }
+ }
+ }
+ }
+ else{
+ if(dwFlags&PROCFLAG_NEW){
+ GetVarType( ObjectName, leftType, false );
+
+ //New演算子によるコンストラクタ呼び出し
+ pobj_c=pUserProc->GetParentClassPtr();
+ }
+ else{
+ //クラスメンバ関数内から同一クラスのメンバ関数の呼び出し
+ pobj_c=compiler.pCompilingClass;
+ }
+ }
+
+
+ /////////////////////////////////
+ // メソッド情報を取得
+ /////////////////////////////////
+ pMethod = NULL;
+ if( ! isStatic ) pMethod = pobj_c->GetDynamicMethodOrInterfaceMethod( pUserProc );
+ if( ! pMethod ){
+ //動的メソッドが取得できなかったときは静的メソッドを当たる
+ pMethod = pobj_c->GetStaticMethods().GetMethodPtr( pUserProc );
+ if( !pMethod ){
+ SetError(300,NULL,cp);
+ return false;
+ }
+
+ //静的メンバ
+ isStatic = true;
+ }
+
+
+ //////////////////////////////
+ // アクセスエラーチェック
+ //////////////////////////////
+
+ if(ObjectName[0]){
+ //外部からの呼び出し
+ if(pobj_c==compiler.pCompilingClass){
+ //同一クラスオブジェクトの場合はプライベートアクセスを容認する
+ if( pMethod->IsNoneAccess() ){
+ SetError(109,pUserProc->GetName(),cp);
+ return false;
+ }
+ }
+ else{
+ if( pMethod->IsPrivate()
+ || pMethod->IsNoneAccess() ){
+ SetError(109,pUserProc->GetName(),cp);
+ return false;
+ }
+ if( !pMethod->GetUserProc().GetParentClass().IsEqualsOrSubClass( pobj_c ) && pMethod->IsProtected() ){
+ SetError(110,pUserProc->GetName(),cp);
+ return false;
+ }
+ }
+ }
+ else{
+ //クラス内部からの呼び出し（継承によるACCESS_NONのみをエラーとする）
+ if( pMethod->IsNoneAccess() ){
+ SetError(109,pUserProc->GetName(),cp);
+ return false;
+ }
+ }
+ }
+
+
+ ///////////////////////////////////////////////////////////////
+ // _System_LocalThisのダミーをセット
+ ///////////////////////////////////////////////////////////////
+
+ char temporary[VN_SIZE]={0};
+ if( pUserProc->GetParentClassPtr() && isStatic == false ){
+ //_System_LocalThis（第一パラメータ）のダミーを作成
+ lstrcpy(temporary,"0,");
+ }
+ if( pUserProc->ReturnType().IsStruct() ){
+ // ※ByRef _System_ReturnValue パラメータのダミーをセット
+ lstrcat(temporary,"0,");
+ }
+
+ if(Parameter[0]=='\0'&&temporary[0])
+ temporary[lstrlen(temporary)-1]=0;
+ else lstrcat(temporary,Parameter);
+
+
+ ////////////////////////
+ // パラメータをセット
+ ////////////////////////
+
+ //パラメータオブジェクトを生成
+ ParamImpl *pobj_parameter=0;
+ pobj_parameter=new ParamImpl(temporary);
+
+ // デフォルト引数を適用
+ pobj_parameter->ApplyDefaultParameters( pUserProc->RealParams() );
+
+ // 型パラメータを適用
+ pobj_parameter->SetLeftType( leftType );
+
+ //エラーチェック
+ if( !pobj_parameter->ErrorCheck(pUserProc->GetName(),pUserProc->RealParams(),pUserProc->GetSecondParmNum() ) ){
+ //パラメータにエラーがあるときは処理を終える
+ return false;
+ }
+
+ if(pUserProc->IsMacro()){
+ //マクロ関数の場合は、パラメータ省略を考慮する
+ pobj_parameter->MacroParameterSupport( pUserProc->RealParams() );
+ }
+
+ //一時オブジェクトを生成
+ int tempSize = pobj_parameter->NewTempParameters( pUserProc->GetName(),pUserProc->RealParams(),pUserProc->GetRealSecondParmNum() );
+
+ //レジスタ、スタックフレームにセット
+ int ParmSize = pobj_parameter->SetParameter(pUserProc->GetName(),pUserProc->RealParams(),pUserProc->GetRealSecondParmNum(), pUserProc );
+
+ if(pUserProc->ReturnType().IsStruct() ){
+ //////////////////////////////////////////////////////
+ // 戻り値に構造体インスタンスを持つ場合
+ // ※ByRef _System_ReturnValue パラメータをセット
+ //////////////////////////////////////////////////////
+
+ int object_size = pUserProc->ReturnType().GetClass().GetSize();
+
+ //push object_size
+ compiler.codeGenerator.op_push_V(object_size);
+
+ //call calloc
+ extern const UserProc *pSub_calloc;
+ compiler.codeGenerator.op_call(pSub_calloc);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+ ParmSize += PTR_SIZE;
+ }
+
+
+ if( pUserProc->GetParentClassPtr() && isStatic == false ){
+ //////////////////////////////////////////////////////
+ // メンバ関数の場合
+ // ※_System_LocalThis パラメータをecxにセット
+ //////////////////////////////////////////////////////
+
+ if(ObjectName[0] && (dwFlags&PROCFLAG_NEW)==0){
+ if(lstrcmpi(ObjectName,"Super")==0) goto InClassMember;
+ else{
+ bool isLiteral, isNeedHeapFreeStructure = false;
+ Type baseType( DEF_OBJECT, *pUserProc->GetParentClassPtr() ) , resultType;
+ if( !TermOpe( ObjectName, baseType, resultType, isLiteral, isNeedHeapFreeStructure, NULL, false, !pMethod->IsConst() ) )
+ {
+ return false;
+ }
+ if( !resultType.IsObject() )
+ {
+ SetError();
+ }
+
+ // 実態ポインタをeaxにコピー
+ compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EAX );
+ }
+ }
+ else{
+InClassMember:
+ if(dwFlags&PROCFLAG_NEW){
+ //New演算子によるコンストラクタ呼び出しの場合
+
+ //mov ecx,dword ptr[esp+ParmSize]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_ESP, ParmSize + tempSize, MOD_BASE_DISP32 );
+ }
+ else{
+ //Thisポインタをecxにコピー
+ SetThisPtrToReg(REG_ECX);
+ }
+ }
+ }
+
+ if( pUserProc->IsVirtual() && !isFixedClass )
+ {
+ int vtblIndex;
+ if( pobj_c->IsInterface() )
+ {
+ // インターフェイス メソッド呼び出し
+
+ int offset_vtbl = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__vtbl" );
+
+
+ // vtblのポインタを取得
+ //mov edx,dword ptr[ecx+offset_vtbl]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, offset_vtbl, MOD_BASE_DISP8 );
+
+ int offset_this = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__this" );
+
+
+
+ // インターフェイスの場合は更に__thisを取得する
+ //mov ecx,qword ptr[ecx+offset_this]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_ECX, offset_this, MOD_BASE_DISP8 );
+
+ int vtblMasterListIndex;
+ pobj_c->GetVtblMasterListIndexAndVtblIndex( pUserProc, vtblMasterListIndex, vtblIndex );
+ if( vtblMasterListIndex != 0 )
+ {
+ SetError();
+ }
+ }
+ else if( pobj_c->IsComInterface() )
+ {
+ // COMインターフェイス メソッド呼び出し
+
+ //仮想関数（オブジェクトメソッド）呼び出し
+ // pObj -> vtbl1 -> func1
+ // -> func2
+ // -> func3
+
+ int vtblMasterListIndex;
+ pobj_c->GetVtblMasterListIndexAndVtblIndex( pUserProc, vtblMasterListIndex, vtblIndex );
+
+ // vtblのポインタを取得
+ //mov edx,dword ptr[ecx]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, 0, MOD_BASE );
+ }
+ else
+ {
+ //仮想関数（オブジェクトメソッド）呼び出し
+ // pObj -> vtbl_master_list -> vtbl1 -> func1
+ // -> func2
+ // -> func3
+ // -> vtbl2 -> func1
+ // -> func2
+ // -> func3
+
+ int vtblMasterListIndex;
+ pobj_c->GetVtblMasterListIndexAndVtblIndex( pUserProc, vtblMasterListIndex, vtblIndex );
+
+ // vtblマスターリストのポインタを取得
+ //mov edx,dword ptr[ecx+sizeof(com_vtbl)]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, PTR_SIZE, MOD_BASE_DISP8 );
+
+ // vtblのポインタを取得
+ //mov edx,dword ptr[edx+vtblMasterListIndex]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_EDX, vtblMasterListIndex*PTR_SIZE, MOD_BASE_DISP32 );
+ }
+
+ //push ecx
+ compiler.codeGenerator.op_push(REG_ECX);
+
+ //call dword ptr[edx+func_index]
+ if( vtblIndex * PTR_SIZE <= 0x7F )
+ {
+ compiler.codeGenerator.PutOld(
+ (char)0xFF,
+ (char)0x52,
+ (char)(vtblIndex*PTR_SIZE)
+ );
+ }
+ else{
+ compiler.codeGenerator.PutOld(
+ (char)0xFF,
+ (char)0x92
+ );
+ compiler.codeGenerator.PutOld( (long)(vtblIndex*PTR_SIZE), Schedule::None );
+ }
+ }
+ else{
+ //通常呼び出し
+
+ if( pUserProc->GetParentClassPtr() && isStatic == false )
+ {
+ //push ecx
+ compiler.codeGenerator.op_push(REG_ECX);
+ }
+
+ //call ProcAddr
+ compiler.codeGenerator.op_call(pUserProc);
+ }
+
+ if(pUserProc->IsCdecl()){
+ //add esp,ParmSize
+ compiler.codeGenerator.op_add_esp(ParmSize);
+ }
+
+ //一時オブジェクトを破棄
+ pobj_parameter->DeleteTempParameters();
+
+ //パラメータオブジェクトを破棄
+ delete pobj_parameter;
+
+ return true;
+}
+
+bool Opcode_CallDllProc( const char *lpszParms, const DllProc *pDllProc ){
+
+ extern BOOL bDebugCompile;
+ extern BOOL bDebugSupportProc;
+ if(bDebugCompile&&bDebugSupportProc==0&& pDllProc->IsEqualSymbol( "DebugBreak" ) ){
+ Call_DebugSys_SaveContext();
+ }
+
+
+ ////////////////////////
+ // パラメータのセット
+ ////////////////////////
+
+ //パラメータオブジェクトを生成
+ ParamImpl *pobj_parameter=0;
+ pobj_parameter=new ParamImpl(lpszParms);
+
+ // デフォルト引数を適用
+ pobj_parameter->ApplyDefaultParameters( pDllProc->Params() );
+
+ //エラーチェック
+ if( !pobj_parameter->ErrorCheck( pDllProc->GetName(), pDllProc->Params() ) ){
+ //パラメータにエラーがあるときは処理を終える
+ return false;
+ }
+
+ //一時オブジェクトを生成
+ pobj_parameter->NewTempParameters( pDllProc->GetName(), pDllProc->Params() );
+
+ //レジスタ、スタックフレームにセット
+ int ParmSize = pobj_parameter->SetParameter(pDllProc->GetName(), pDllProc->Params() );
+
+
+ //動的リンクされたプロシージャの呼び出し
+
+ //call dword ptr[LookupTable]
+ compiler.codeGenerator.op_call( pDllProc );
+
+ if(pDllProc->IsCdecl()){
+ //add esp,ParmSize
+ compiler.codeGenerator.op_add_esp(ParmSize);
+ }
+
+ //一時オブジェクトを破棄
+ pobj_parameter->DeleteTempParameters();
+
+ //パラメータオブジェクトを破棄
+ delete pobj_parameter;
+
+ return true;
+}
+
+void Opcode_CallDelegate( const Delegate &dg, const char *methodPtrValueStr, const char *objPtrValueStr, const char *params )
+{
+ extern BOOL bDebugCompile;
+ extern BOOL bDebugSupportProc;
+ if(bDebugCompile&&bDebugSupportProc==0)
+ Call_DebugSys_SaveContext();
+
+
+ ///////////////////////////////////////////////////////////////
+ // _System_LocalThisのダミーをセット
+ ///////////////////////////////////////////////////////////////
+
+ char temporary[VN_SIZE]={0};
+ bool isDynamicCall = false;
+ if( objPtrValueStr && objPtrValueStr[0] ){
+ //_System_LocalThis（第一パラメータ）のダミーを作成
+ lstrcpy(temporary,"0,");
+
+ isDynamicCall = true;
+ }
+ if( dg.ReturnType().IsStruct() ){
+ // ※ByRef _System_ReturnValue パラメータのダミーをセット
+ lstrcat(temporary,"0,");
+ }
+
+ if(params[0]=='\0'&&temporary[0])
+ temporary[lstrlen(temporary)-1]=0;
+ else lstrcat(temporary,params);
+
+
+ const Parameters *pParams = &dg.Params();
+ if( isDynamicCall )
+ {
+ pParams = &dg.GetDynamicParams();
+ }
+
+
+ ParamImpl *pobj_parameter = new ParamImpl( temporary );
+
+ //一時オブジェクトを生成
+ pobj_parameter->NewTempParameters( dg.GetName(), *pParams );
+
+ //レジスタ、スタックフレームにセット
+ int ParmSize = pobj_parameter->SetParameter( dg.GetName(), *pParams );
+
+
+ if( objPtrValueStr && objPtrValueStr[0] )
+ {
+ RELATIVE_VAR RelativeVar;
+ //Constアクセスが不可能なメソッドの場合
+ if( !GetVarOffsetReadWrite( objPtrValueStr, &RelativeVar, Type() ) ){
+ Jenga::Throw( "Opcode_CallDelegate関数内で呼ばれるGetVarOffsetReadWrite関数に失敗" );
+ return;
+ }
+
+ SetVarPtrToEax(&RelativeVar);
+
+ // 参照を実体ポインタにする
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
+
+ //push ecx
+ compiler.codeGenerator.op_push(REG_ECX);
+ }
+
+
+ {
+ ////////////////////////
+ // call
+ ////////////////////////
+ RELATIVE_VAR RelativeVar;
+ GetVarOffsetReadOnly( methodPtrValueStr, &RelativeVar, Type() );
+ SetVarPtrToEax( &RelativeVar );
+
+ //mov eax,dword ptr[eax]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
+
+ //call eax
+ compiler.codeGenerator.op_call_R( REG_EAX );
+ }
+
+
+ //一時オブジェクトを破棄
+ pobj_parameter->DeleteTempParameters();
+
+ //パラメータオブジェクトを破棄
+ delete pobj_parameter;
+}
Index: /trunk/ab5.0/abdev/BasicCompiler32/Compile_Func.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/Compile_Func.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/Compile_Func.cpp (revision 440)
@@ -0,0 +1,816 @@
+#include "stdafx.h"
+
+#include
+
+#include
+
+#include "../BasicCompiler_Common/common.h"
+#include "Opcode.h"
+
+#ifdef _AMD64_
+#include "../BasicCompiler64/FunctionValue.h"
+#else
+#include "../BasicCompiler32/FunctionValue.h"
+#endif
+
+int GetFunctionFromName(char *FuncName){
+ if( lstrcmpi( FuncName, "CUDbl" ) == 0 ) return FUNC_CUDBL;
+ if( lstrcmpi( FuncName, "Fix" ) == 0 ) return FUNC_FIX;
+ if( lstrcmpi( FuncName, "Len" ) == 0 ) return FUNC_LEN;
+ if( lstrcmpi( FuncName, "AddressOf" ) == 0 ) return FUNC_ADDRESSOF;
+ if( lstrcmpi( FuncName, "SizeOf" ) == 0 ) return FUNC_SIZEOF;
+ if( lstrcmpi( FuncName, "VarPtr" ) == 0 ) return FUNC_VARPTR;
+ if( lstrcmpi( FuncName, "ObjPtr" ) == 0 ) return FUNC_OBJPTR;
+ if( lstrcmpi( FuncName, "__delegate_dynamicmethod_call" ) == 0 ) return FUNC_DELEGATE_DYNAMICMETHOD_CALL;
+ if( lstrcmpi( FuncName, "__delegate_staticmethod_call" ) == 0 ) return FUNC_DELEGATE_STATICMETHOD_CALL;
+ if( lstrcmpi( FuncName, "_System_GetNowScopeCatchAddresses" ) == 0 )return FUNC_SYSTEM_GET_NOW_SCOPE_CATCH_ADDRESS;
+ if( lstrcmpi( FuncName, "_System_GetNowScopeFinallyAddresses" ) == 0 )return FUNC_SYSTEM_GET_NOW_SCOPE_FINALLY_ADDRESS;
+ if( lstrcmpi( FuncName, "_System_GetBp" ) == 0 ) return FUNC_SYSTEM_GET_BP;
+ if( lstrcmpi( FuncName, "_System_GetSp" ) == 0 ) return FUNC_SYSTEM_GET_SP;
+ if( lstrcmp( FuncName, "_System_GetComVtbl" ) == 0 ) return FUNC_SYSTEM_GET_COM_VTBL;
+ if( lstrcmp( FuncName, "_System_GetVtblList" ) == 0 ) return FUNC_SYSTEM_GET_VTBL_LIST;
+ if( lstrcmp( FuncName, "_System_GetDefaultConstructor" ) == 0 ) return FUNC_SYSTEM_GET_DEFAULT_CONSTRUCTOR;
+ if( lstrcmp( FuncName, "_System_GetDestructor" ) == 0 ) return FUNC_SYSTEM_GET_DESTRUCTOR;
+ if( lstrcmpi( FuncName, "GetDouble" ) == 0 ) return FUNC_GETDOUBLE;
+ if( lstrcmpi( FuncName, "GetSingle" ) == 0 ) return FUNC_GETSINGLE;
+ if( lstrcmpi( FuncName, "GetQWord" ) == 0 ) return FUNC_GETQWORD;
+ if( lstrcmpi( FuncName, "GetDWord" ) == 0 ) return FUNC_GETDWORD;
+ if( lstrcmpi( FuncName, "GetWord" ) == 0 ) return FUNC_GETWORD;
+ if( lstrcmpi( FuncName, "GetByte" ) == 0 ) return FUNC_GETBYTE;
+ return 0;
+}
+
+void Opcode_Func_Fix(const char *lpszParms){
+ Type resultType;
+ if( !NumOpe( lpszParms, Type(), resultType ) ){
+ return;
+ }
+
+ if( resultType.IsDouble() ){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //fnstcw word ptr[esp]
+ compiler.codeGenerator.PutOld(
+ (char)0xD9,
+ (char)0x3C,
+ (char)0x24
+ );
+
+ //mov ax,word ptr[esp]
+ compiler.codeGenerator.op_mov_RM( sizeof(short), REG_EAX, REG_ESP, 0, MOD_BASE );
+
+ //or ah,0Ch
+ compiler.codeGenerator.PutOld(
+ (char)0x80,
+ (char)0xCC,
+ (char)0x0C
+ );
+
+ //mov word ptr[esp-2],ax
+ compiler.codeGenerator.op_mov_MR( sizeof(short), REG_EAX, REG_ESP, -2, MOD_BASE_DISP8 );
+
+ //fldcw word ptr[esp-2]
+ compiler.codeGenerator.PutOld(
+ (char)0xD9,
+ (char)0x6C,
+ (char)0x24,
+ (char)0xFE
+ );
+
+ //fistp dword ptr[esp+4]
+ compiler.codeGenerator.PutOld(
+ (char)0xDB,
+ (char)0x5C,
+ (char)0x24,
+ (char)0x04
+ );
+
+ //fldcw word ptr[esp]
+ compiler.codeGenerator.PutOld(
+ (char)0xD9,
+ (char)0x2C,
+ (char)0x24
+ );
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if( resultType.IsSingle() ){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ //fnstcw word ptr[esp]
+ compiler.codeGenerator.PutOld(
+ (char)0xD9,
+ (char)0x3C,
+ (char)0x24
+ );
+
+ //mov ax,word ptr[esp]
+ compiler.codeGenerator.op_mov_RM( sizeof(short), REG_EAX, REG_ESP, 0, MOD_BASE );
+
+ //or ah,0Ch
+ compiler.codeGenerator.PutOld(
+ (char)0x80,
+ (char)0xCC,
+ (char)0x0C
+ );
+
+ //mov word ptr[esp-2],ax
+ compiler.codeGenerator.op_mov_MR( sizeof(short), REG_EAX, REG_ESP, -2, MOD_BASE_DISP8 );
+
+ //fldcw word ptr[esp-2]
+ compiler.codeGenerator.PutOld(
+ (char)0xD9,
+ (char)0x6C,
+ (char)0x24,
+ (char)0xFE
+ );
+
+ //fistp dword ptr[esp+4]
+ compiler.codeGenerator.PutOld(
+ (char)0xDB,
+ (char)0x5C,
+ (char)0x24,
+ (char)0x04
+ );
+
+ //fldcw word ptr[esp]
+ compiler.codeGenerator.PutOld(
+ (char)0xD9,
+ (char)0x2C,
+ (char)0x24
+ );
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if( resultType.Is64() ){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+}
+
+void Opcode_Func_CUDbl(const char *Parameter){
+ Type resultType;
+ if( !NumOpe(Parameter,Type(),resultType) ){
+ return;
+ }
+ ChangeTypeToLong(resultType.GetBasicType());
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //push 0
+ compiler.codeGenerator.op_push_V( 0 );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+}
+void Opcode_Func_Len(const char *Parameter){
+ BOOL bArrayHead;
+
+ const char *tempParm=Parameter;
+ char temporary[VN_SIZE];
+ char temp2[32];
+ Type type;
+ if( !GetVarType(Parameter,type,0) ){
+ sprintf(temporary,"_System_DummyStr2=%s",Parameter);
+ OpcodeCalc(temporary);
+
+ lstrcpy(temp2,"_System_DummyStr2");
+ tempParm=temp2;
+
+ type.SetType( DEF_OBJECT, compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr() );
+ }
+
+ if( type.IsStringClass() ){
+ //Stringオブジェクトの場合
+ sprintf(temporary,"%s.Length",tempParm);
+
+ int reg=REG_RAX;
+ NumOpe(temporary,Type(),Type());
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ return;
+ }
+
+ Subscripts subscripts;
+ RELATIVE_VAR RelativeVar;
+ if(!GetVarOffsetReadOnly(tempParm,&RelativeVar,type,&subscripts)) return;
+
+ if(type.GetBasicType()&FLAG_PTR){
+ type.SetBasicType( type.GetBasicType() & ( ~FLAG_PTR ) );
+
+ bArrayHead=1;
+ }
+ else bArrayHead=0;
+
+ int typeSize = type.GetSize();
+
+ if(bArrayHead) typeSize*=JumpSubScripts(subscripts);
+
+ //mov eax,typeSize
+ compiler.codeGenerator.op_mov_RV( REG_EAX, typeSize );
+}
+
+void _Opcode_Func_AddressOf( const char *methodInstanceName, const UserProc &userProc )
+{
+ if( userProc.IsVirtual() ){
+ ///////////////////////////////
+ // 仮想関数の場合
+ // thisポインタをrcxにコピー
+ ///////////////////////////////
+
+ const CClass *pobj_c;
+
+ char ObjectName[VN_SIZE];
+ ReferenceKind referenceKind;
+ SplitObjectName( methodInstanceName, ObjectName, referenceKind );
+
+ if(ObjectName[0]){
+ if(lstrcmpi(ObjectName,"Super")==0) goto InClassMember;
+ else{
+ RELATIVE_VAR RelativeVar;
+ Type type;
+ if(!GetVarOffsetReadOnly(ObjectName,&RelativeVar,type)) return;
+ SetVarPtrToEax(&RelativeVar);
+
+ //mov ecx,eax
+ compiler.codeGenerator.op_mov_RR(REG_ECX,REG_EAX);
+
+ //参照タイプが整合しているかをチェック
+ if( !( type.IsObject() && referenceKind == RefDot
+ || type.IsObjectPtr() && referenceKind == RefPointer ) )
+ {
+ SetError(104,ObjectName,cp);
+ }
+
+ if(type.IsObjectPtr()){
+ //mov ecx,dword ptr[ecx]
+ compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_ECX,0,MOD_BASE);
+ }
+ }
+ }
+ else{
+InClassMember:
+ //自身のオブジェクトのThisポインタをrcxにコピー
+ SetThisPtrToReg(REG_RCX);
+
+ pobj_c=compiler.pCompilingClass;
+ }
+
+
+ int vtblIndex;
+ if( pobj_c->IsInterface() )
+ {
+ // インターフェイスメソッド呼び出し
+
+ int offset_vtbl = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__vtbl" );
+
+
+ // vtblのポインタを取得
+ //mov edx,dword ptr[ecx+offset_vtbl]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, offset_vtbl, MOD_BASE_DISP8 );
+
+ int offset_this = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__this" );
+
+
+
+ // インターフェイスの場合は更に__thisを取得する
+ //mov rcx,qword ptr[rcx+offset_this]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_ECX, offset_this, MOD_BASE_DISP8 );
+
+ int vtblMasterListIndex;
+ pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
+ if( vtblMasterListIndex != 0 )
+ {
+ SetError();
+ }
+ }
+ else if( pobj_c->IsComInterface() )
+ {
+ // COMインターフェイス メソッド呼び出し
+
+ //仮想関数（オブジェクトメソッド）呼び出し
+ // pObj -> vtbl1 -> func1
+ // -> func2
+ // -> func3
+
+ int vtblMasterListIndex;
+ pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
+
+ // vtblのポインタを取得
+ //mov edx,dword ptr[ecx]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, 0, MOD_BASE );
+ }
+ else
+ {
+ //仮想関数（オブジェクトメソッド）呼び出し
+ // pObj -> vtbl_master_list -> vtbl1 -> func1
+ // -> func2
+ // -> func3
+ // -> vtbl2 -> func1
+ // -> func2
+ // -> func3
+
+ int vtblMasterListIndex;
+ pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
+
+ // vtblマスターリストのポインタを取得
+ //mov edx,dword ptr[ecx+sizeof(com_vtbl)]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, PTR_SIZE, MOD_BASE_DISP8 );
+
+ // vtblのポインタを取得
+ //mov edx,dword ptr[edx+vtblMasterListIndex]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_EDX, vtblMasterListIndex*PTR_SIZE, MOD_BASE_DISP32 );
+ }
+
+ //mov eax,dword ptr[edx+func_index]
+ if( vtblIndex * PTR_SIZE <= 0x7F )
+ {
+ compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_EDX,vtblIndex*PTR_SIZE,MOD_BASE_DISP8);
+ }
+ else{
+ compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_EDX,vtblIndex*PTR_SIZE,MOD_BASE_DISP32);
+ }
+ }
+ else{
+ //一般の関数
+
+ //mov eax,ProcAddr
+ compiler.codeGenerator.op_addressof( REG_EAX, &userProc );
+ }
+
+ userProc.Using();
+}
+void Opcode_CreateDelegate( const CClass &dgClass, const char *methodInstanceName, const UserProc &userProc )
+{
+ /////////////////////////////////////////////////////////////////
+ // 関数ポインタをpush
+ /////////////////////////////////////////////////////////////////
+
+ //push AddressOf(userProc)
+ _Opcode_Func_AddressOf( methodInstanceName, userProc );
+ compiler.codeGenerator.op_push( REG_EAX );
+
+
+ if( userProc.GetMethod().IsDynamic() )
+ {
+ /////////////////////////////////////////////////////////////////
+ // オブジェクト ポインタをpush
+ /////////////////////////////////////////////////////////////////
+
+ // オブジェクト名を取得
+ char objectName[VN_SIZE];
+ char memberName[VN_SIZE];
+ char *thisPtrName = "This";
+ Type type;
+ if( SplitMemberName( methodInstanceName, objectName, memberName ) )
+ {
+ if( GetVarType( objectName, type, false ) )
+ {
+ thisPtrName = objectName;
+ }
+ }
+
+ // オブジェクト ポインタを取得
+ RELATIVE_VAR relativeVar;
+ GetVarOffsetReadOnly( thisPtrName, &relativeVar, type );
+ if( !type.IsObject() )
+ {
+ extern int cp;
+ SetError(1,NULL,cp);
+ return;
+ }
+
+ SetVarPtrToEax( &relativeVar );
+
+ //mov eax,dword ptr[eax]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
+
+ //push eax
+ compiler.codeGenerator.op_push( REG_EAX );
+ }
+
+
+ /////////////////////////////////////////////////////////////////
+ // call _CreateDynamicDelegate/_CreateStaticDelegate
+ /////////////////////////////////////////////////////////////////
+
+ std::vector subs;
+ if( userProc.GetMethod().IsDynamic() )
+ {
+ dgClass.GetStaticMethods().Enum( "_CreateDynamicDelegate", subs );
+ }
+ else
+ {
+ dgClass.GetStaticMethods().Enum( "_CreateStaticDelegate", subs );
+ }
+
+ // call _CreateDynamicDelegate
+ compiler.codeGenerator.op_call( subs[0] );
+}
+void Opcode_Func_AddressOf( const char *name, const Type &baseType, bool isCallOn, Type &resultType )
+{
+ extern int cp;
+ const UserProc *pUserProc;
+
+ const Parameters *pBaseParams = NULL;
+ if( baseType.IsProcPtr() )
+ {
+ // 左辺で関数ポインタを要求されているとき
+ pBaseParams = &compiler.GetObjectModule().meta.GetProcPointers()[baseType.GetIndex()]->Params();
+ }
+ else if( baseType.IsDelegate() )
+ {
+ // 左辺でデリゲートを要求されているとき
+ pBaseParams = &baseType.GetClass().GetDelegate().Params();
+ }
+
+ if( pBaseParams )
+ {
+ //左辺の型にのっとり、オーバーロードを解決
+
+ std::vector subs;
+ GetOverloadSubHash( name, subs );
+ if( subs.size() == 0 ){
+ SetError(27,name,cp);
+ return;
+ }
+
+ //オーバーロードを解決
+ pUserProc=OverloadSolution( name, subs, *pBaseParams, Type(), Type() );
+
+ if( isCallOn && baseType.IsDelegate() )
+ {
+ // コード生成を伴う場合はエラーチェックを行う
+ if( !pUserProc->Params().Equals( *pBaseParams )
+ || !pUserProc->ReturnType().Equals( baseType.GetClass().GetDelegate().ReturnType() ) )
+ {
+ if( baseType.IsDelegate() )
+ {
+ SetError(67, name, cp );
+ }
+ else
+ {
+ SetError(66, name, cp );
+ }
+ }
+ }
+
+ if(!pUserProc){
+ SetError(27,name,cp);
+ return;
+ }
+ }
+ else{
+ pUserProc=GetSubHash(name);
+ if(!pUserProc){
+ SetError(27,name,cp);
+ return;
+ }
+ }
+
+ if( baseType.IsDelegate() )
+ {
+ if( isCallOn )
+ {
+ // デリゲートのとき
+ Opcode_CreateDelegate( baseType.GetClass(), name, *pUserProc );
+ }
+ resultType = baseType;
+ }
+ else
+ {
+ if( isCallOn )
+ {
+ // 関数ポインタのとき
+ _Opcode_Func_AddressOf( name, *pUserProc );
+ }
+ resultType.SetBasicType( DEF_PTR_VOID );
+ }
+}
+void Opcode_Func_SizeOf( const string &typeName ){
+ Type tempType;
+ if( !compiler.StringToType( typeName, tempType ) ){
+ SetError(3,typeName,cp);
+ return;
+ }
+
+ int typeSize = ( tempType.IsObject() ) ?
+ tempType.GetClass().GetSize() : tempType.GetSize();
+
+ //mov eax,size
+ compiler.codeGenerator.op_mov_RV( REG_EAX, typeSize );
+}
+void Opcode_Func_VarPtr( const char *Parameter, Type &resultType, bool isCallOn ){
+ if( isCallOn == false ){
+ // 戻り値の型を取得するだけ
+
+ //変数のアドレスを取得
+ if(!GetVarType( Parameter, resultType, true )) return;
+
+ resultType.PtrLevelUp();
+
+ return;
+ }
+
+ RELATIVE_VAR RelativeVar;
+
+ //変数のアドレスを取得
+ if(!GetVarOffsetReadOnly( Parameter, &RelativeVar, resultType )) return;
+
+ int beforeType = resultType.GetBasicType();
+
+ resultType.PtrLevelUp();
+
+ SetVarPtrToEax(&RelativeVar);
+}
+void Opcode_Func_ObjPtr( const char *Parameter, Type &resultType, bool isCallOn ){
+ if( isCallOn == false ){
+ // 戻り値の型を取得するだけ
+
+ //変数のアドレスを取得
+ if(!GetVarType( Parameter, resultType, true )) return;
+
+ resultType.PtrLevelUp();
+
+ return;
+ }
+
+ RELATIVE_VAR RelativeVar;
+
+ //変数のアドレスを取得
+ if(!GetVarOffsetReadOnly( Parameter, &RelativeVar, resultType )) return;
+
+ int beforeType = resultType.GetBasicType();
+
+ resultType.PtrLevelUp();
+
+ SetVarPtrToEax(&RelativeVar);
+
+ if( lstrcmpi( Parameter, "This" )==0 ){
+ // Thisの場合は特別にオブジェクトポインタが返ってくるので、何もせずに抜ける
+ }
+ else if( beforeType == DEF_OBJECT ){
+ //参照をオブジェクトポインタに変更
+
+ //mov eax,dword ptr[eax]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
+ }
+ else{
+ SetError(134,NULL,cp );
+ }
+}
+
+void Opcode_Func_delegate_call( const char *paramsStr, Type &resultType, bool isDynamicCall, bool isCallOn )
+{
+ if( isCallOn )
+ {
+ int i = 0;
+ char methodPtrParamStr[VN_SIZE];
+ i = GetOneParameter( paramsStr, i, methodPtrParamStr );
+
+ char objPtrValueStr[VN_SIZE]="";
+ if( isDynamicCall )
+ {
+ i = GetOneParameter( paramsStr, i, objPtrValueStr );
+ }
+
+ Opcode_CallDelegate( compiler.pCompilingClass->GetDelegate(), methodPtrParamStr, objPtrValueStr, paramsStr + i );
+ }
+
+ resultType = UserProc::CompilingUserProc().ReturnType();
+}
+void Opcode_Func_System_Get_Bp()
+{
+ //mov eax,ebp
+ compiler.codeGenerator.op_mov_RR(REG_EAX,REG_EBP);
+}
+void Opcode_Func_System_Get_Sp()
+{
+ //mov eax,esp
+ compiler.codeGenerator.op_mov_RR(REG_EAX,REG_ESP);
+}
+
+void Opcode_Func_System_GetComVtbl( const char *parameter )
+{
+ Type classType;
+ compiler.StringToType( parameter, classType );
+
+ // mov eax,com_vtbl
+ compiler.codeGenerator.op_mov_RV_com_vtbl( REG_EAX, &classType.GetClass() );
+}
+void Opcode_Func_System_GetVtblList( const char *parameter )
+{
+ Type classType;
+ compiler.StringToType( parameter, classType );
+
+ // mov eax,com_vtbl
+ compiler.codeGenerator.op_mov_RV_vtbl( REG_EAX, &classType.GetClass() );
+}
+void Opcode_Func_System_GetDefaultConstructor( const char *parameter )
+{
+ Type classType;
+ compiler.StringToType( parameter, classType );
+
+ if( classType.GetClass().GetConstructorMethod() )
+ {
+ //mov eax,ProcAddr
+ compiler.codeGenerator.op_addressof( REG_EAX, &classType.GetClass().GetConstructorMethod()->GetUserProc() );
+ }
+ else
+ {
+ // デフォルトコンストラクタを持たない
+
+ //xor eax,eax
+ compiler.codeGenerator.op_zero_reg( REG_EAX );
+ }
+}
+void Opcode_Func_System_GetDestructor( const char *parameter )
+{
+ Type classType;
+ compiler.StringToType( parameter, classType );
+
+ //mov eax,ProcAddr
+ compiler.codeGenerator.op_addressof( REG_EAX, &classType.GetClass().GetDestructorMethod()->GetUserProc() );
+}
+
+void Opcode_Func_GetPtrData(const char *Parameter,const int type){
+ Type tempType;
+ if( !NumOpe(Parameter,Type(),tempType) ){
+ return;
+ }
+ if(!tempType.IsWhole()){
+ SetError(11,Parameter,cp);
+ return;
+ }
+ ChangeTypeToLong(tempType.GetBasicType());
+
+ if(type==DEF_DOUBLE){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //fld qword ptr[eax]
+ compiler.codeGenerator.PutOld(
+ (char)0xDD,
+ (char)0x00
+ );
+ }
+ else if(type==DEF_SINGLE||type==DEF_DWORD){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //mov eax,dword ptr[eax]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
+ }
+ else if(type==DEF_QWORD){
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+
+ //mov eax,dword ptr[ecx]
+ compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_ECX,0,MOD_BASE);
+
+ //mov edx,dword ptr[ecx+sizeof(long)]
+ compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EDX,REG_ECX,sizeof(long),MOD_BASE_DISP8);
+ }
+ else if(type==DEF_WORD){
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //xor eax,eax
+ compiler.codeGenerator.op_xor_RR(REG_EAX);
+
+ //mov ax,word ptr[ebx]
+ compiler.codeGenerator.op_mov_RM( sizeof(short), REG_EAX, REG_EBX, 0, MOD_BASE );
+ }
+ else if(type==DEF_BYTE){
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //xor eax,eax
+ compiler.codeGenerator.op_xor_RR(REG_EAX);
+
+ //mov al,byte ptr[ebx]
+ compiler.codeGenerator.op_mov_RM( sizeof(char), REG_EAX, REG_EBX, 0, MOD_BASE );
+ }
+}
+
+bool Opcode_CallFunc( const char *Parameter, const int FuncNum, const Type &baseType, Type &resultType, bool isCallOn )
+{
+ switch(FuncNum){
+ case FUNC_FIX:
+ if( isCallOn ) Opcode_Func_Fix(Parameter);
+ resultType.SetBasicType( DEF_LONG );
+ break;
+ case FUNC_CUDBL:
+ if( isCallOn ) Opcode_Func_CUDbl(Parameter);
+ resultType.SetBasicType( DEF_DOUBLE );
+ break;
+ case FUNC_LEN:
+ if( isCallOn ) Opcode_Func_Len(Parameter);
+ resultType.SetBasicType( DEF_LONG );
+ break;
+ case FUNC_ADDRESSOF:
+ Opcode_Func_AddressOf( Parameter, baseType, isCallOn, resultType );
+ break;
+ case FUNC_SIZEOF:
+ if( isCallOn ) Opcode_Func_SizeOf(Parameter);
+ resultType.SetBasicType( DEF_LONG );
+ break;
+ case FUNC_VARPTR:
+ Opcode_Func_VarPtr( Parameter, resultType, isCallOn );
+ break;
+ case FUNC_OBJPTR:
+ Opcode_Func_ObjPtr( Parameter, resultType, isCallOn );
+ break;
+ case FUNC_DELEGATE_DYNAMICMETHOD_CALL:
+ Opcode_Func_delegate_call( Parameter, resultType, true, isCallOn );
+ break;
+ case FUNC_DELEGATE_STATICMETHOD_CALL:
+ Opcode_Func_delegate_call( Parameter, resultType, false, isCallOn );
+ break;
+ case FUNC_SYSTEM_GET_NOW_SCOPE_CATCH_ADDRESS:
+ if( isCallOn ) Exception::Opcode_Func_System_GetNowScopeCatchAddress();
+ resultType.SetBasicType( DEF_PTR_VOID );
+ break;
+ case FUNC_SYSTEM_GET_NOW_SCOPE_FINALLY_ADDRESS:
+ if( isCallOn ) Exception::Opcode_Func_System_GetNowScopeFinallyAddress();
+ resultType.SetBasicType( DEF_PTR_VOID );
+ break;
+ case FUNC_SYSTEM_GET_BP:
+ if( isCallOn ) Opcode_Func_System_Get_Bp();
+ resultType.SetBasicType( DEF_LONG );
+ break;
+ case FUNC_SYSTEM_GET_SP:
+ if( isCallOn ) Opcode_Func_System_Get_Sp();
+ resultType.SetBasicType( DEF_LONG );
+ break;
+ case FUNC_SYSTEM_GET_COM_VTBL:
+ if( isCallOn ) Opcode_Func_System_GetComVtbl( Parameter );
+ resultType.SetBasicType( DEF_PTR_VOID );
+ break;
+ case FUNC_SYSTEM_GET_VTBL_LIST:
+ if( isCallOn ) Opcode_Func_System_GetVtblList( Parameter );
+ resultType.SetBasicType( DEF_PTR_VOID );
+ break;
+ case FUNC_SYSTEM_GET_DEFAULT_CONSTRUCTOR:
+ if( isCallOn ) Opcode_Func_System_GetDefaultConstructor( Parameter );
+ resultType.SetBasicType( DEF_PTR_VOID );
+ break;
+ case FUNC_SYSTEM_GET_DESTRUCTOR:
+ if( isCallOn ) Opcode_Func_System_GetDestructor( Parameter );
+ resultType.SetBasicType( DEF_PTR_VOID );
+ break;
+
+ case FUNC_GETDOUBLE:
+ if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DOUBLE);
+ resultType.SetBasicType( DEF_DOUBLE );
+ break;
+ case FUNC_GETSINGLE:
+ if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_SINGLE);
+ resultType.SetBasicType( DEF_SINGLE );
+ break;
+ case FUNC_GETQWORD:
+ if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_QWORD);
+ resultType.SetBasicType( DEF_QWORD );
+ break;
+ case FUNC_GETDWORD:
+ if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DWORD);
+ resultType.SetBasicType( DEF_DWORD );
+ break;
+ case FUNC_GETWORD:
+ if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_WORD);
+ resultType.SetBasicType( DEF_WORD );
+ break;
+ case FUNC_GETBYTE:
+ if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_BYTE);
+ resultType.SetBasicType( DEF_BYTE );
+ break;
+ default:
+ return false;
+ }
+ return true;
+}
Index: /trunk/ab5.0/abdev/BasicCompiler32/Compile_Object.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/Compile_Object.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/Compile_Object.cpp (revision 440)
@@ -0,0 +1,359 @@
+#include "stdafx.h"
+
+#include
+
+#include "../BasicCompiler_Common/common.h"
+#include "opcode.h"
+
+void _call_constructor( const CClass *pobj_c, const char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
+ ////////////////////////////
+ // コンストラクタの呼び出し
+ ////////////////////////////
+
+ //この関数を使用する場合は、
+ //・ebxにオブジェクトの個数
+ //・eaxに先頭ポインタ
+ //をセットしておかなければならない
+
+
+/* //jnzのジャンプ先番地
+ extern int obp;
+ int jnz_back = obp;*/
+
+ if(bSomeObjects){
+ SetError();
+
+ //push ebx
+ //compiler.codeGenerator.op_push(REG_EBX);
+ }
+
+ // ※ここでプッシュされた値はコンストラクタのthisポインタとなる
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+
+
+ ////////////////////////
+ // オーバーロードを解決
+ ////////////////////////
+
+ std::vector subs;
+ pobj_c->GetDynamicMethods().Enum( pobj_c->GetName().c_str(), subs );
+
+ const UserProc *pUserProc;
+ if( subs.size() > 0 ){
+ //オーバーロードを解決
+ pUserProc=OverloadSolutionWithStrParam(pobj_c->GetName().c_str(),
+ subs,CreateParameter,"");
+
+ if(!pUserProc) return;
+ }
+
+ {
+ // 動的型情報をセットする
+ // obj._System_SetType( _System_TypeBase_Search( fullName ) )
+ subs.clear();
+ pobj_c->GetDynamicMethods().Enum( "_System_SetType", subs );
+ if( subs.size() == 1 ){
+ char temporary[VN_SIZE];
+ sprintf( temporary, "_System_TypeBase_Search(\"%s\"))", pobj_c->GetFullName().c_str() );
+
+ Opcode_CallProc(temporary,
+ subs[0],
+ PROCFLAG_NEW,"");
+ }
+ else{
+ SetError();
+ }
+
+ // インターフェイスを初期化する
+ // TODO: 実装
+ }
+
+ //コンストラクタを呼び出す
+ Opcode_CallProc(CreateParameter,
+ pUserProc,
+ PROCFLAG_NEW,"");
+
+
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ if(bSomeObjects){
+ /*
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //add eax,TypeSize
+ compiler.codeGenerator.op_add_RV( REG_EAX, ObjectSize );
+
+ //sub ebx,1
+ compiler.codeGenerator.op_sub_RV8(REG_EBX,1);
+
+ //jne ↑
+ compiler.codeGenerator.op_jne( jnz_back-obp, sizeof(long), false, true );
+ */
+ }
+}
+void Operator_New( const CClass &objClass, const char *objectSizeStr, const char *parameter, const Type &baseType )
+{
+ const CClass *pClass = &objClass;
+
+ if( pClass->IsInterface() )
+ {
+ pClass = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr();
+ }
+
+ int typeSize = pClass->GetSize();
+
+ if(pClass->IsAbstract()){
+ //抽象クラスだったとき
+ SetError(125,pClass->GetName(),cp);
+ }
+
+ BOOL bSomeObjects=0;
+ if(objectSizeStr[0]){
+ bSomeObjects=1;
+
+ Type tempType;
+ NumOpe(objectSizeStr,Type(),tempType);
+ if( !tempType.IsWhole() ) SetError(49,NULL,cp);
+ ChangeTypeToLong(tempType.GetBasicType());
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //※添え字上限値であることを考慮
+ //inc eax
+ compiler.codeGenerator.op_inc( REG_EAX );
+
+ //オブジェクトの個数をebxに一時保持
+ //※ebxは関数が呼ばれても不変
+ //mov ebx,eax
+ compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
+
+ //imul eax,size
+ compiler.codeGenerator.op_imul_RV( REG_EAX, typeSize );
+
+ //add eax,OBJECT_HEAD_SIZE
+ compiler.codeGenerator.op_add_RV8( REG_EAX, (char)OBJECT_HEAD_SIZE );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else{
+ //オブジェクトの個数をebxに一時保持
+ //※ebxは関数が呼ばれても不変
+ //mov ebx,1
+ compiler.codeGenerator.op_mov_RV( REG_EBX, 1 );
+
+ //push size + OBJECT_HEAD_SIZE
+ compiler.codeGenerator.op_push_V( typeSize + OBJECT_HEAD_SIZE );
+ }
+
+ if( baseType.IsObject() ){
+ // オブジェクト インスタンス
+ // ※DeleteはGCで処理
+
+ //call _System_GC_malloc_ForObject
+ extern const UserProc *pSub_System_GC_malloc_ForObject;
+ compiler.codeGenerator.op_call(pSub_System_GC_malloc_ForObject);
+ }
+ else{
+ // オブジェクトポインタ
+ // ※明示的なDeleteが必要
+
+ //call _System_GC_malloc_ForObjectPtr
+ extern const UserProc *pSub_System_GC_malloc_ForObjectPtr;
+ compiler.codeGenerator.op_call(pSub_System_GC_malloc_ForObjectPtr);
+ }
+
+
+ /*
+ 確保されたヒープ領域のポインタ（callocの戻り値eax）をpPtrとすると、
+ pPtr[0]=オブジェクトの個数
+ pPtr[1]=オブジェクトのサイズ
+ pPtr[2]=デストラクタの関数ポインタ
+ pPtr[3]=reserve
+ */
+
+
+ //mov dword ptr[eax],ebx（オブジェクトの個数）
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EBX, REG_EAX, 0, MOD_BASE );
+
+ //add eax,sizeof(long)
+ compiler.codeGenerator.op_add_RV8( REG_EAX, sizeof(long) );
+
+ //mov ecx,TypeSize
+ compiler.codeGenerator.op_mov_RV( REG_ECX, typeSize );
+
+ //mov dword ptr[eax],ecx（オブジェクトのサイズ）
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
+
+ //add eax,sizeof(long)
+ compiler.codeGenerator.op_add_RV8( REG_EAX, sizeof(long) );
+
+
+ const CMethod *method = pClass->GetDestructorMethod();
+ if( method == NULL ) return;
+
+ //mov ecx,DestructorProcAddr
+ compiler.codeGenerator.op_addressof( REG_ECX, &method->GetUserProc() );
+
+ //mov dword ptr[eax],ecx（デストラクタの関数ポインタ）
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
+
+ //add eax,sizeof(long)
+ compiler.codeGenerator.op_add_RV8( REG_EAX, sizeof(long) );
+
+
+ // リザーブ領域
+ //add eax,sizeof(long)
+ compiler.codeGenerator.op_add_RV8( REG_EAX, sizeof(long) );
+
+
+ //仮想関数テーブルを初期化
+ if( pClass->IsExistVirtualFunctions()
+ && !pClass->IsAbstract() )
+ {
+ // mov ecx,com_vtbl
+ compiler.codeGenerator.op_mov_RV_com_vtbl( REG_ECX, pClass );
+
+ //mov dword ptr[eax],ecx
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
+
+ // mov rcx,vtblAddress
+ compiler.codeGenerator.op_mov_RV_vtbl( REG_ECX, pClass );
+
+ //mov qword ptr[rax+sizeof(com_vtbl)],rcx
+ compiler.codeGenerator.op_mov_MR(sizeof(long),REG_ECX,REG_EAX,PTR_SIZE,MOD_BASE_DISP8);
+
+ // 仮想関数になるメソッドに使用チェックをつける
+ BOOST_FOREACH( const CMethod *pMethod, pClass->GetDynamicMethods() )
+ {
+ if( pMethod->IsVirtual() )
+ {
+ pMethod->GetUserProc().Using();
+ }
+ }
+ BOOST_FOREACH( const ::Interface *pInterface, pClass->GetInterfaces() )
+ {
+ BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() )
+ {
+ if( pMethod->IsVirtual() )
+ {
+ pMethod->GetUserProc().Using();
+ }
+ }
+ }
+ }
+
+
+ // ※ここでプッシュされた値はNew演算子の戻り値となる
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+
+ /////////////////////////////////////////////////////////////////////
+
+ ////////////////////////////
+ // コンストラクタの呼び出し
+ ////////////////////////////
+
+ _call_constructor(pClass,parameter,typeSize,bSomeObjects);
+}
+void OpcodeDelete(const char *Parameter, bool isSweeping){
+ Type tempType;
+ if( !NumOpe(Parameter,Type(),tempType) ){
+ return;
+ }
+ if(!( tempType.IsObjectPtr() || tempType.IsVoidPtr() )) SetError(122,NULL,cp);
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //sub eax,sizeof(DWORD)*3
+ compiler.codeGenerator.op_sub_RV8( REG_EAX, OBJECT_HEAD_SIZE );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+
+ //mov ebx,dword ptr[eax]（オブジェクトの個数）
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EBX, REG_EAX, 0, MOD_BASE );
+
+ //add eax,sizeof(long)
+ compiler.codeGenerator.op_add_RV8( REG_EAX, sizeof(long) );
+
+
+ //mov esi,dword ptr[eax]（オブジェクトのサイズ）
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ESI, REG_EAX, 0, MOD_BASE );
+
+ //add eax,sizeof(long)
+ compiler.codeGenerator.op_add_RV8( REG_EAX, sizeof(long) );
+
+
+ //mov edx,dword ptr[eax]（デストラクタの関数ポインタ）
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_EAX, 0, MOD_BASE );
+
+ //add eax,sizeof(long)
+ compiler.codeGenerator.op_add_RV8( REG_EAX, sizeof(long) );
+
+
+ // リザーブ領域
+ //add eax,sizeof(long)
+ compiler.codeGenerator.op_add_RV8( REG_EAX, sizeof(long) );
+
+
+ //mov ecx,eax
+ compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EAX );
+
+
+ //jnzの番地
+ /*extern int obp;
+ int jnz_back = obp;*/
+
+ //push ecx
+ compiler.codeGenerator.op_push(REG_ECX);
+
+ //push edx
+ compiler.codeGenerator.op_push(REG_EDX);
+
+ //push ecx（Thisポインタ ※隠れた第一パラメータ）
+ compiler.codeGenerator.op_push(REG_ECX);
+
+ //call edx
+ compiler.codeGenerator.op_call_R( REG_EDX );
+
+ //pop edx
+ compiler.codeGenerator.op_pop(REG_EDX);
+
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+
+ //add ecx,esi
+ compiler.codeGenerator.op_add_RR( REG_ECX, REG_ESI );
+
+ //sub ebx,1
+ compiler.codeGenerator.op_sub_RV8(REG_EBX,1);
+
+ //jne ↑
+ //compiler.codeGenerator.op_jne( jnz_back-obp, sizeof(long), false, true );
+
+
+ //////////////////////////////////////////
+ // オブジェクトメンバ変数用のメモリを解放
+ //////////////////////////////////////////
+
+ if( isSweeping ){
+ //call _System_GC_free_for_SweepingDelete
+ extern const UserProc *pSub_System_GC_free_for_SweepingDelete;
+ compiler.codeGenerator.op_call(pSub_System_GC_free_for_SweepingDelete);
+ }
+ else{
+ //call free
+ extern const UserProc *pSub_free;
+ compiler.codeGenerator.op_call(pSub_free);
+ }
+}
Index: /trunk/ab5.0/abdev/BasicCompiler32/Compile_ProcOp.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/Compile_ProcOp.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/Compile_ProcOp.cpp (revision 440)
@@ -0,0 +1,781 @@
+#include "stdafx.h"
+
+#include
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "../BasicCompiler_Common/common.h"
+#include "Opcode.h"
+
+
+void SystemProc( const UserProc &userProc ){
+ if( userProc.GetName() == "_System_GetEip" ){
+ //mov eax,dword ptr[esp]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
+
+ //ret
+ compiler.codeGenerator.op_ret();
+ }
+ else if( userProc.GetName() == "_System_InitDllGlobalVariables" ){
+ ////////////////////////////////////////
+ // DLLのグローバル領域をコンパイル
+ ////////////////////////////////////////
+
+ if( !compiler.IsDll() ){
+ //ret
+ compiler.codeGenerator.op_ret();
+
+ return;
+ }
+
+ const UserProc *pBackUserProc;
+ pBackUserProc = &UserProc::CompilingUserProc();
+ UserProc::CompileStartForGlobalArea();
+
+ int BackCp;
+ BackCp=cp;
+ cp=-1;
+
+ extern BOOL bDebugCompile;
+ if(bDebugCompile){
+ //デバッグ用の変数を定義
+ DebugVariable();
+ }
+
+ //GC用の変数を定義
+ InitGCVariables();
+
+ //_System_StartupProgramの呼び出し
+ extern const UserProc *pSub_System_StartupProgram;
+ compiler.codeGenerator.op_call(pSub_System_StartupProgram);
+
+ //クラスに属する静的メンバを定義
+ compiler.GetObjectModule().meta.GetClasses().InitStaticMember();
+
+ GetGlobalDataForDll();
+
+ UserProc::CompileStartForUserProc( pBackUserProc );
+ cp=BackCp;
+
+ //ret
+ compiler.codeGenerator.op_ret();
+ }
+ else if( userProc.GetName() == "_System_InitStaticLocalVariables" ){
+ //静的ローカルオブジェクトのコンストラクタ呼び出し
+
+ BOOST_FOREACH( Variable *pVar, compiler.GetObjectModule().meta.GetGlobalVars() ){
+ if(memicmp(pVar->GetName().c_str(),"Static%",7)==0){
+ //コンストラクタ呼び出し
+ if( pVar->GetType().IsObject() ){
+
+ //エラー用
+ cp=pVar->source_code_address;
+
+ CallConstructor(
+ pVar->GetName().c_str(),
+ pVar->GetSubscripts(),
+ pVar->GetType(),
+ pVar->GetParamStrForConstructor().c_str());
+ }
+ }
+ }
+
+ //ret
+ compiler.codeGenerator.op_ret();
+ }
+ else if( userProc.GetName() == "_System_Call_Destructor_of_GlobalObject" ){
+
+ const UserProc *pBackUserProc;
+ pBackUserProc = &UserProc::CompilingUserProc();
+ UserProc::CompileStartForGlobalArea();
+
+ compiler.codeGenerator.lexicalScopes.CallDestructorsOfScopeEnd();
+
+ UserProc::CompileStartForUserProc( pBackUserProc );
+
+
+ //ret
+ compiler.codeGenerator.op_ret();
+ }
+ else if( userProc.GetName() == "_allrem" ){
+ //乗除演算用の特殊関数（64ビット整数対応）
+ BYTE Buffer_allrem[]={
+ 0x53,0x57,0x33,0xFF,0x8B,0x44,0x24,0x10,0x0B,0xC0,0x7D,0x14,0x47,0x8B,0x54,0x24,0x0C,0xF7,0xD8,0xF7,0xDA,0x83,0xD8,0x00,0x89,0x44,0x24,0x10,0x89,0x54,0x24,0x0C,0x8B,0x44,0x24,0x18,0x0B,0xC0,0x7D,0x13,0x8B,0x54,0x24,0x14,0xF7,0xD8,0xF7,0xDA,0x83,0xD8,0x00,0x89,0x44,0x24,0x18,0x89,0x54,0x24,0x14,0x0B,0xC0,0x75,0x1B,0x8B,0x4C,0x24,0x14,0x8B,0x44,0x24,0x10,0x33,0xD2,0xF7,0xF1,0x8B,0x44,0x24,0x0C,0xF7,0xF1,0x8B,0xC2,0x33,0xD2,0x4F,0x79,0x4E,0xEB,0x53,0x8B,0xD8,0x8B,0x4C,0x24,0x14,0x8B,0x54,0x24,0x10,0x8B,0x44,0x24,0x0C,0xD1,0xEB,0xD1,0xD9,0xD1,0xEA,0xD1,0xD8,0x0B,0xDB,0x75,0xF4,0xF7,0xF1,0x8B,0xC8,0xF7,0x64,0x24,0x18,0x91,0xF7,0x64,0x24,0x14,0x03,0xD1,0x72,0x0E,0x3B,0x54,0x24,0x10,0x77,0x08,0x72,0x0E,0x3B,0x44,0x24,0x0C,0x76,0x08,0x2B,0x44,0x24,0x14,0x1B,0x54,0x24,0x18,0x2B,0x44,0x24,0x0C,0x1B,0x54,0x24,0x10,0x4F,0x79,0x07,0xF7,0xDA,0xF7,0xD8,0x83,0xDA,0x00,0x5F,0x5B,0xC2,0x10,0x00
+ };
+
+ compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_allrem, 178 ) );
+ }
+ else if( userProc.GetName() == "_aullrem" ){
+ //乗除演算用の特殊関数（64ビット整数対応）
+ BYTE Buffer_aullrem[]={
+ 0x53,0x8B,0x44,0x24,0x14,0x0B,0xC0,0x75,0x18,0x8B,0x4C,0x24,0x10,0x8B,
+ 0x44,0x24,0x0C,0x33,0xD2,0xF7,0xF1,0x8B,0x44,0x24,0x08,0xF7,0xF1,0x8B,
+ 0xC2,0x33,0xD2,0xEB,0x50,0x8B,0xC8,0x8B,0x5C,0x24,0x10,0x8B,0x54,0x24,
+ 0x0C,0x8B,0x44,0x24,0x08,0xD1,0xE9,0xD1,0xDB,0xD1,0xEA,0xD1,0xD8,0x0B,
+ 0xC9,0x75,0xF4,0xF7,0xF3,0x8B,0xC8,0xF7,0x64,0x24,0x14,0x91,0xF7,0x64,
+ 0x24,0x10,0x03,0xD1,0x72,0x0E,0x3B,0x54,0x24,0x0C,0x77,0x08,0x72,0x0E,
+ 0x3B,0x44,0x24,0x08,0x76,0x08,0x2B,0x44,0x24,0x10,0x1B,0x54,0x24,0x14,
+ 0x2B,0x44,0x24,0x08,0x1B,0x54,0x24,0x0C,0xF7,0xDA,0xF7,0xD8,0x83,0xDA,
+ 0x00,0x5B,0xC2,0x10,0x00
+ };
+
+ compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_aullrem, 117 ) );
+ }
+ else if( userProc.GetName() == "_allmul" ){
+ //乗算用の特殊関数（64ビット整数対応）
+ BYTE Buffer_allmul[]={
+ 0x8B,0x44,0x24,0x08,0x8B,0x4C,0x24,0x10,0x0B,0xC8,0x8B,0x4C,0x24,0x0C,0x75,0x09,0x8B,0x44,0x24,0x04,0xF7,0xE1,0xC2,0x10,0x00,0x53,0xF7,0xE1,0x8B,0xD8,0x8B,0x44,0x24,0x08,0xF7,0x64,0x24,0x14,0x03,0xD8,0x8B,0x44,0x24,0x08,0xF7,0xE1,0x03,0xD3,0x5B,0xC2,0x10,0x00
+ };
+
+ compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_allmul, 52 ) );
+ }
+ else if( userProc.GetName() == "_alldiv" ){
+ //除算用の特殊関数（64ビット整数対応）
+ BYTE Buffer_alldiv[]={
+ 0x57,0x56,0x53,0x33,0xFF,0x8B,0x44,0x24,0x14,0x0B,0xC0,0x7D,0x14,0x47,0x8B,0x54,0x24,0x10,0xF7,0xD8,0xF7,0xDA,0x83,0xD8,0x00,0x89,0x44,0x24,0x14,0x89,0x54,0x24,0x10,0x8B,0x44,0x24,0x1C,0x0B,0xC0,0x7D,0x14,0x47,0x8B,0x54,0x24,0x18,0xF7,0xD8,0xF7,0xDA,0x83,0xD8,0x00,0x89,0x44,0x24,0x1C,0x89,0x54,0x24,0x18,0x0B,0xC0,0x75,0x18,0x8B,0x4C,0x24,0x18,0x8B,0x44,0x24,0x14,0x33,0xD2,0xF7,0xF1,0x8B,0xD8,0x8B,0x44,0x24,0x10,0xF7,0xF1,0x8B,0xD3,0xEB,0x41,0x8B,0xD8,0x8B,0x4C,0x24,0x18,0x8B,0x54,0x24,0x14,0x8B,0x44,0x24,0x10,0xD1,0xEB,0xD1,0xD9,0xD1,0xEA,0xD1,0xD8,0x0B,0xDB,0x75,0xF4,0xF7,0xF1,0x8B,0xF0,0xF7,0x64,0x24,0x1C,0x8B,0xC8,0x8B,0x44,0x24,0x18,0xF7,0xE6,0x03,0xD1,0x72,0x0E,0x3B,0x54,0x24,0x14,0x77,0x08,0x72,0x07,0x3B,0x44,0x24,0x10,0x76,0x01,0x4E,0x33,0xD2,0x8B,0xC6,0x4F,0x75,0x07,0xF7,0xDA,0xF7,0xD8,0x83,0xDA,0x00,0x5B,0x5E,0x5F,0xC2,0x10,0x00
+ };
+
+ compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_alldiv, 170 ) );
+ }
+ else if( userProc.GetName() == "_aulldiv" ){
+ //整数除算用の特殊関数（64ビット整数対応）
+ BYTE Buffer_aulldiv[]={
+ 0x53,0x56,0x8B,0x44,0x24,0x18,0x0B,0xC0,0x75,0x18,0x8B,0x4C,0x24,0x14,
+ 0x8B,0x44,0x24,0x10,0x33,0xD2,0xF7,0xF1,0x8B,0xD8,0x8B,0x44,0x24,0x0C,
+ 0xF7,0xF1,0x8B,0xD3,0xEB,0x41,0x8B,0xC8,0x8B,0x5C,0x24,0x14,0x8B,0x54,
+ 0x24,0x10,0x8B,0x44,0x24,0x0C,0xD1,0xE9,0xD1,0xDB,0xD1,0xEA,0xD1,0xD8,
+ 0x0B,0xC9,0x75,0xF4,0xF7,0xF3,0x8B,0xF0,0xF7,0x64,0x24,0x18,0x8B,0xC8,
+ 0x8B,0x44,0x24,0x14,0xF7,0xE6,0x03,0xD1,0x72,0x0E,0x3B,0x54,0x24,0x10,
+ 0x77,0x08,0x72,0x07,0x3B,0x44,0x24,0x0C,0x76,0x01,0x4E,0x33,0xD2,0x8B,
+ 0xC6,0x5E,0x5B,0xC2,0x10,0x00
+ };
+
+ compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_aulldiv, 104 ) );
+ }
+ else if( userProc.GetName() == "_allshl" ){
+ //符号あり左ビットシフト用の特殊関数（64ビット整数対応）
+ BYTE Buffer_allshl[]={
+ 0x80,0xF9,0x40,0x73,0x15,0x80,0xF9,0x20,0x73,0x06,0x0F,0xA5,0xC2,0xD3,0xE0,0xC3,0x8B,0xD0,0x33,0xC0,0x80,0xE1,0x1F,0xD3,0xE2,0xC3,0x33,0xC0,0x33,0xD2,0xC3
+ };
+
+ compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_allshl, 31 ) );
+ }
+ else if( userProc.GetName() == "_allshr" ){
+ //符号あり右ビットシフト用の特殊関数（64ビット整数対応）
+ BYTE Buffer_allshr[]={
+ 0x80,0xF9,0x40,0x73,0x16,0x80,0xF9,0x20,0x73,0x06,0x0F,0xAD,0xD0,0xD3,0xFA,0xC3,0x8B,0xC2,0xC1,0xFA,0x1F,0x80,0xE1,0x1F,0xD3,0xF8,0xC3,0xC1,0xFA,0x1F,0x8B,0xC2,0xC3
+ };
+
+ compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_allshr, 33 ) );
+ }
+ else if( userProc.GetName() == "_aullshr" ){
+ //符号なし右ビットシフト用の特殊関数（64ビット整数対応）
+ BYTE Buffer_aullshr[]={
+ 0x80,0xF9,0x40, //cmp cl,40h
+ 0x73,0x15, //jae RETZERO (0040d71a)
+ 0x80,0xF9,0x20, //cmp cl,20h
+ 0x73,0x06, //jae MORE32 (0040d710)
+ 0x0F,0xAD,0xD0, //shrd eax,edx,cl
+ 0xD3,0xEA, //shr edx,cl
+ 0xC3, //ret
+ //MORE32:
+ 0x8B,0xC2, //mov eax,edx
+ 0x33,0xD2, //xor edx,edx
+ 0x80,0xE1,0x1F, //and cl,1Fh
+ 0xD3,0xE8, //shr eax,cl
+ 0xC3, //ret
+ //RETZERO:
+ 0x33,0xC0, //xor eax,eax
+ 0x33,0xD2, //xor edx,edx
+ 0xC3 //ret
+ };
+
+ compiler.codeGenerator.PutOld( NativeCode( (const char *)Buffer_aullshr, 31 ) );
+ }
+ else{
+ SetError();
+ }
+}
+void AutoGeneration( const UserProc &userProc){
+ if( userProc.GetName() == "InitializeUserTypes"
+ && userProc.HasParentClass()
+ && userProc.GetParentClass().GetName() == "_System_TypeBase" ){
+
+ compiler.GetObjectModule().meta.GetClasses().Compile_System_InitializeUserTypes();
+ }
+ else if( userProc.GetName() == "InitializeUserTypesForBaseType"
+ && userProc.HasParentClass()
+ && userProc.GetParentClass().GetName() == "_System_TypeBase" )
+ {
+ compiler.GetObjectModule().meta.GetClasses().Compile_System_InitializeUserTypesForBaseType();
+ }
+ else if( userProc.GetName() == "RegisterGlobalRoots"
+ && userProc.HasParentClass()
+ && userProc.GetParentClass().GetName() == "_System_CGarbageCollection" ){
+
+ Compile_AddGlobalRootsForGc();
+ }
+ else if( userProc.GetName() == compiler.globalAreaProcName ){
+ ////////////////////////////////////////
+ // グローバル領域をコンパイル
+ ////////////////////////////////////////
+
+ UserProc::pGlobalProc = &userProc;
+
+ const UserProc *pBackUserProc = &UserProc::CompilingUserProc();
+ UserProc::CompileStartForGlobalArea();
+
+ int BackCp = cp;
+ cp=-1;
+
+ //クラスに属する静的メンバを定義
+ compiler.GetObjectModule().meta.GetClasses().InitStaticMember();
+
+ //グローバル実行領域をコンパイル開始
+ CompileBuffer(0,0);
+
+ //Goto未知ラベルスケジュールが存在したらエラーにする
+ BOOST_FOREACH( const GotoLabelSchedule *pGotoLabelSchedule, compiler.codeGenerator.gotoLabelSchedules )
+ {
+ if(pGotoLabelSchedule->GetName().size()>0){
+ SetError(6,pGotoLabelSchedule->GetName(),pGotoLabelSchedule->GetSourceCodePos());
+ }
+ else{
+ char temporary[255];
+ sprintf(temporary,"%d",pGotoLabelSchedule->GetLineNum());
+ SetError(6,temporary,pGotoLabelSchedule->GetSourceCodePos());
+ }
+ }
+
+ UserProc::CompileStartForUserProc( pBackUserProc );
+ cp=BackCp;
+ }
+ else if( userProc.HasParentClass()
+ && userProc.IsCastOperator()
+ && userProc.ReturnType().IsInterface() )
+ {
+ // インターフェイス型にキャストするためのメソッド
+
+ int vtblMasterListIndex = userProc.GetParentClass().GetVtblMasterListIndex( &userProc.ReturnType().GetClass() );
+
+ char temporary[1024];
+ sprintf( temporary,
+ "Return New %s(ObjPtr( This ),Get_LONG_PTR( (Get_LONG_PTR( ObjPtr(This)+SizeOf(VoidPtr) ) + SizeOf(LONG_PTR)*%d) As VoidPtr ) As VoidPtr )",
+ userProc.ReturnType().GetClass().GetName().c_str(),
+ vtblMasterListIndex
+ );
+ MakeMiddleCode( temporary );
+
+ ChangeOpcode( temporary );
+ }
+ else{
+ SetError();
+ }
+}
+
+void _compile_proc(const UserProc *pUserProc)
+{
+ extern char *basbuf;
+ extern HANDLE hHeap;
+ extern BOOL bDebugCompile;
+ int i3,i4,BaseOffset;
+ char temporary[VN_SIZE];
+
+ if( pUserProc->GetLocalVars().size() ){
+ SetError();
+ return;
+ }
+
+ trace_for_sourcecodestep( "★★★ " << pUserProc->GetFullName() << "のコンパイルを開始" );
+
+ pUserProc->CompleteCompile();
+
+ extern BOOL bSystemProc;
+ if(memcmp(pUserProc->GetName().c_str(),"_System_",8)==0) bSystemProc=1;
+ else bSystemProc=0;
+
+ extern BOOL bDebugSupportProc;
+ if(memcmp(pUserProc->GetName().c_str(),"_DebugSys_",10)==0){
+ if(!bDebugCompile){
+ return;
+ }
+ bDebugSupportProc=1;
+ }
+ else bDebugSupportProc=0;
+
+ if( pUserProc->GetCodeSize() != 0 || pUserProc->GetNativeCode().GetSize() != 0 )
+ {
+ // 既にコード生成が行われている場合はエラー
+ SetError();
+ }
+
+ //コンパイル中の関数が属するクラス
+ compiler.pCompilingClass = pUserProc->GetParentClassPtr();
+
+ //コンパイルスタートをクラス管理クラスに追加
+ compiler.GetObjectModule().meta.GetClasses().StartCompile( pUserProc );
+
+ //コンパイル中の関数
+ UserProc::CompileStartForUserProc( pUserProc );
+
+ // コンパイル中の関数が属する名前空間
+ compiler.GetNamespaceSupporter().SetLivingNamespaceScopes( pUserProc->GetNamespaceScopes() );
+
+ // コンパイル中の関数でImportsされている名前空間
+ compiler.GetNamespaceSupporter().SetImportedNamespaces( pUserProc->GetImportedNamespaces() );
+
+ // コード生成対象を選択
+ compiler.codeGenerator.Select( (const_cast(pUserProc))->GetNativeCode() );
+
+ if(pUserProc->IsSystem()){
+ ////////////////////
+ // 特殊関数
+ ////////////////////
+
+ extern int AllLocalVarSize;
+ AllLocalVarSize=0;
+
+ SystemProc(*pUserProc);
+ return;
+ }
+
+ if( !pUserProc->IsAutoGeneration() )
+ {
+ cp=pUserProc->GetCodePos();
+ for(;;cp++){
+ if(IsCommandDelimitation(basbuf[cp])) break;
+ }
+ cp--;
+ }
+
+ //ローカル変数に関する情報
+ extern int AllLocalVarSize;
+ AllLocalVarSize=0;
+
+ //パラメータ用の変数データを考慮
+ for(i3=(int)pUserProc->RealParams().size()-1;i3>=0;i3--){
+ Parameter ¶m = *pUserProc->RealParams()[i3];
+
+ Variable *pVar = new Variable( param.GetVarName(), param, false, param.IsRef(), "", false );
+
+ if( param.IsArray() ){
+ pVar->SetArray( param.GetSubscripts() );
+ }
+
+ int varSize;
+ if( param.IsRef() == false && param.IsStruct() ){
+ //構造体のByValパラメータ
+ pVar->ThisIsParameter();
+ varSize=PTR_SIZE;
+ }
+ else{
+ if( param.IsArray() == false ){
+ varSize = pVar->GetMemorySize();
+ }
+ else{
+ varSize=PTR_SIZE;
+ }
+ }
+ AllLocalVarSize+=varSize;
+ pVar->SetOffsetAddress( AllLocalVarSize );
+
+ //レキシカルスコープ情報
+ pVar->SetScopeLevel( compiler.codeGenerator.lexicalScopes.GetNowLevel() );
+ pVar->SetScopeStartAddress( compiler.codeGenerator.lexicalScopes.GetStartAddress() );
+ pVar->isLiving = true;
+
+ pUserProc->GetLocalVars().push_back( pVar );
+ }
+
+ //Thisポインタを示すローカルオフセット値をセット
+ extern int LocalVar_ThisPtrOffset;
+ LocalVar_ThisPtrOffset=AllLocalVarSize;
+
+ BaseOffset=AllLocalVarSize;
+
+ //ret用のアドレスを考慮
+ AllLocalVarSize+=sizeof(long);
+
+
+ ///////////////////////
+ // ここからコード生成
+
+ //sub esp,AllLocalVarSize（スケジュール）
+ const PertialSchedule *pAllLocalVarPertialSchedule = compiler.codeGenerator.op_sub_esp( 0, true );
+
+ //push ebp
+ compiler.codeGenerator.op_push(REG_EBP);
+
+ //mov ebp,esp
+ compiler.codeGenerator.op_mov_RR( REG_EBP, REG_ESP );
+
+ //push ebx
+ compiler.codeGenerator.op_push(REG_EBX);
+
+ //push esi
+ compiler.codeGenerator.op_push( REG_ESI );
+
+ //push edi
+ compiler.codeGenerator.op_push( REG_EDI );
+
+ if( !pUserProc->ReturnType().IsNull() ){
+ //戻り値が存在するとき
+
+ const char *temp = pUserProc->GetName().c_str();
+ if( temp[0]==1&&temp[1]==ESC_OPERATOR ){
+ temp = "_System_ReturnValue";
+ }
+
+ if( pUserProc->ReturnType().IsStruct() ){
+ //戻り値用の構造体（値型）はパラメータで引き渡される
+ }
+ else{
+ if( pUserProc->ReturnType().IsObject() ){
+ sprintf(temporary,"%s=Nothing%c%c%s",temp,1,ESC_AS, compiler.TypeToString( pUserProc->ReturnType() ).c_str() );
+ }
+ else{
+ //戻り値用の変数の定義
+ sprintf(temporary,"%s%c%c%s",temp,1,ESC_AS, compiler.TypeToString( pUserProc->ReturnType() ).c_str() );
+ }
+
+ OpcodeDim(temporary,0);
+ }
+ }
+
+ //プロシージャ抜け出しスケジュール（Exit Sub/Function）
+ compiler.codeGenerator.exitSubCodePositions.clear();
+
+ //ラベル管理オブジェクトを初期化
+ compiler.codeGenerator.gotoLabels.clear();
+
+ //Gotoラベルスケジュール
+ compiler.codeGenerator.gotoLabelSchedules.clear();
+
+ //With情報のメモリを確保
+ extern WITHINFO WithInfo;
+ WithInfo.ppName=(char **)HeapAlloc(hHeap,0,1);
+ WithInfo.pWithCp=(int *)HeapAlloc(hHeap,0,1);
+ WithInfo.num=0;
+
+ //重複エラー情報管理のメモリを確保
+ extern char **SynonymErrorWords;
+ extern int SynonymErrorNum;
+ SynonymErrorNum=0;
+ SynonymErrorWords=(char **)HeapAlloc(hHeap,0,1);
+
+ //Continueアドレスを初期化
+ compiler.codeGenerator.ClearContinueArea();
+
+ //レキシカルスコープ情報を初期化
+ compiler.codeGenerator.lexicalScopes.Init( compiler.codeGenerator.GetNativeCodeSize() );
+
+ const PertialSchedule *pEspOffsetPertialSchedule = NULL;
+ if(bDebugCompile&&bDebugSupportProc==0){
+ //push dword ptr[ebp+(AllLocalVarSize-BaseOffset)]（スケジュール）
+ pEspOffsetPertialSchedule = compiler.codeGenerator.op_push_M( REG_EBP, 0, Schedule::None, true );
+
+ //push dword ptr[ebp]（以前のebp）
+ compiler.codeGenerator.op_push_M( REG_EBP );
+
+ //call _DebugSys_StartProc
+ extern const UserProc *pSub_DebugSys_StartProc;
+ compiler.codeGenerator.op_call(pSub_DebugSys_StartProc);
+ }
+
+ if(compiler.pCompilingClass){
+ if( pUserProc->GetName() == compiler.pCompilingClass->GetName() ){
+ ////////////////////////////////////
+ // コンストラクタをコンパイルするとき
+ ////////////////////////////////////
+
+ //コンストラクタのコンパイル開始を通知
+ compiler.pCompilingClass->NotifyStartConstructorCompile();
+
+ //基底クラスかどうかの識別
+ //（継承元がインターフェイスの場合も基底クラスと見なす）
+ BOOL bThisIsSuperClass;
+ if( !compiler.pCompilingClass->HasSuperClass() ) bThisIsSuperClass=1;
+ else if( compiler.pCompilingClass->GetSuperClass().GetConstructorMethod() == NULL ){
+ //インターフェイスを継承したときはコンストラクタを持たない
+ bThisIsSuperClass=1;
+ }
+ else bThisIsSuperClass=0;
+
+ if(!bThisIsSuperClass){
+ /* サブクラスコンストラクタをコンパイルしているときは、
+ 基底クラスのコンストラクタを呼び出す */
+
+ i3=cp+1;
+ while(IsCommandDelimitation(basbuf[i3])) i3++;
+ for(i4=0;;i3++,i4++){
+ if(!IsVariableChar(basbuf[i3])){
+ temporary[i4]=0;
+ break;
+ }
+ temporary[i4]=basbuf[i3];
+ }
+ if( compiler.pCompilingClass->GetSuperClass().GetName() == temporary ){
+ //基底クラスのコンストラクタを呼び出す
+ cp=i3;
+ for(i4=0;;cp++,i4++){
+ if(IsCommandDelimitation(basbuf[cp])){
+ temporary[i4]=0;
+ break;
+ }
+ temporary[i4]=basbuf[cp];
+ }
+ if(!(temporary[0]=='('&&temporary[lstrlen(temporary)-1]==')')){
+ SetError(1,NULL,cp);
+ }
+ RemoveStringPare(temporary);
+
+ Type dummyType;
+ CallProc( PROC_DEFAULT
+ , &compiler.pCompilingClass->GetSuperClass().GetConstructorMethod()->GetUserProc()
+ , compiler.pCompilingClass->GetSuperClass().GetConstructorMethod()->GetUserProc().GetName().c_str()
+ , temporary
+ , Type() // baseTypeはなし
+ , dummyType
+ );
+ }
+ else{
+ //基底クラスのコンストラクタを暗黙的に呼び出す
+ Opcode_CallProc("",
+ &compiler.pCompilingClass->GetSuperClass().GetConstructorMethod()->GetUserProc(),
+ 0,
+ ""
+ );
+ }
+ }
+ }
+ else if( pUserProc->IsDestructor() ){
+ //デストラクタをコンパイルしたとき
+
+ //デストラクタのコンパイル開始を通知
+ compiler.pCompilingClass->NotifyStartDestructorCompile();
+ }
+ }
+
+ //////////////////////////////////////////
+ //////////////////////////////////////////
+ ////// プロシージャ内をコンパイル ////////
+ if( pUserProc->IsAutoGeneration() ){
+ AutoGeneration( *pUserProc );
+ }
+ else{
+ if(pUserProc->IsMacro()){
+ CompileBuffer(ESC_ENDMACRO,0);
+ }
+ else{
+ if(pUserProc->IsSub()){
+ CompileBuffer(ESC_ENDSUB,0);
+ }
+ else if(pUserProc->IsFunction()){
+ CompileBuffer(ESC_ENDFUNCTION,0);
+ }
+ }
+ }
+ //////////////////////////////////////////
+ //////////////////////////////////////////
+
+ if( compiler.pCompilingClass ){
+
+ if( compiler.pCompilingClass->IsCompilingConstructor() ){
+ // コンストラクタをコンパイルしていたとき
+
+ // コンストラクタのコンパイルが完了したことを通知
+ compiler.pCompilingClass->NotifyFinishConstructorCompile();
+ }
+ else if( pUserProc->IsDestructor() ){
+ ////////////////////////////////////
+ //デストラクタをコンパイルしたとき
+ ////////////////////////////////////
+
+ // デストラクタのコンパイルが完了したことを通知
+ compiler.pCompilingClass->NotifyFinishDestructorCompile();
+
+ if( compiler.pCompilingClass->HasSuperClass() ){
+ /* サブクラスのデストラクタをコンパイルしているときは、
+ 基底クラスのデストラクタを呼び出す */
+
+ const CMethod *method = compiler.pCompilingClass->GetSuperClass().GetDestructorMethod();
+ if( method ){
+ Opcode_CallProc("",
+ &method->GetUserProc(),
+ 0,
+ ""
+ );
+ }
+ }
+ }
+ }
+
+ //With情報のメモリを解放
+ for(i3=0;i3ReturnType().IsNull() ){
+ //戻り値をeax、edxに設定
+ RELATIVE_VAR RelativeVar;
+
+ const char *temp = pUserProc->GetName().c_str();
+ if( temp[0]==1 && temp[1]==ESC_OPERATOR ){
+ temp="_System_ReturnValue";
+ }
+ GetVarOffsetReadWrite(temp,&RelativeVar,Type());
+
+ const Type &returnType = pUserProc->ReturnType();
+ if( returnType.IsObject() || returnType.IsStruct() )
+ {
+ SetVarPtrToEax(&RelativeVar);
+ if( returnType.IsObject() )
+ {
+ //mov eax,dword ptr[eax]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
+ }
+ }
+ else if( returnType.IsReal() )
+ {
+ //fld qword ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_fld_base_offset( returnType.GetBasicType(), REG_EBP, RelativeVar.offset, Schedule::None, true )
+ );
+ }
+ else if( returnType.Is64() )
+ {
+ //mov eax,dword ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EBP, RelativeVar.offset, MOD_BASE_DISP32, Schedule::None, true )
+ );
+
+ //mov edx,dword ptr[ebp+offset+sizeof(long)]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_EBP, RelativeVar.offset+sizeof(long), MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+ else if( returnType.GetSize() == sizeof(long) )
+ {
+ //mov eax,dword ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EBP, RelativeVar.offset, MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+ else if( returnType.GetSize() == sizeof(short) )
+ {
+ //xor eax,eax（eaxを0に初期化する）
+ compiler.codeGenerator.op_zero_reg(REG_EAX);
+
+ //mov ax,word ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_RM( sizeof(short), REG_EAX, REG_EBP, RelativeVar.offset, MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+ else if( returnType.GetSize() == sizeof(char) )
+ {
+ //xor eax,eax（eaxを0に初期化する）
+ compiler.codeGenerator.op_zero_reg(REG_EAX);
+
+ //mov al,byte ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_RM( sizeof(char), REG_EAX, REG_EBP, RelativeVar.offset, MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+ else
+ {
+ SetError();
+ }
+ }
+
+ //ローカル変数アドレススケジュール
+ BOOST_FOREACH( const PertialSchedule *pPertialSchedule, compiler.codeGenerator.localVarPertialSchedules )
+ {
+ compiler.codeGenerator.opfix_offset( pPertialSchedule, AllLocalVarSize );
+ }
+ compiler.codeGenerator.localVarPertialSchedules.clear();
+ BOOST_FOREACH( Variable *pVar, pUserProc->GetLocalVars() ){
+ //後にデバッグで利用する
+ pVar->SetOffsetAddress( AllLocalVarSize - pVar->GetOffsetAddress() );
+ }
+
+ //push ebp、ret用のアドレスを考慮
+ AllLocalVarSize-=sizeof(long)*2;
+
+ //ローカル変数用メモリを確保するためのスケジュール（subコマンド）
+ compiler.codeGenerator.opfix( pAllLocalVarPertialSchedule, AllLocalVarSize - BaseOffset );
+
+ //pop edi
+ compiler.codeGenerator.op_pop( REG_EDI );
+
+ //pop esi
+ compiler.codeGenerator.op_pop( REG_ESI );
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ if(bDebugCompile){
+ //cmp esp,ebp
+ compiler.codeGenerator.op_cmp_RR( REG_ESP, REG_EBP );
+
+ //je 6（次のcallとbreakpointを飛び越す）
+ compiler.codeGenerator.op_je( 6 );
+
+ //call _esp_error
+ extern const UserProc *pSub_esp_error;
+ compiler.codeGenerator.op_call( pSub_esp_error );
+
+ breakpoint;
+ }
+
+ //mov esp,ebp
+ compiler.codeGenerator.op_mov_RR( REG_ESP, REG_EBP );
+
+ //pop ebp
+ compiler.codeGenerator.op_pop(REG_EBP);
+
+ //add esp AllLocalVarSize
+ compiler.codeGenerator.op_add_esp(AllLocalVarSize-BaseOffset);
+
+ if( BaseOffset==0 || pUserProc->IsCdecl() ){
+ //ret
+ compiler.codeGenerator.op_ret();
+ }
+ else{
+ //ret BaseOffset（パラメータ分のスタック領域を解放）
+ compiler.codeGenerator.op_ret( (_int16)BaseOffset );
+ }
+
+
+ //重複エラー情報管理のメモリを解放
+ for(i3=0;i3
+
+#include
+
+#include "../BasicCompiler_Common/common.h"
+#include "Opcode.h"
+
+BOOL IsUse_ecx(RELATIVE_VAR *pRelativeVar){
+ if(pRelativeVar->bOffsetOffset||pRelativeVar->dwKind==VAR_DIRECTMEM) return 1;
+ return 0;
+}
+
+void SetStructVariable( const Type &varType, const Type &calcType, BOOL bUseHeap){
+ if( calcType.IsStruct() ){
+ if( varType.GetClass().IsEquals( &calcType.GetClass() ) ){ //等しい
+
+ //双方のオブジェクト型が一致、または派生・継承関係にあるとき
+ //※コピーを行う
+
+ int object_size = varType.GetClass().GetSize();
+
+ //mov ecx,object_size
+ compiler.codeGenerator.op_mov_RV(REG_ECX,object_size);
+
+ //pop esi
+ compiler.codeGenerator.op_pop(REG_ESI);
+
+ //pop edi
+ compiler.codeGenerator.op_pop(REG_EDI);
+
+ if(bUseHeap){
+ //mov eax,esi
+ compiler.codeGenerator.op_mov_RR(REG_EAX,REG_ESI);
+ }
+
+ //rep movs byte ptr[edi],byte ptr[esi]
+ compiler.codeGenerator.op_rep_movs(sizeof(BYTE));
+
+ if(bUseHeap){
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+ //call free
+ extern const UserProc *pSub_free;
+ compiler.codeGenerator.op_call(pSub_free);
+ }
+
+ return;
+ }
+ }
+
+ SetError(1,NULL,cp);
+}
+
+
+void SetRealVariable(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar){
+ if( !IsRealNumberType( CalcType ) ){
+ // 実数へ変換
+ // 64bit edx:eax -> st(0)
+ // 32bit eax -> st(0)
+
+ if( Is64Type( CalcType ) ){
+ //64ビット整数型
+
+ //push edx
+ compiler.codeGenerator.op_push( REG_EDX );
+
+ //push eax
+ compiler.codeGenerator.op_push( REG_EAX );
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //pop
+ compiler.codeGenerator.op_pop( REG_NON );
+
+ //pop
+ compiler.codeGenerator.op_pop( REG_NON );
+ }
+ else{
+ //push eax
+ compiler.codeGenerator.op_push( REG_EAX );
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //pop
+ compiler.codeGenerator.op_pop( REG_NON );
+ }
+ }
+
+ if(pRelativeVar->dwKind==VAR_GLOBAL){
+ if(pRelativeVar->bOffsetOffset){
+ //fstp ptr[ecx+offset]
+ compiler.codeGenerator.op_fstp_base_offset(VarType,REG_ECX,(int)pRelativeVar->offset, Schedule::GlobalVar );
+ }
+ else{
+ //mov ecx,offset
+ compiler.codeGenerator.op_mov_RV(REG_ECX,(int)pRelativeVar->offset, Schedule::GlobalVar );
+
+ //fstp ptr[ecx]
+ compiler.codeGenerator.op_fstp_basereg(VarType,REG_ECX);
+ }
+ }
+ else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
+ if(pRelativeVar->bOffsetOffset){
+ //add ecx,qword ptr[offset]
+ compiler.codeGenerator.op_add_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32, Schedule::GlobalVar );
+ }
+ else{
+ //mov ecx,qword ptr[offset]
+ compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32, Schedule::GlobalVar );
+ }
+
+ goto directmem;
+ }
+ else if(pRelativeVar->dwKind==VAR_LOCAL){
+ if(pRelativeVar->bOffsetOffset){
+ //fstp ptr[ebp+ecx+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_fstp_base_offset_ex(VarType,REG_EBP,REG_ECX,(int)pRelativeVar->offset,USE_OFFSET, Schedule::None, true )
+ );
+ }
+ else{
+ //fstp ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_fstp_base_offset(VarType,REG_EBP,(int)pRelativeVar->offset, Schedule::None, true )
+ );
+ }
+ }
+ else if(pRelativeVar->dwKind==VAR_REFLOCAL){
+ if(pRelativeVar->bOffsetOffset){
+ //add ecx,qword ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_add_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+ else{
+ //mov ecx,qword ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+
+ goto directmem;
+ }
+ else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
+directmem:
+ //fstp ptr[ecx]
+ compiler.codeGenerator.op_fstp_basereg(VarType,REG_ECX);
+ }
+}
+
+void SetBooleanVariable(int type,RELATIVE_VAR *pRelative){
+ if(type==DEF_DOUBLE){
+ // TODO: 実装
+ SetError();
+ }
+ else if(type==DEF_SINGLE){
+ // TODO: 実装
+ SetError();
+ }
+ else if(type==DEF_INT64||type==DEF_QWORD){
+ //cmp eax,0
+ compiler.codeGenerator.op_cmp_value(sizeof(long),REG_EAX,0);
+
+ //setne al
+ compiler.codeGenerator.op_setne( REG_EAX );
+
+ //cmp edx,0
+ compiler.codeGenerator.op_cmp_value(sizeof(long),REG_EDX,0);
+
+ //setne cl
+ compiler.codeGenerator.op_setne( REG_ECX );
+
+ //or al,cl
+ compiler.codeGenerator.op_or_RR( sizeof( _int8 ), REG_EAX, REG_ECX );
+ }
+ else{
+ if(!IsWholeNumberType(type)){
+ //不正な型の場合
+ SetError(9,NULL,cp);
+ return;
+ }
+ }
+
+ //cmp eax,0
+ compiler.codeGenerator.op_cmp_value(Type(type,-1).GetSize(),REG_EAX,0);
+
+ //setne al
+ compiler.codeGenerator.op_setne( REG_EAX );
+
+ SetWholeVariable( sizeof(char), DEF_BYTE, pRelative );
+}
+
+void ExtendTypeTo32(int type,int reg);
+void ExtendTypeTo64(int type){
+ if(Is64Type(type)) return;
+
+ ExtendTypeTo32(type,REG_EAX);
+
+ if(IsSignedType(type)){
+ //cdq
+ compiler.codeGenerator.op_cdq();
+ }
+ else{
+ //xor edx,edx
+ compiler.codeGenerator.op_zero_reg(REG_EDX);
+ }
+}
+void ExtendTypeTo32(int type,int reg){
+ if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){
+ //movsx reg32,reg16
+ compiler.codeGenerator.op_movsx_R32R16(reg,reg);
+ }
+ else if(type==DEF_WORD){
+ //and reg,0000FFFFh
+ compiler.codeGenerator.op_and_RV(reg,(int)0x0000FFFF);
+ }
+ else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
+ //movsx reg32,reg8
+ compiler.codeGenerator.op_movsx_R32R8(reg,reg);
+ }
+ else if(type==DEF_BYTE||type==DEF_BOOLEAN){
+ //and reg,000000FFh
+ compiler.codeGenerator.op_and_RV(reg,(int)0xFF);
+ }
+}
+void ExtendTypeTo16(int type,int reg){
+ if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
+ //movsx reg16,reg8
+ compiler.codeGenerator.op_movsx_R16R8(reg,reg);
+ }
+ else if(type==DEF_BYTE||type==DEF_BOOLEAN){
+ //and reg,000000FFh
+ compiler.codeGenerator.op_and_RV(reg,(int)0xFF);
+ }
+}
+
+void SetWholeVariable(int varSize,int calcType,RELATIVE_VAR *pRelative){
+ if( IsRealNumberType( calcType ) ){
+ // 実数型から整数型へ変換する
+
+ if( varSize == sizeof(_int64) ){
+ // 64bitへ
+ // st(0) -> edx:eax
+
+ //push
+ //push
+ compiler.codeGenerator.op_sub_esp( PTR_SIZE * 2 );
+
+ //fistp qword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
+
+ //pop eax
+ compiler.codeGenerator.op_pop( REG_EAX );
+
+ //pop edx
+ compiler.codeGenerator.op_pop( REG_EDX );
+ }
+ else{
+ // 32bit
+ // st(0) -> eax
+
+ //push
+ compiler.codeGenerator.op_push( REG_NON );
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+
+ //pop eax
+ compiler.codeGenerator.op_pop( REG_EAX );
+ }
+ }
+ else{
+ //その他の整数
+
+ if(varSize==sizeof(_int64)){
+ //eaxの値を64ビット（edx:eax）に拡張する
+ ExtendTypeTo64(calcType);
+ }
+ else if(varSize==sizeof(long)){
+ //レジスタの値を32ビット（eax）に拡張する
+ ExtendTypeTo32(calcType,REG_EAX);
+ }
+ else if(varSize==sizeof(short)){
+ //レジスタの値を16ビット（ax）に拡張する
+ ExtendTypeTo16(calcType,REG_EAX);
+ }
+ //8ビットは拡張なし
+ }
+
+ if(varSize==sizeof(_int64)){
+ //下位32ビット
+ SetWholeVariable(sizeof(long),DEF_LONG,pRelative);
+
+ //上位32ビット
+
+ //直接参照に切り替え
+ SetVarPtrToEax(pRelative);
+ pRelative->dwKind=VAR_DIRECTMEM;
+
+ //mov ecx,eax
+ compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EAX );
+
+ //add ecx,sizeof(long)
+ compiler.codeGenerator.op_add_RV8( REG_ECX, sizeof(long) );
+
+ //mov eax,edx
+ compiler.codeGenerator.op_mov_RR( REG_EAX, REG_EDX );
+
+ SetWholeVariable(sizeof(long),DEF_LONG,pRelative);
+
+ return;
+ }
+
+ if(pRelative->dwKind==VAR_GLOBAL){
+ if(pRelative->bOffsetOffset){
+ //mov ptr[ecx+offset],eax/ax/al
+ compiler.codeGenerator.op_mov_MR(varSize,REG_EAX,REG_ECX,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::GlobalVar );
+ }
+ else{
+ //mov ptr[offset],eax/ax/al
+ compiler.codeGenerator.op_mov_MR(varSize,REG_EAX,0,(int)pRelative->offset,MOD_DISP32, Schedule::GlobalVar );
+ }
+ }
+ else if(pRelative->dwKind==VAR_REFGLOBAL){
+ // 今は使われていない
+ SetError();
+
+ if(pRelative->bOffsetOffset){
+ //add ecx,qword ptr[offset]
+ compiler.codeGenerator.op_add_RM(varSize,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32, Schedule::GlobalVar );
+ }
+ else{
+ //mov ecx,qword ptr[offset]
+ compiler.codeGenerator.op_mov_RM(varSize,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32, Schedule::GlobalVar );
+ }
+
+ goto directmem;
+ }
+ else if(pRelative->dwKind==VAR_LOCAL){
+ if(pRelative->bOffsetOffset){
+ //mov ptr[ebp+ecx+offset],eax/ax/al
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_MR_ex(varSize,REG_EAX,REG_EBP,REG_ECX,(int)pRelative->offset,USE_OFFSET, Schedule::None, true )
+ );
+ }
+ else{
+ //mov ptr[ebp+offset],eax/ax/al
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_MR(varSize,REG_EAX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+ }
+ else if(pRelative->dwKind==VAR_REFLOCAL){
+ if(pRelative->bOffsetOffset){
+ //add ecx,ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_add_RM(PTR_SIZE,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+ else{
+ //mov ecx,ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_RM(PTR_SIZE,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+
+ goto directmem;
+ }
+ else if(pRelative->dwKind==VAR_DIRECTMEM){
+directmem:
+
+ //mov ptr[ecx],eax/ax/al
+ compiler.codeGenerator.op_mov_MR(varSize,REG_EAX,REG_ECX,0,MOD_BASE);
+ }
+}
Index: /trunk/ab5.0/abdev/BasicCompiler32/Compile_Statement.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/Compile_Statement.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/Compile_Statement.cpp (revision 440)
@@ -0,0 +1,1388 @@
+#include "stdafx.h"
+
+#include
+#include
+
+#include "../BasicCompiler_Common/common.h"
+#include "Opcode.h"
+
+void OpcodeOthers( const char *Command ){
+ int i,i2;
+
+ char leftTerm[8192];
+ int lastParePos = 0;
+ for(i=0;;i++){
+ if(Command[i]=='\"'){
+ //ダブルクォートは不正なのでエラー扱い
+ leftTerm[i]=0;
+ SetError(3,leftTerm,cp);
+ return;
+ }
+
+ if(Command[i]=='('){
+ lastParePos = i;
+ i2=GetStringInPare(leftTerm+i,Command+i);
+ i+=i2-1;
+ continue;
+ }
+ if(Command[i]=='['){
+ i2=GetStringInBracket(leftTerm+i,Command+i);
+ i+=i2-1;
+ continue;
+ }
+ if(Command[i]=='\0'){
+ leftTerm[i] = 0;
+ break;
+ }
+
+ if( IsNumCalcMark( Command, i ) ){
+ leftTerm[i] = 0;
+ break;
+ }
+
+ leftTerm[i]=Command[i];
+ }
+ if(!(
+ IsVariableTopChar(leftTerm[0])||
+ leftTerm[0]=='.'||
+ (leftTerm[0]==1&&leftTerm[1]==ESC_PSMEM)
+ )){
+ SetError(1,NULL,cp);
+ return;
+ }
+
+
+ if(Command[i]=='\0' && lastParePos == 0){
+ //////////////////////////////
+ // パラメータ無しのマクロ検索
+ //////////////////////////////
+
+ const UserProc *pUserProc = GetSubHash(Command);
+
+ //GetSubHash内でエラー提示が行われた場合
+ if(pUserProc==(UserProc *)-1) return;
+
+ if(pUserProc==0){
+ char temporary[VN_SIZE];
+ lstrcpy(temporary,Command);
+
+ CharUpper(temporary);
+ pUserProc=GetSubHash(temporary);
+
+ //GetSubHash内でエラー提示が行われた場合
+ if(pUserProc==(UserProc *)-1) return;
+ }
+
+ if(pUserProc){
+ if( !pUserProc->IsMacro() ){
+ SetError(10,Command,cp);
+ }
+
+ Opcode_CallProc("",pUserProc,0,"");
+
+ return;
+ }
+ }
+ else if(IsNumCalcMark(Command,i)){
+ //代入演算
+ OpcodeCalc(Command);
+ return;
+ }
+
+ Type resultType;
+ bool isLiteral, isNeedHeapFreeStructure = false;
+ bool result = TermOpe( leftTerm, Type(), resultType, isLiteral, isNeedHeapFreeStructure, NULL, true );
+ if( result ){
+
+ /////////////////////
+ // 戻り値の処理
+ /////////////////////
+
+ if( resultType.IsReal() ){
+ //fstp st(0)
+ compiler.codeGenerator.PutOld(
+ (char)0xDD,
+ (char)0xD8
+ );
+ }
+ else if( resultType.IsStruct() ){
+ //mov ebx,eax
+ compiler.codeGenerator.op_mov_RR(REG_EBX,REG_EAX);
+
+ FreeTempObject(REG_EBX,&resultType.GetClass());
+ }
+
+ return;
+ }
+
+ // どこにも当てはまらなかったため、失敗
+ SetError(1,NULL,cp);
+}
+
+void OpcodeIf(char *Parameter){
+ int i,i2;
+ Type tempType;
+
+ for(i=0;;i++){
+ if(Parameter[i]=='\0'){
+ SetError(21,NULL,cp);
+ return;
+ }
+ if(Parameter[i]==1&&Parameter[i+1]==ESC_THEN){
+ Parameter[i]=0;
+ break;
+ }
+ }
+
+ const PertialSchedule *pIfPertialSchedule = NULL;
+ if( !NumOpe(Parameter,Type(DEF_BOOLEAN),tempType) ){
+ //NumOpe内でエラー
+ }
+ else if( tempType.IsDouble() ){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //push 0
+ compiler.codeGenerator.op_push_V(0);
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //add esp,sizeof(double)+sizeof(long)
+ compiler.codeGenerator.op_add_esp(sizeof(double)+sizeof(long));
+
+ //fcompp
+ compiler.codeGenerator.op_fcompp();
+
+ //fnstsw ax
+ compiler.codeGenerator.op_fnstsw_ax();
+
+ //test ah,40
+ compiler.codeGenerator.op_test_ah( (char)0x40 );
+
+ //jne (endif、または else まで)
+ pIfPertialSchedule = compiler.codeGenerator.op_jne( 0, sizeof(long), true );
+ }
+ else if( tempType.IsSingle() ){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //push 0
+ compiler.codeGenerator.op_push_V(0);
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //add esp,sizeof(float)+sizeof(long)
+ compiler.codeGenerator.op_add_esp(sizeof(float)+sizeof(long));
+
+ //fcompp
+ compiler.codeGenerator.op_fcompp();
+
+ //fnstsw ax
+ compiler.codeGenerator.op_fnstsw_ax();
+
+ //test ah,40
+ compiler.codeGenerator.op_test_ah( (char)0x40 );
+
+ //jne (endif、または else まで)
+ pIfPertialSchedule = compiler.codeGenerator.op_jne( 0, sizeof(long), true );
+ }
+ else if( tempType.Is64() ){
+ //64ビット型
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //cmp eax,0
+ compiler.codeGenerator.op_cmp_value( sizeof(long), REG_EAX, 0 );
+
+ //jne
+ const PertialSchedule *pTempPertialSchedule1 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
+
+ //cmp ebx,0
+ compiler.codeGenerator.op_cmp_value( sizeof(long), REG_EBX, 0 );
+
+ //jne
+ const PertialSchedule *pTempPertialSchedule2 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
+
+ //jmp (endif、または else までジャンプ)
+ pIfPertialSchedule = compiler.codeGenerator.op_jmp( 0, sizeof(long), true );
+
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTempPertialSchedule1 );
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTempPertialSchedule2 );
+ }
+ else{
+ //32ビット型
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //cmp eax,0
+ compiler.codeGenerator.op_cmp_value( sizeof(long), REG_EAX, 0 );
+
+ //je (endif、または else まで条件ジャンプ)
+ pIfPertialSchedule = compiler.codeGenerator.op_je( 0, sizeof(long), true );
+ }
+
+
+ /////////////////////////
+ // If内をコード化
+ /////////////////////////
+
+ //レキシカルスコープをレベルアップ
+ compiler.codeGenerator.lexicalScopes.Start(
+ compiler.codeGenerator.GetNativeCodeSize(),
+ LexicalScope::SCOPE_TYPE_IF
+ );
+
+ i2=CompileBuffer(ESC_ENDIF,0);
+
+ //レキシカルスコープをレベルダウン
+ compiler.codeGenerator.lexicalScopes.End();
+
+
+ if( pIfPertialSchedule == NULL ) return;
+
+ if(i2==ESC_ELSE){
+ //jmp (endifまで)
+ const PertialSchedule *pTempPertialSchedule = compiler.codeGenerator.op_jmp( 0, sizeof(long), true );
+
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pIfPertialSchedule );
+
+
+ /////////////////////////
+ // Else内をコード化
+ /////////////////////////
+
+ //レキシカルスコープをレベルアップ
+ compiler.codeGenerator.lexicalScopes.Start(
+ compiler.codeGenerator.GetNativeCodeSize(),
+ LexicalScope::SCOPE_TYPE_IF
+ );
+
+ CompileBuffer(ESC_ENDIF,0);
+
+ //レキシカルスコープをレベルダウン
+ compiler.codeGenerator.lexicalScopes.End();
+
+
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTempPertialSchedule );
+ }
+ else{
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pIfPertialSchedule );
+ }
+}
+
+int GetLabelAddress(char *LabelName,int LineNum){
+ if(LabelName){
+ BOOST_FOREACH( const GotoLabel &label, compiler.codeGenerator.gotoLabels )
+ {
+ if( label.name.size() > 0 )
+ {
+ if( label.name == LabelName )
+ {
+ return label.address;
+ }
+ }
+ }
+ }
+ else{
+ BOOST_FOREACH( const GotoLabel &label, compiler.codeGenerator.gotoLabels )
+ {
+ if( label.name.size() == 0 )
+ {
+ if( label.line == LineNum )
+ {
+ return label.address;
+ }
+ }
+ }
+ }
+ return -1;
+}
+void OpcodeGoto(char *Parameter){
+ extern HANDLE hHeap;
+ int i,LineNum;
+
+ if(Parameter[0]=='*'){
+ i=GetLabelAddress(Parameter+1,0);
+
+ if( i == -1 )
+ {
+ //jmp ...(schedule)
+ compiler.codeGenerator.op_jmp_goto_schedule( (const std::string)(Parameter + 1), 0, cp );
+ }
+ else
+ {
+ //jmp ...
+ compiler.codeGenerator.op_jmp(
+ i-compiler.codeGenerator.GetNativeCodeSize(),
+ sizeof(long),
+ false,
+ true
+ );
+ }
+ }
+ else{
+ LineNum=atoi(Parameter);
+ i=GetLabelAddress(0,LineNum);
+
+ if( i == -1 )
+ {
+ //jmp ...(schedule)
+ compiler.codeGenerator.op_jmp_goto_schedule( "", LineNum, cp );
+ }
+ else
+ {
+ //jmp ...
+ compiler.codeGenerator.op_jmp(
+ i-compiler.codeGenerator.GetNativeCodeSize(),
+ sizeof(long),
+ false,
+ true
+ );
+ }
+ }
+}
+void OpcodeWhile(char *Parameter){
+ extern HANDLE hHeap;
+
+ //Continueアドレスのバックアップとセット
+ compiler.codeGenerator.ContinueAreaBegin();
+
+ if(!Parameter[0]) SetError(10,"While",cp);
+
+ const PertialSchedule *pWhilePertialSchedule = NULL;
+ Type tempType;
+ if( !NumOpe(Parameter,Type(),tempType) ){
+ //ダミー
+ }
+ else if( tempType.IsDouble() ){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //push 0
+ compiler.codeGenerator.op_push_V(0);
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //add esp,sizeof(double)+sizeof(long)
+ compiler.codeGenerator.op_add_esp(sizeof(double)+sizeof(long));
+
+ //fcompp
+ compiler.codeGenerator.op_fcompp();
+
+ //fnstsw ax
+ compiler.codeGenerator.op_fnstsw_ax();
+
+ //test ah,40
+ compiler.codeGenerator.op_test_ah( (char)0x40 );
+
+ //jne (Wend まで)
+ pWhilePertialSchedule = compiler.codeGenerator.op_jne( 0, sizeof(long), true );
+ }
+ else if( tempType.IsSingle() ){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //push 0
+ compiler.codeGenerator.op_push_V(0);
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //add esp,sizeof(float)+sizeof(long)
+ compiler.codeGenerator.op_add_esp(sizeof(float)+sizeof(long));
+
+ //fcompp
+ compiler.codeGenerator.op_fcompp();
+
+ //fnstsw ax
+ compiler.codeGenerator.op_fnstsw_ax();
+
+ //test ah,40h
+ compiler.codeGenerator.op_test_ah( (char)0x40 );
+
+ //jne (Wend まで)
+ pWhilePertialSchedule = compiler.codeGenerator.op_jne( 0, sizeof(long), true );
+ }
+ else if( tempType.Is64() ){
+ //64ビット型
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //cmp eax,0
+ compiler.codeGenerator.op_cmp_value( sizeof(long), REG_EAX, 0 );
+
+ //jne
+ const PertialSchedule *pTempPertialSchedule1 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
+
+ //cmp ebx,0
+ compiler.codeGenerator.op_cmp_value( sizeof(long), REG_EBX, 0 );
+
+ //jne
+ const PertialSchedule *pTempPertialSchedule2 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
+
+ //jmp (Wendまでジャンプ)
+ pWhilePertialSchedule = compiler.codeGenerator.op_jmp( 0, sizeof(long), true );
+
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTempPertialSchedule1 );
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTempPertialSchedule2 );
+ }
+ else{
+ //その他整数型
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //cmp eax,0
+ compiler.codeGenerator.op_cmp_value( sizeof(long), REG_EAX, 0 );
+
+ //je (Wend まで)
+ pWhilePertialSchedule = compiler.codeGenerator.op_je( 0, sizeof(long), true );
+ }
+
+ //レキシカルスコープをレベルアップ
+ compiler.codeGenerator.lexicalScopes.Start( compiler.codeGenerator.GetNativeCodeSize(), LexicalScope::SCOPE_TYPE_WHILE );
+
+ //While内をコンパイル
+ CompileBuffer(0,COM_WEND);
+
+ compiler.codeGenerator.lexicalScopes.CallDestructorsOfScopeEnd();
+
+ //jmp ...
+ compiler.codeGenerator.op_jmp_continue();
+
+ //レキシカルスコープをレベルダウン
+ compiler.codeGenerator.lexicalScopes.End();
+
+ if( pWhilePertialSchedule )
+ {
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pWhilePertialSchedule );
+ }
+
+ compiler.codeGenerator.ContinueAreaEnd();
+}
+
+char szNextVariable[VN_SIZE];
+void OpcodeFor(char *Parameter){
+ extern HANDLE hHeap;
+ int i,i2;
+ char temporary[VN_SIZE],variable[VN_SIZE],JudgeNum[VN_SIZE],StepNum[VN_SIZE];
+
+ //第１パラメータを取得
+ i=GetOneParameter(Parameter,0,temporary);
+ if(!Parameter[i]){
+ SetError(12,"For",cp);
+ goto ErrorStep;
+ }
+
+ for(i2=0;;i2++){
+ if(temporary[i2]=='='){
+ variable[i2]=0;
+
+ //カウンタ初期化
+ OpcodeCalc(temporary);
+ break;
+ }
+ if(temporary[i2]=='\0'){
+ SetError(12,"For",cp);
+ goto ErrorStep;
+ }
+ variable[i2]=temporary[i2];
+ }
+
+ //jmp ...
+ const PertialSchedule *pTempPertialSchedule = compiler.codeGenerator.op_jmp( 0, sizeof(long), true );
+
+ //Continueアドレスのバックアップとセット
+ compiler.codeGenerator.ContinueAreaBegin();
+
+ //第２パラメータを取得（to～）
+ i=GetOneParameter(Parameter,i,JudgeNum);
+
+ //第３パラメータを取得（step～）
+ if(Parameter[i]){
+ i=GetOneParameter(Parameter,i,StepNum);
+ if(Parameter[i]) SetError(12,"For",cp);
+ }
+ else lstrcpy(StepNum,"1");
+
+ //カウンタを増加させる
+ sprintf(temporary,"%s=(%s)+(%s)",variable,variable,StepNum);
+ OpcodeCalc(temporary);
+
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTempPertialSchedule );
+
+ //増加か減少かを区別する
+ sprintf(temporary,"(%s)>=0",StepNum);
+ NumOpe(temporary,Type(),Type());
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //cmp eax,0
+ compiler.codeGenerator.op_cmp_value( sizeof(long), REG_EAX, 0 );
+
+ //je [カウンタ減少の場合の判定]
+ pTempPertialSchedule = compiler.codeGenerator.op_je( 0, sizeof(long), true );
+
+ //判定（カウンタ増加の場合）
+ sprintf(temporary,"%s<=(%s)",variable,JudgeNum);
+ NumOpe(temporary,Type(),Type());
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //jmp [カウンタ減少の場合の判定を飛び越す]
+ const PertialSchedule *pTempPertialSchedule2 = compiler.codeGenerator.op_jmp( 0, sizeof(long), true );
+
+ //jeジャンプ先のオフセット値
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTempPertialSchedule );
+
+ //判定（カウンタ減少の場合）
+ sprintf(temporary,"%s>=(%s)",variable,JudgeNum);
+ NumOpe(temporary,Type(),Type());
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //jmpジャンプ先のオフセット値
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTempPertialSchedule2 );
+
+ //cmp eax,0
+ compiler.codeGenerator.op_cmp_value( sizeof(long), REG_EAX, 0 );
+
+ErrorStep:
+
+ //je ...
+ pTempPertialSchedule = compiler.codeGenerator.op_je( 0, sizeof(long), true );
+
+ //レキシカルスコープをレベルアップ
+ compiler.codeGenerator.lexicalScopes.Start( compiler.codeGenerator.GetNativeCodeSize(), LexicalScope::SCOPE_TYPE_FOR );
+
+ //For内をコンパイル
+ CompileBuffer(0,COM_NEXT);
+
+ compiler.codeGenerator.lexicalScopes.CallDestructorsOfScopeEnd();
+
+ if(szNextVariable[0]){
+ if(lstrcmp(szNextVariable,variable)!=0){
+ SetError(55,szNextVariable,cp);
+ }
+ }
+
+ //jmp ...
+ compiler.codeGenerator.op_jmp_continue();
+
+ //レキシカルスコープをレベルダウン
+ compiler.codeGenerator.lexicalScopes.End();
+
+ //jeジャンプ先のオフセット値
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTempPertialSchedule );
+
+ //Continueアドレスを復元
+ compiler.codeGenerator.ContinueAreaEnd();
+}
+
+void OpcodeForeach( const char *Parameter )
+{
+ Type resultType;
+ char temporary[VN_SIZE],variable[VN_SIZE],collectionVar[VN_SIZE];
+ bool isError = false;
+
+ //レキシカルスコープをレベルアップ
+ compiler.codeGenerator.lexicalScopes.Start( compiler.codeGenerator.GetNativeCodeSize(), LexicalScope::SCOPE_TYPE_FOR );
+
+ //第１パラメータを取得
+ int i = 0;
+ GetCustomToken( variable, Parameter, i, ESC_IN, true );
+ if(!Parameter[i]){
+ SetError(12,"Foreach",cp);
+ isError = true;
+ goto ErrorStep;
+ }
+ i++;
+
+ //第２パラメータを取得（in～）
+ lstrcpy( collectionVar, Parameter + i );
+
+ if( !GetVarType( variable, resultType, false ) )
+ {
+ Type collectionType;
+ if( !NumOpe_GetType( collectionVar, Type(), collectionType ) )
+ {
+ isError = true;
+ goto ErrorStep;
+ }
+
+ // 未定義の場合は自動的に定義する
+ sprintf(temporary,"%s=Nothing%c%c%s", variable, 1, ESC_AS, collectionType.GetActualGenericType(0).GetClass().GetFullName().c_str() );
+ OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
+ }
+
+ // Resetメソッドを呼び出す
+ sprintf( temporary, "%s.Reset()", collectionVar );
+ Compile( temporary );
+
+ //Continueアドレスのバックアップとセット
+ compiler.codeGenerator.ContinueAreaBegin();
+
+ // MoveNextメソッドを呼び出す
+ sprintf( temporary, "%s.MoveNext()", collectionVar );
+ NumOpe(temporary,Type(),Type());
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //cmp eax,0
+ compiler.codeGenerator.op_cmp_value( sizeof(long), REG_EAX, 0 );
+
+ErrorStep:
+
+ //je ...
+ const PertialSchedule *pTempPertialSchedule = compiler.codeGenerator.op_je( 0, sizeof(long), true );
+
+ if( !isError )
+ {
+ // Currentプロパティから現在の値を取得
+ sprintf( temporary, "%s=%s.Current", variable, collectionVar );
+ Compile( temporary );
+ }
+
+ //For内をコンパイル
+ CompileBuffer(0,COM_NEXT);
+
+ compiler.codeGenerator.lexicalScopes.CallDestructorsOfScopeEnd();
+
+ if(szNextVariable[0]){
+ if(lstrcmp(szNextVariable,variable)!=0){
+ SetError(55,szNextVariable,cp);
+ }
+ }
+
+ if( !isError )
+ {
+ //jmp ...
+ compiler.codeGenerator.op_jmp_continue();
+ }
+
+ //レキシカルスコープをレベルダウン
+ compiler.codeGenerator.lexicalScopes.End();
+
+ //jeジャンプ先のオフセット値
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTempPertialSchedule );
+
+ //Continueアドレスを復元
+ compiler.codeGenerator.ContinueAreaEnd();
+}
+
+void OpcodeDo(char *Parameter){
+ extern HANDLE hHeap;
+ int i,i2,i3;
+
+ if(Parameter[0]) SetError(10,"Do",cp);
+
+ //Continueアドレスのバックアップとセット
+ compiler.codeGenerator.ContinueAreaBegin();
+
+ //レキシカルスコープをレベルアップ
+ compiler.codeGenerator.lexicalScopes.Start( compiler.codeGenerator.GetNativeCodeSize(), LexicalScope::SCOPE_TYPE_DO );
+
+ //Do内をコンパイル
+ CompileBuffer(0,COM_LOOP);
+
+ compiler.codeGenerator.lexicalScopes.CallDestructorsOfScopeEnd();
+
+ const PertialSchedule *pDoPertialSchedule = NULL;
+
+ extern char *basbuf;
+ char temporary[VN_SIZE];
+ for(i=cp-1;;i--){
+ if(IsCommandDelimitation(basbuf[i])){
+ i+=3;
+ if(!(basbuf[i]=='0'||basbuf[i]=='1')){
+ //無条件ループ
+ break;
+ }
+ i3=i;
+
+ for(i+=2,i2=0;;i++,i2++){
+ if(IsCommandDelimitation(basbuf[i])){
+ temporary[i2]=0;
+ break;
+ }
+ temporary[i2]=basbuf[i];
+ }
+
+ Type tempType;
+ NumOpe(temporary,Type(),tempType);
+
+ if( tempType.IsDouble() ){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //push 0
+ compiler.codeGenerator.op_push_V(0);
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //add esp,sizeof(double)+sizeof(long)
+ compiler.codeGenerator.op_add_esp(sizeof(double)+sizeof(long));
+
+ //fcompp
+ compiler.codeGenerator.op_fcompp();
+
+ //fnstsw ax
+ compiler.codeGenerator.op_fnstsw_ax();
+
+ //test ah,40
+ compiler.codeGenerator.op_test_ah( (char)0x40 );
+
+ if(basbuf[i3]=='0'){
+ //While
+
+ //jne 5（ループ終了）
+ pDoPertialSchedule = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
+ }
+ else if(basbuf[i3]=='1'){
+ //Until
+
+ //je 5（ループ終了）
+ pDoPertialSchedule = compiler.codeGenerator.op_je( 0, sizeof(char), true );
+ }
+ }
+ else if( tempType.IsSingle() ){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //push 0
+ compiler.codeGenerator.op_push_V(0);
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //add esp,sizeof(float)+sizeof(long)
+ compiler.codeGenerator.op_add_esp(sizeof(float)+sizeof(long));
+
+ //fcompp
+ compiler.codeGenerator.op_fcompp();
+
+ //fnstsw ax
+ compiler.codeGenerator.op_fnstsw_ax();
+
+ //test ah,40
+ compiler.codeGenerator.op_test_ah( (char)0x40 );
+
+ if(basbuf[i3]=='0'){
+ //While
+
+ //jne 5（ループ終了）
+ pDoPertialSchedule = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
+ }
+ else if(basbuf[i3]=='1'){
+ //Until
+
+ //je 5（ループ終了）
+ pDoPertialSchedule = compiler.codeGenerator.op_je( 0, sizeof(char), true );
+ }
+ }
+ else if( tempType.Is64() ){
+ //64ビット型
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //cmp eax,0
+ compiler.codeGenerator.op_cmp_value( sizeof(long), REG_EAX, 0 );
+
+ //jne
+ const PertialSchedule *pTempPertialSchedule1 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
+
+ //cmp ebx,0
+ compiler.codeGenerator.op_cmp_value( sizeof(long), REG_EBX, 0 );
+
+ //jne
+ const PertialSchedule *pTempPertialSchedule2 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
+
+ if(basbuf[i3]=='0'){
+ //While
+
+ //jmp 5（ループ終了）
+ pDoPertialSchedule = compiler.codeGenerator.op_jmp( 0, sizeof(char), true );
+
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTempPertialSchedule1 );
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTempPertialSchedule2 );
+ }
+ else if(basbuf[i3]=='1'){
+ //Until
+
+ //jmp 2（ループを続ける）
+ const PertialSchedule *pTempPertialSchedule3 = compiler.codeGenerator.op_jmp( 0, sizeof(char), true );
+
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTempPertialSchedule1 );
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTempPertialSchedule2 );
+
+ //jmp 5（ループ終了）
+ pDoPertialSchedule = compiler.codeGenerator.op_jmp( 0, sizeof(char), true );
+
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTempPertialSchedule3 );
+ }
+ }
+ else{
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //cmp eax,0
+ compiler.codeGenerator.op_cmp_value( sizeof(long), REG_EAX, 0 );
+
+ if(basbuf[i3]=='0'){
+ //While
+
+ //je 5（ループ終了）
+ pDoPertialSchedule = compiler.codeGenerator.op_je( 0, sizeof(char), true );
+ }
+ else if(basbuf[i3]=='1'){
+ //Until
+
+ //jne 5（ループ終了）
+ pDoPertialSchedule = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
+ }
+ }
+ break;
+ }
+ }
+
+ //jmp ...
+ compiler.codeGenerator.op_jmp_continue();
+
+ if( pDoPertialSchedule )
+ {
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pDoPertialSchedule );
+ }
+
+ //jmp ...
+ const PertialSchedule *pTempPertialSchedule = compiler.codeGenerator.op_jmp( 0, sizeof(long), true );
+
+ //レキシカルスコープをレベルダウン
+ compiler.codeGenerator.lexicalScopes.End();
+
+ //jmpジャンプ先のオフセット値
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTempPertialSchedule );
+
+ //Continueアドレスを復元
+ compiler.codeGenerator.ContinueAreaEnd();
+}
+void OpcodeContinue(void){
+ //jmp ...(Continue addr)
+ compiler.codeGenerator.op_jmp_continue();
+}
+
+void OpcodeExitSub(void){
+ if( UserProc::IsGlobalAreaCompiling() ){
+ SetError(12,"Exit Sub/Function",cp);
+ return;
+ }
+
+ //未解放のローカルオブジェクトのデストラクタを呼び出す
+ compiler.codeGenerator.lexicalScopes.CallDestructorsOfReturn();
+
+ //jmp ...(End Sub/Function)
+ compiler.codeGenerator.op_jmp_exitsub();
+}
+
+//Caseスケジュール
+class SelectSchedule
+{
+public:
+ SelectSchedule( int typeSize )
+ : typeSize( typeSize )
+ , nowCaseSchedule( 0 )
+ {
+ }
+
+ PertialSchedules casePertialSchedules;
+ int typeSize;
+ int nowCaseSchedule;
+};
+std::vector selectSchedules;
+
+void OpcodeSelect(const char *lpszParms)
+{
+ extern HANDLE hHeap;
+ extern char *basbuf;
+ int i,i2,i3,sw,NowCaseCp;
+ char temporary[VN_SIZE];
+
+ Type type1;
+ bool result = NumOpe(lpszParms,Type(), type1 );
+
+ selectSchedules.push_back( SelectSchedule( type1.GetSize() ) );
+
+ if( result )
+ {
+ if( selectSchedules.back().typeSize < sizeof(long) ){
+ selectSchedules.back().typeSize = sizeof(long);
+ }
+
+ for(i=cp,sw=0;;i++){
+ if(basbuf[i]=='\0'){
+ selectSchedules.pop_back();
+ SetError(22,"Select",cp);
+ return;
+ }
+ if(basbuf[i]==1&&basbuf[i+1]==ESC_SELECTCASE){
+ for(i2=0;;i++){
+ if(basbuf[i]==1&&basbuf[i+1]==ESC_SELECTCASE) i2++;
+ if(basbuf[i]==1&&basbuf[i+1]==ESC_ENDSELECT){
+ i2--;
+ if(i2==0) break;
+ }
+ }
+ continue;
+ }
+ if(basbuf[i]==1&&basbuf[i+1]==ESC_ENDSELECT){
+ if(sw==0){
+ //add esp,CaseTypeSize
+ compiler.codeGenerator.op_add_esp( selectSchedules.back().typeSize );
+ }
+ break;
+ }
+ if(basbuf[i]==1&&basbuf[i+1]==ESC_CASE){
+ NowCaseCp=i;
+
+ i++;
+ while(1){
+ for(i++,i2=0;;i++,i2++){
+ if(basbuf[i]=='\"'){
+ i3=GetStringInQuotation(temporary+i2,basbuf+i);
+ i+=i3-1;
+ i2+=i3-1;
+ continue;
+ }
+ if(basbuf[i]=='('){
+ i3=GetStringInPare(temporary+i2,basbuf+i);
+ i+=i3-1;
+ i2+=i3-1;
+ continue;
+ }
+ if(basbuf[i]=='['){
+ i3=GetStringInBracket(temporary+i2,basbuf+i);
+ i+=i3-1;
+ i2+=i3-1;
+ continue;
+ }
+
+ if(IsCommandDelimitation(basbuf[i])){
+ temporary[i2]=0;
+ break;
+ }
+ if(basbuf[i]==','){
+ temporary[i2]=0;
+ break;
+ }
+
+ temporary[i2]=basbuf[i];
+ }
+
+ //エラー用
+ i2=cp;
+ cp=NowCaseCp;
+
+ Type type2;
+ if( !NumOpe(temporary,type1,type2) ){
+ return;
+ }
+
+ cp=i2;
+
+ if(type1.IsObject()){
+ std::vector subs;
+ type1.GetClass().GetDynamicMethods().Enum( CALC_EQUAL, subs );
+ if( subs.size() == 0 ){
+ return;
+ }
+
+ Parameters params;
+ params.push_back( new Parameter( "", Type( type2 ) ) );
+
+ //オーバーロードを解決
+ const UserProc *pUserProc = OverloadSolution( "==", subs, params, Type( DEF_BOOLEAN ), type1 );
+
+ delete params[0];
+
+ if(!pUserProc){
+ //エラー
+ return;
+ }
+
+
+ //pop edx
+ compiler.codeGenerator.op_pop(REG_EDX);
+
+ //mov ecx,dword ptr[esp]
+ compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_ESP,0,MOD_BASE);
+
+ //push edx
+ compiler.codeGenerator.op_push(REG_EDX);
+
+ //push ecx
+ compiler.codeGenerator.op_push(REG_ECX);
+
+ //call operator_proc ※ ==演算子
+ compiler.codeGenerator.op_call(pUserProc);
+
+ //test eax,eax
+ compiler.codeGenerator.op_test(REG_EAX,REG_EAX);
+
+ //jne ...
+ selectSchedules.back().casePertialSchedules.push_back(
+ compiler.codeGenerator.op_jne( 0, sizeof(long), true )
+ );
+ }
+ else if(type1.IsDouble()){
+ ChangeTypeToDouble(type2.GetBasicType());
+
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,CaseTypeSize
+ compiler.codeGenerator.op_add_esp(selectSchedules.back().typeSize);
+
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //fcompp
+ compiler.codeGenerator.op_fcompp();
+
+ //fnstsw ax
+ compiler.codeGenerator.op_fnstsw_ax();
+
+ //test ah,40
+ compiler.codeGenerator.op_test_ah( (char)0x40 );
+
+ //jne ...
+ selectSchedules.back().casePertialSchedules.push_back(
+ compiler.codeGenerator.op_jne( 0, sizeof(long), true )
+ );
+ }
+ else if(type1.IsSingle()){
+ ChangeTypeToSingle(type2.GetBasicType());
+
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //add esp,CaseTypeSize
+ compiler.codeGenerator.op_add_esp(selectSchedules.back().typeSize);
+
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //fcompp
+ compiler.codeGenerator.op_fcompp();
+
+ //fnstsw ax
+ compiler.codeGenerator.op_fnstsw_ax();
+
+ //test ah,40
+ compiler.codeGenerator.op_test_ah( (char)0x40 );
+
+ //jne ...
+ selectSchedules.back().casePertialSchedules.push_back(
+ compiler.codeGenerator.op_jne( 0, sizeof(long), true )
+ );
+ }
+ else{
+ //その他整数型
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //mov eax,dword ptr[esp]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
+
+ //cmp eax,ebx
+ compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
+
+ //je ...
+ selectSchedules.back().casePertialSchedules.push_back(
+ compiler.codeGenerator.op_je( 0, sizeof(long), true )
+ );
+ }
+
+ if(basbuf[i]!=',') break;
+ }
+ }
+ if(basbuf[i]==1&&basbuf[i+1]==ESC_CASEELSE){
+ sw=1;
+
+ //jmp ...
+ selectSchedules.back().casePertialSchedules.push_back(
+ compiler.codeGenerator.op_jmp( 0, sizeof(long), true )
+ );
+ }
+ }
+ }
+
+ //レキシカルスコープをレベルアップ
+ compiler.codeGenerator.lexicalScopes.Start( compiler.codeGenerator.GetNativeCodeSize(), LexicalScope::SCOPE_TYPE_SELECT );
+
+ //Select Case内をコンパイル
+ CompileBuffer(ESC_ENDSELECT,0);
+
+ //jmp EndSelect
+ selectSchedules.back().casePertialSchedules.push_back(
+ compiler.codeGenerator.op_jmp( 0, sizeof(long), true )
+ );
+
+ //最終スケジュール
+ for(i=selectSchedules.back().nowCaseSchedule;i<(int)selectSchedules.back().casePertialSchedules.size();i++){
+ compiler.codeGenerator.opfix_JmpPertialSchedule( selectSchedules.back().casePertialSchedules[i] );
+ }
+
+ //レキシカルスコープをレベルダウン
+ compiler.codeGenerator.lexicalScopes.End();
+
+ selectSchedules.pop_back();
+}
+void OpcodeCase(char *Parameter){
+ int i;
+
+ if(selectSchedules.back().typeSize==-1){
+ SetError(30,"Case",cp);
+ return;
+ }
+
+ //jmp EndSelect
+ selectSchedules.back().casePertialSchedules.push_back(
+ compiler.codeGenerator.op_jmp( 0, sizeof(long), true )
+ );
+
+ i=0;
+ while(1){
+ //Caseスケジュール
+ compiler.codeGenerator.opfix_JmpPertialSchedule( selectSchedules.back().casePertialSchedules[selectSchedules.back().nowCaseSchedule] );
+ selectSchedules.back().nowCaseSchedule++;
+
+ i=JumpOneParameter(Parameter,i);
+ if(Parameter[i]=='\0') break;
+ }
+
+ //add esp,CaseTypeSize
+ compiler.codeGenerator.op_add_esp(selectSchedules.back().typeSize);
+}
+
+void OpcodeGosub(char *Parameter){
+ extern HANDLE hHeap;
+ int i,LineNum;
+
+ if(Parameter[0]=='*'){
+ i=GetLabelAddress(Parameter+1,0);
+
+ if( i == -1 )
+ {
+ //jmp ...(schedule)
+ compiler.codeGenerator.op_jmp_goto_schedule( (const std::string)(Parameter + 1), 0, cp );
+ }
+ else
+ {
+ //jmp ...
+ compiler.codeGenerator.op_jmp(
+ i-compiler.codeGenerator.GetNativeCodeSize(),
+ sizeof(long),
+ false,
+ true
+ );
+ }
+ }
+ else{
+ LineNum=atoi(Parameter);
+ i=GetLabelAddress(0,LineNum);
+
+ if( i == -1 )
+ {
+ //jmp ...(schedule)
+ compiler.codeGenerator.op_jmp_goto_schedule( "", LineNum, cp );
+ }
+ else
+ {
+ //jmp ...
+ compiler.codeGenerator.op_jmp(
+ i-compiler.codeGenerator.GetNativeCodeSize(),
+ sizeof(long),
+ false,
+ true
+ );
+ }
+ }
+}
+void OpcodeReturn(char *Parameter){
+ if( UserProc::IsGlobalAreaCompiling() ){
+ //Gosub～Returnとして扱う
+
+ //ret
+ compiler.codeGenerator.op_ret();
+ }
+ else{
+ //戻り値をセット
+ if(Parameter[0]){
+ const UserProc &proc = UserProc::CompilingUserProc();
+
+ const char *temp = "_System_ReturnValue";
+ if(proc.GetName()[0]==1&&proc.GetName()[1]==ESC_OPERATOR)
+ {
+ }
+ else{
+ temp=proc.GetName().c_str();
+ }
+
+ char temporary[VN_SIZE];
+ sprintf(temporary,"%s=%s",temp,Parameter);
+ OpcodeCalc(temporary);
+ }
+
+ //プロシージャを抜け出す（C言語のreturnと同様の処理を行う）
+ OpcodeExitSub();
+ }
+}
+
+
+////////////
+// ポインタ
+
+void OpcodeSetPtrData(char *Parameter,int type){
+ int i;
+ char temporary[VN_SIZE];
+
+ if(Parameter[0]=='('){
+ i=JumpStringInPare(Parameter,1);
+ if(Parameter[i+1]=='\0'){
+ for(i=0;;i++){
+ Parameter[i]=Parameter[i+1];
+ if(Parameter[i]=='\0') break;
+ }
+ Parameter[i-1]=0;
+ }
+ }
+
+ //第１パラメータを取得
+ i=GetOneParameter(Parameter,0,temporary);
+ if(!Parameter[i]){
+ SetError(1,NULL,cp);
+ return;
+ }
+
+ Type resultType;
+ if( !NumOpe(temporary,Type(),resultType) ){
+ return;
+ }
+ if(!resultType.IsWhole()){
+ SetError(11,Parameter,cp);
+ return;
+ }
+
+ ChangeTypeToLong( resultType.GetBasicType() );
+
+ //第２パラメータを取得
+ i=GetOneParameter(Parameter,i,temporary);
+ if(Parameter[i]){
+ SetError(1,NULL,cp);
+ return;
+ }
+
+ if( !NumOpe(temporary,Type(),resultType) ){
+ return;
+ }
+
+ if(type==DEF_DOUBLE){
+ ChangeTypeToDouble_ToFpuReg( resultType.GetBasicType() );
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //fstp qword ptr[eax]
+ compiler.codeGenerator.PutOld(
+ (char)0xDD,
+ (char)0x18
+ );
+ }
+ else if(type==DEF_SINGLE){
+ ChangeTypeToSingle( resultType.GetBasicType() );
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //mov dword ptr[eax],ebx
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EBX, REG_EAX, 0, MOD_BASE );
+ }
+ else if(type==DEF_QWORD){
+ ChangeTypeToInt64( resultType.GetBasicType() );
+
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //mov dword ptr[eax],ecx
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
+
+ //mov dword ptr[eax+sizeof(long)],ebx
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EBX, REG_EAX, 0x04, MOD_BASE_DISP8 );
+ }
+ else if(type==DEF_DWORD){
+ ChangeTypeToLong( resultType.GetBasicType() );
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //mov dword ptr[eax],ebx
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EBX, REG_EAX, 0, MOD_BASE );
+ }
+ else if(type==DEF_WORD){
+ ChangeTypeToLong( resultType.GetBasicType() );
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //mov word ptr[eax],bx
+ compiler.codeGenerator.op_mov_MR( sizeof(short), REG_EBX, REG_EAX, 0, MOD_BASE );
+ }
+ else if(type==DEF_BYTE){
+ ChangeTypeToLong( resultType.GetBasicType() );
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //mov byte ptr[eax],bl
+ compiler.codeGenerator.op_mov_MR( sizeof(char), REG_EBX, REG_EAX, 0, MOD_BASE );
+ }
+}
Index: /trunk/ab5.0/abdev/BasicCompiler32/Compile_Var.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/Compile_Var.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/Compile_Var.cpp (revision 440)
@@ -0,0 +1,1361 @@
+#include "stdafx.h"
+
+#include
+
+#include
+#include
+#include
+#include
+
+#include "../BasicCompiler_Common/common.h"
+#include "Opcode.h"
+
+//変数
+// TODO: xml未完成
+int AllLocalVarSize;
+
+
+void SetRelativeOffset( Type &resultType, RELATIVE_VAR *pRelativeVar,const char *lpPtrOffset){
+ PushLongVariable(pRelativeVar);
+
+ Type type;
+ NumOpe( lpPtrOffset, Type(), type );
+ ChangeTypeToLong( type.GetBasicType() );
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ if( resultType.PtrLevel() ){
+ resultType.PtrLevelDown();
+
+ int typeSize = resultType.GetSize();
+ if(typeSize>=2){
+ //imul ebx,i2
+ compiler.codeGenerator.op_imul_RV( REG_EBX, typeSize );
+ }
+ }
+ else{
+ //エラー
+ SetError(1,NULL,cp);
+ return;
+ }
+
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+
+ //add ecx,ebx
+ compiler.codeGenerator.op_add_RR( REG_ECX, REG_EBX );
+}
+void SetRelativeOffset( RELATIVE_VAR &relativeVar ){
+ if(relativeVar.dwKind==VAR_DIRECTMEM){
+ //mov ecx,dword ptr[ecx]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_ECX, 0, MOD_BASE );
+ }
+ else{
+ //直接参照に切り替え
+ SetVarPtrToEax(&relativeVar);
+ relativeVar.dwKind=VAR_DIRECTMEM;
+
+ //mov ecx,dword ptr[eax]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
+ }
+}
+bool GetArrayOffset(const Subscripts &subscripts,char *array, const Type &type){
+ extern HANDLE hHeap;
+ int i,i2,i3,i4;
+ char temporary[VN_SIZE],*pParm[MAX_PARMS];
+
+ for(i=0,i2=0,i3=0;;i++,i2++){
+ if(array[i]=='('){
+ i4=GetStringInPare(temporary+i2,array+i);
+ i+=i4-1;
+ i2+=i4-1;
+ continue;
+ }
+ if(array[i]=='['){
+ i4=GetStringInBracket(temporary+i2,array+i);
+ i+=i4-1;
+ i2+=i4-1;
+ continue;
+ }
+ if(array[i]==','||array[i]=='\0'){
+ if( i3 >= (int)subscripts.size() )
+ {
+ for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
+ return 0;
+ }
+
+ temporary[i2]=0;
+
+ pParm[i3]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
+ lstrcpy(pParm[i3],temporary);
+
+ i3++;
+
+ if(array[i]=='\0'){
+ if( i3 < (int)subscripts.size() )
+ {
+ for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
+ return 0;
+ }
+ break;
+ }
+
+ i2=-1;
+ continue;
+ }
+ temporary[i2]=array[i];
+ }
+
+ //push ecx
+ compiler.codeGenerator.op_push(REG_ECX);
+
+ //push 0
+ compiler.codeGenerator.op_push_V(0);
+
+ for(i=i3-1;i>=0;i--){
+ Type tempType;
+ bool isNeedHeapFreeStructure;
+ NumOpe( pParm[i], Type( DEF_LONG ), tempType, &isNeedHeapFreeStructure );
+ if( tempType.IsObject() )
+ {
+ //キャスト演算子のオーバーロードに対応する
+ CallCastOperatorProc(
+ tempType,
+ isNeedHeapFreeStructure, Type(DEF_LONG) );
+ tempType.SetBasicType( DEF_LONG );
+ }
+ ChangeTypeToLong( tempType.GetBasicType() );
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ for( i2=i+1, i4=1; i2IsNoneAccess()){
+ if(isErrorEnabled) SetError(107,VarName,cp);
+ return false;
+ }
+ }
+ else{
+ if((bPrivateAccess==0&&pMember->IsPrivate())||
+ pMember->IsNoneAccess()){
+ if(isErrorEnabled) SetError(107,VarName,cp);
+ return false;
+ }
+ else if(bPrivateAccess==0&&pMember->IsProtected()){
+ if(isErrorEnabled) SetError(108,VarName,cp);
+ return false;
+ }
+ }
+
+ //Const定義の場合は書き込みアクセスを制限する
+ //※コンストラクタをコンパイル中の場合は例外的に許可する
+ if( pMember->IsConst() && //定数メンバである
+ isWriteAccess && //書き込みアクセスを要求されている
+ objClass.IsCompilingConstructor() == false //コンストラクタ コンパイル中を除く
+ ){
+ //Const定義の変数に書き込みアクセスをしようとした場合
+ SetError(61,VarName,cp);
+ }
+
+ resultType = pMember->GetType();
+
+ // 型パラメータを解決
+ ResolveFormalGenericTypeParameter( resultType, classType );
+
+
+ //ポインタ変数の場合
+ if( resultType.IsPointer() ){
+ if( pMember->GetSubscripts().size() == 0 ){
+ lstrcpy(lpPtrOffset,array);
+ array[0]=0;
+ }
+ }
+ else{
+ if(lpPtrOffset[0]){
+ if(isErrorEnabled) SetError(16,member,cp);
+ return false;
+ }
+ }
+
+ if(offset){
+ //add ecx,offset
+ compiler.codeGenerator.op_add_RV( REG_ECX, offset );
+ }
+
+ if(array[0]){
+ //配列オフセット
+ if(!GetArrayOffset(pMember->GetSubscripts(),array,pMember->GetType())){
+ if(isErrorEnabled) SetError(14,member,cp);
+ return false;
+ }
+ }
+ else if( pMember->GetSubscripts().size() > 0 ){
+ resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
+ }
+
+ if(NestMember[0]){
+ //入れ子構造の場合
+
+ if( resultType.IsObject() || resultType.IsStruct() ){
+ if( refType != RefDot ){
+ if(isErrorEnabled) SetError(104,member,cp);
+ return false;
+ }
+
+ if( resultType.IsObject() ){
+ // 参照内容へのポインタを抽出
+ SetRelativeOffset( *pRelativeVar );
+ }
+ }
+ else if( resultType.IsObjectPtr() || resultType.IsStructPtr() ){
+ //構造体ポインタ型メンバ変数
+
+ if(lpPtrOffset[0]){
+ //pObj[n].member
+ if( ( resultType.IsObjectPtr() || resultType.IsStructPtr() )
+ && refType != RefDot ){
+ if(isErrorEnabled) SetError(104,member,cp);
+ return false;
+ }
+
+ //直接参照に切り替え
+ SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
+ pRelativeVar->dwKind=VAR_DIRECTMEM;
+
+ lpPtrOffset[0]=0;
+ }
+ else{
+ //pObj->member
+ if( ( resultType.IsObjectPtr() || resultType.IsStructPtr() )
+ && refType != RefPointer ){
+ if(isErrorEnabled) SetError(104,member,cp);
+ return false;
+ }
+
+ SetRelativeOffset( *pRelativeVar );
+ }
+ }
+ else if( resultType.GetBasicType() == MAKE_PTR_TYPE(DEF_OBJECT,2)
+ || resultType.GetBasicType() == MAKE_PTR_TYPE(DEF_STRUCT,2)){
+ //構造体ポインタのポインタ型メンバ変数
+
+ if(lpPtrOffset[0]){
+ //ppObj[n]->member
+ if( refType != RefPointer ){
+ if(isErrorEnabled) SetError(104,member,cp);
+ return false;
+ }
+
+ //直接参照に切り替え
+ SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
+ pRelativeVar->dwKind=VAR_DIRECTMEM;
+
+ lpPtrOffset[0]=0;
+
+ //mov ecx,dword ptr[ecx]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_ECX, 0, MOD_BASE );
+ }
+ else{
+ if(isErrorEnabled) SetError(104,member,cp);
+ return false;
+ }
+ }
+
+ if(!_member_offset(
+ isErrorEnabled,
+ isWriteAccess,
+ pMember->GetType(),
+ NestMember,
+ pRelativeVar,
+ resultType,
+ 0)) return false;
+ }
+
+ if(lpPtrOffset[0]){
+ SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
+ pRelativeVar->dwKind=VAR_DIRECTMEM;
+ }
+
+ return true;
+}
+
+int LocalVar_ThisPtrOffset;
+void SetThisPtrToReg(int reg){
+ //自身のオブジェクトのThisポインタをregにコピー
+
+ RELATIVE_VAR RelativeVar;
+ RelativeVar.dwKind=VAR_LOCAL;
+ RelativeVar.bOffsetOffset=0;
+ RelativeVar.offset=-LocalVar_ThisPtrOffset;
+
+ SetReg_WholeVariable(Type(DEF_PTR_VOID),&RelativeVar,reg);
+}
+
+bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType, Subscripts *pResultSubscripts ){
+ char variable[VN_SIZE];
+
+ if(NameBuffer[0]=='.'){
+ GetWithName(variable);
+ lstrcat(variable,NameBuffer);
+ }
+ else lstrcpy(variable,NameBuffer);
+
+ // 名前空間を分離
+ char namespaceStr[VN_SIZE]="", simpleName[VN_SIZE];
+ compiler.GetObjectModule().meta.GetNamespaces().SplitNamespace( variable, namespaceStr, simpleName );
+
+ // 先頭オブジェクトまたはクラス名と入れ子メンバに分割
+ ReferenceKind refType;
+ char member[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
+ GetVarFormatString(simpleName,array,lpPtrOffset,member,refType);
+
+ // 名前空間を分離していた場合は結合
+ char VarName[VN_SIZE];
+ if( namespaceStr[0] ){
+ sprintf( VarName, "%s.%s", namespaceStr, simpleName );
+ }
+ else{
+ lstrcpy( VarName, simpleName );
+ }
+
+ const Subscripts *pSubscripts;
+ bool bConst = false;
+
+
+ if( UserProc::IsLocalAreaCompiling() ){
+ //////////////////
+ // ローカル変数
+ //////////////////
+
+ const Variable *pVar = UserProc::CompilingUserProc().GetLocalVars().BackSearch( Symbol( VarName ) );
+ if( pVar ){
+ //ポインタ変数の場合
+ if( pVar->GetType().IsPointer() ){
+ if( !pVar->IsArray() ){
+ lstrcpy(lpPtrOffset,array);
+ array[0]=0;
+ }
+ }
+ else{
+ if(lpPtrOffset[0]){
+ SetError(16,variable,cp);
+ pRelativeVar->dwKind=NON_VAR;
+ return false;
+ }
+ }
+
+ pRelativeVar->offset=-pVar->GetOffsetAddress();
+ pRelativeVar->bOffsetOffset=0;
+ if( pVar->IsRef() ){
+ // 参照型
+ pRelativeVar->dwKind = VAR_REFLOCAL;
+ }
+ else pRelativeVar->dwKind=VAR_LOCAL;
+ resultType = pVar->GetType();
+ pSubscripts = &pVar->GetSubscripts();
+ bConst = pVar->IsConst();
+
+
+ /////////////////////////////////////////////////////////
+ // ☆★☆ ジェネリクスサポート ☆★☆
+
+ if( resultType.IsTypeParameter() )
+ {
+ // 型パラメータだったとき
+
+ int ptrLevel = PTR_LEVEL( resultType.GetBasicType() );
+
+ // 制約クラス（指定されていないときはObjectクラス）にセットする
+ resultType.SetBasicType( DEF_OBJECT );
+
+ for( int i=0; idwKind=VAR_DIRECTMEM;
+
+ resultType.SetType( DEF_OBJECT, compiler.pCompilingClass );
+ return true;
+ }
+
+ if(memicmp(variable,"This.",5)==0){
+ //Thisオブジェクトのメンバを参照するとき
+ SlideString(variable+5,-5);
+ lstrcpy(VarName,variable);
+ }
+ else{
+ //クラス内の動的メンバを参照するとき（通常）
+
+ if( !compiler.pCompilingClass->HasDynamicMember( VarName ) )
+ {
+ goto NonClassMember;
+ }
+ }
+
+ //Const修飾子のメソッド内でメンバ書き込みアクセスが発生したとき
+ //（コンストラクタ、デストラクタ内を除く）
+ const CMethod *pMethod = compiler.GetObjectModule().meta.GetClasses().GetNowCompilingMethodInfo();
+ if( isWriteAccess &&
+ pMethod->IsConst() &&
+ compiler.pCompilingClass->IsCompilingConstructor() == false &&
+ compiler.pCompilingClass->IsCompilingDestructor() == false
+ ){
+ SetError(131, NULL, cp );
+ }
+
+ /////////////////////////////
+ // thisポインタをecxにセット
+
+ //Thisポインタをecxにコピー
+ SetThisPtrToReg(REG_ECX);
+
+ pRelativeVar->dwKind=VAR_DIRECTMEM;
+ if(!_member_offset(
+ isErrorEnabled,
+ isWriteAccess,
+ Type( DEF_OBJECT, *compiler.pCompilingClass ),
+ variable,
+ pRelativeVar,
+ resultType,1)) return false;
+ return true;
+ }
+
+NonClassMember:
+
+ {
+ const Variable *pVar;
+
+ //////////////////////////
+ // 静的ローカル変数
+ // ※"Static.Object.Method.Variable"
+ //////////////////////////
+
+ char temporary[VN_SIZE];
+ if( UserProc::IsLocalAreaCompiling() ){
+ GetNowStaticVarFullName(VarName,temporary);
+
+ pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( Symbol( temporary ) );
+ if( pVar ){
+ goto GlobalOk;
+ }
+ }
+
+
+ //////////////////////////
+ // クラスの静的メンバ
+ //////////////////////////
+
+ if(member[0]){
+ lstrcpy(temporary,member);
+
+ // TODO: 名前空間を考慮したコードになっていない
+
+ char tempMember[VN_SIZE];
+ char tempArray[VN_SIZE];
+ {
+ ReferenceKind refType;
+ GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember, refType );
+ }
+
+ int typeDefIndex = compiler.GetObjectModule().meta.GetTypeDefs().GetIndex( VarName );
+ if( typeDefIndex != -1 ){
+ // TypeDef後の型名だったとき
+ lstrcpy( VarName, compiler.GetObjectModule().meta.GetTypeDefs()[typeDefIndex].GetBaseName().c_str() );
+ }
+
+ char temp2[VN_SIZE];
+ sprintf(temp2,"%s.%s",VarName,temporary);
+ pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( Symbol( temp2 ) );
+ if( pVar ){
+ lstrcpy(member,tempMember);
+ lstrcpy(array,tempArray);
+ goto GlobalOk;
+ }
+ }
+
+ if(compiler.pCompilingClass){
+ //自身のクラスから静的メンバを参照する場合
+ char temp2[VN_SIZE];
+ sprintf(temp2,"%s.%s",compiler.pCompilingClass->GetName().c_str(),VarName);
+ pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( Symbol( temp2 ) );
+ if( pVar ){
+ goto GlobalOk;
+ }
+ }
+
+ /////////////////////
+ // グローバル変数
+ /////////////////////
+
+ pVar = compiler.GetObjectModule().meta.GetGlobalVars().BackSearch( Symbol( VarName ) );
+ if( pVar ){
+ goto GlobalOk;
+ }
+
+ if(isErrorEnabled) SetError(3,variable,cp);
+ pRelativeVar->dwKind=NON_VAR;
+ return false;
+
+
+
+GlobalOk:
+ //ポインタ変数の場合
+ if( pVar->GetType().IsPointer() ){
+ if( !pVar->IsArray() ){
+ lstrcpy(lpPtrOffset,array);
+ array[0]=0;
+ }
+ }
+ else{
+ if(lpPtrOffset[0]){
+ SetError(16,variable,cp);
+ pRelativeVar->dwKind=NON_VAR;
+ return false;
+ }
+ }
+
+ pRelativeVar->offset=pVar->GetOffsetAddress();
+ pRelativeVar->bOffsetOffset=0;
+ if( pVar->IsRef() ){
+ // 参照型
+ pRelativeVar->dwKind = VAR_REFGLOBAL;
+ }
+ else pRelativeVar->dwKind=VAR_GLOBAL;
+ resultType = pVar->GetType();
+ pSubscripts=&pVar->GetSubscripts();
+ bConst = pVar->IsConst();
+ }
+
+
+
+ok:
+
+ if( bConst && isWriteAccess ){
+ //Const定義の変数に書き込みアクセスをしようとした場合
+ if( resultType.IsObject() ){
+ //オブジェクト定数
+ SetError(130, VarName, cp );
+ }
+ else{
+ //一般のConst変数
+ SetError(61,VarName,cp);
+ }
+ }
+
+ if( array[0] == 0 && pSubscripts->size() > 0 ){
+ //配列の先頭ポインタを示す場合
+ resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
+
+ if( pResultSubscripts )
+ {
+ (*pResultSubscripts) = *pSubscripts;
+ }
+ return true;
+ }
+
+ if(array[0]||member[0]){
+ //xor ecx,ecx（ecxを0に初期化する）
+ //※ecxは変数ベースアドレスからの相対オフセットを示す
+ compiler.codeGenerator.op_zero_reg(REG_ECX);
+
+ pRelativeVar->bOffsetOffset=1;
+ }
+ if(array[0]){
+ if(!GetArrayOffset(*pSubscripts,array,resultType)){
+ SetError(14,variable,cp);
+ pRelativeVar->dwKind=NON_VAR;
+ return false;
+ }
+ }
+ if(member[0]){
+ if( resultType.IsObject() || resultType.IsStruct() ){
+ //実態オブジェクトのメンバを参照（obj.member）
+ if( refType != RefDot ){
+ SetError(104,VarName,cp);
+ pRelativeVar->dwKind=NON_VAR;
+ return false;
+ }
+
+ if( resultType.IsObject() ){
+ // 参照内容へのポインタを抽出
+ SetRelativeOffset( *pRelativeVar );
+ }
+ }
+ else if( resultType.IsObjectPtr() || resultType.IsStructPtr() ){
+ //ポインタオブジェクトが示すメンバを参照
+ if(lpPtrOffset[0]){
+ //pObj[n].member
+ if( refType != RefDot ){
+ SetError(104,VarName,cp);
+ pRelativeVar->dwKind=NON_VAR;
+ return false;
+ }
+ SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
+ pRelativeVar->dwKind=VAR_DIRECTMEM;
+ }
+ else{
+ //pObj->member
+ if( refType != RefPointer ){
+ SetError(104,VarName,cp);
+ pRelativeVar->dwKind=NON_VAR;
+ return false;
+ }
+
+ SetVarPtrToEax(pRelativeVar);
+ pRelativeVar->dwKind=VAR_DIRECTMEM;
+
+ //mov ecx,dword ptr[eax]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
+ }
+ }
+ else if( resultType.GetBasicType()==MAKE_PTR_TYPE(DEF_OBJECT,2) || resultType.GetBasicType()==MAKE_PTR_TYPE(DEF_STRUCT,2)){
+ //ポインタオブジェクトが示すメンバを参照
+ if(lpPtrOffset[0]){
+ //ppObj[n]->member
+ if( refType != RefPointer ){
+ SetError(104,VarName,cp);
+ pRelativeVar->dwKind=NON_VAR;
+ return false;
+ }
+
+ SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
+ pRelativeVar->dwKind=VAR_DIRECTMEM;
+
+
+ SetVarPtrToEax(pRelativeVar);
+
+ //mov ecx,dword ptr[eax]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
+ }
+ else{
+ SetError(104,VarName,cp);
+ pRelativeVar->dwKind=NON_VAR;
+ return false;
+ }
+ }
+ else{
+ SetError(102,VarName,cp);
+ pRelativeVar->dwKind=NON_VAR;
+ return false;
+ }
+
+ Type classType( resultType );
+
+ if(!_member_offset(
+ isErrorEnabled,
+ isWriteAccess,
+ classType,
+ member,pRelativeVar,resultType,0)) return false;
+
+ return true;
+ }
+
+ if(lpPtrOffset[0]){
+ SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
+ pRelativeVar->dwKind=VAR_DIRECTMEM;
+ }
+
+ return true;
+}
+
+bool SetInitGlobalData(int offset,const Type &type,const Subscripts &subscripts,const char *lpszInitBuf){
+ int i2,i3;
+ char temporary[VN_SIZE];
+ char InitBuf[VN_SIZE];
+ lstrcpy( InitBuf, lpszInitBuf );
+
+ if(InitBuf[0]=='['){
+ SlideString(InitBuf+1,-1);
+ InitBuf[lstrlen(InitBuf)-1]=0;
+
+ int typeSize = type.GetSize();
+
+ if( subscripts.size() > 0 ){
+ Subscripts nestSubscripts;
+ for( int i=1; i<(int)subscripts.size(); i++ )
+ {
+ nestSubscripts.push_back( subscripts[i] );
+ }
+
+ typeSize*=JumpSubScripts( nestSubscripts );
+ {
+ int i=0;
+ i2=0;
+ while(1){
+ if( subscripts[0] < i2 ){
+ SetError(41,0,cp);
+ return 0;
+ }
+ i=GetOneParameter(InitBuf,i,temporary);
+ if(!SetInitGlobalData(
+ offset+i2*typeSize,
+ type,
+ nestSubscripts,
+ temporary)) return false;
+ i2++;
+ if(InitBuf[i]=='\0') break;
+ }
+ }
+ return true;
+ }
+
+ if(type.IsStruct()){
+ const CClass &objClass = type.GetClass();
+
+ int i = 0;
+ BOOST_FOREACH( CMember *pMember, objClass.GetDynamicMembers() ){
+ if(InitBuf[i]=='\0'){
+ SetError(41,0,cp);
+ return false;
+ }
+
+ i=GetOneParameter(InitBuf,i,temporary);
+
+ i3=objClass.GetMemberOffset( pMember->GetName().c_str() );
+
+ if(!SetInitGlobalData(offset+i3,
+ pMember->GetType(),
+ pMember->GetSubscripts(),
+ temporary)) return false;
+ }
+ return true;
+ }
+
+ SetError(41,0,cp);
+ return false;
+ }
+
+
+ ///////////////////////////////////////
+ // 単発式（[]で囲まれていない）
+ ///////////////////////////////////////
+
+ if( subscripts.size() > 0 ){
+ SetError(41,0,cp);
+ return false;
+ }
+
+ double dbl;
+ _int64 i64data;
+ Type calcType;
+
+ if( !StaticCalculation(false, InitBuf,type.GetBasicType(),&i64data,calcType) ){
+ //動的データだった場合
+ return false;
+ }
+ if( calcType.IsReal() ){
+ memcpy(&dbl,&i64data,sizeof(double));
+ i64data=(_int64)dbl;
+ }
+ else dbl=(double)i64data;
+
+ //型チェック
+ CheckDifferentType(
+ type,
+ calcType,
+ 0,0);
+
+ if( type.IsDouble() ){
+ compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
+ offset,
+ (const char *)&dbl,
+ sizeof(double)
+ );
+ }
+ else if( type.IsSingle() ){
+ float flt = (float)dbl;
+ compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
+ offset,
+ (const char *)&flt,
+ sizeof(float)
+ );
+ }
+ else if( type.Is64() ){
+ compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
+ offset,
+ (const char *)&i64data,
+ sizeof(_int64)
+ );
+ }
+ else if( type.IsLong() || type.IsDWord() || type.IsPointer() ){
+ if(type.GetBasicType()==typeOfPtrChar){
+ //文字列定数のとき
+
+ char *temp;
+ temp=(char *)i64data;
+ i2=compiler.GetObjectModule().dataTable.AddString(temp,lstrlen(temp));
+ HeapDefaultFree(temp);
+
+ //mov eax,DataPos
+ compiler.codeGenerator.op_mov_RV( REG_EAX, i2, Schedule::DataTable );
+
+ //mov dword ptr[offset],eax
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, 0, offset, MOD_DISP32, Schedule::GlobalVar );
+ }
+ else{
+ long l = (long)i64data;
+ compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
+ offset,
+ (const char *)&l,
+ sizeof(long)
+ );
+ }
+ }
+ else if( type.IsWord() || type.IsInteger() ){
+ short s = (short)i64data;
+ compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
+ offset,
+ (const char *)&s,
+ sizeof(short)
+ );
+ }
+ else if( type.IsSByte() || type.IsByte() || type.IsBoolean() ){
+ char c = (char)i64data;
+ compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
+ offset,
+ (const char *)&c,
+ sizeof(char)
+ );
+ }
+
+ return true;
+}
+bool InitLocalVar(int offset,const Type &type,const Subscripts &subscripts,const char *lpszInitBuf){
+ int i2,i3;
+ char temporary[VN_SIZE];
+ char InitBuf[VN_SIZE];
+ lstrcpy( InitBuf, lpszInitBuf );
+
+ if(InitBuf[0]=='['){
+ SlideString(InitBuf+1,-1);
+ InitBuf[lstrlen(InitBuf)-1]=0;
+
+ int typeSize = type.GetSize();
+
+ if( subscripts.size() > 0 ){
+ Subscripts nestSubscripts;
+ for( int i=1; i<(int)subscripts.size(); i++ )
+ {
+ nestSubscripts.push_back( subscripts[i] );
+ }
+
+ typeSize*=JumpSubScripts( nestSubscripts );
+ {
+ int i=0;
+ i2=0;
+ while(1){
+ if( subscripts[0] < i2 ){
+ SetError(41,0,cp);
+ return 0;
+ }
+ i=GetOneParameter(InitBuf,i,temporary);
+ if(!InitLocalVar(
+ offset+i2*typeSize,
+ type,
+ nestSubscripts,
+ temporary)) return false;
+ i2++;
+ if(InitBuf[i]=='\0') break;
+ }
+ }
+ return true;
+ }
+
+ if(type.IsStruct()){
+ const CClass &objClass = type.GetClass();
+
+ int i = 0;
+ BOOST_FOREACH( CMember *pMember, objClass.GetDynamicMembers() ){
+ if(InitBuf[i]=='\0'){
+ SetError(41,0,cp);
+ return false;
+ }
+
+ i=GetOneParameter(InitBuf,i,temporary);
+
+ i3=objClass.GetMemberOffset( pMember->GetName().c_str() );
+
+ if(!InitLocalVar(offset+i3,
+ pMember->GetType(),
+ pMember->GetSubscripts(),
+ temporary)) return false;
+
+ if(InitBuf[i]=='\0') break;
+ }
+ return true;
+ }
+
+ SetError(41,0,cp);
+ return false;
+ }
+
+
+ ///////////////////////////////////////
+ // 単発式（[]で囲まれていない）
+ ///////////////////////////////////////
+
+ if( subscripts.size() > 0 ){
+ SetError(41,0,cp);
+ return false;
+ }
+
+ double dbl;
+ _int64 i64data;
+ Type calcType;
+
+ if( !StaticCalculation(false, InitBuf,type.GetBasicType(),&i64data,calcType) ){
+ //動的データだった場合
+ return false;
+ }
+ if( calcType.IsReal() ){
+ memcpy(&dbl,&i64data,sizeof(double));
+ i64data=(_int64)dbl;
+ }
+ else dbl=(double)i64data;
+
+ //型チェック
+ CheckDifferentType(
+ type,
+ calcType,
+ 0,0);
+
+ if( type.IsDouble() ){
+ //mov eax,HILONG(dbl)
+ compiler.codeGenerator.op_mov_RV( REG_EAX, *(long *)(((char *)(&dbl))+4) );
+
+ //mov dword ptr[ebp+offset+sizeof(long)],eax
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_EBP, offset+sizeof(long), MOD_BASE_DISP32, Schedule::None, true )
+ );
+
+ //mov eax,LOLONG(dbl)
+ compiler.codeGenerator.op_mov_RV( REG_EAX, *(long *)(&dbl) );
+
+ //mov dword ptr[ebp+offset],eax
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_EBP, offset, MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+ else if( type.IsSingle() ){
+ float flt;
+ flt=(float)dbl;
+
+ //mov eax,InitValue
+ compiler.codeGenerator.op_mov_RV( REG_EAX, *(long *)&flt );
+
+ //mov dword ptr[ebp+offset],eax
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_EBP, offset, MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+ else if( type.Is64() ){
+ //mov eax,HILONG(i64data)
+ compiler.codeGenerator.op_mov_RV( REG_EAX, *(long *)(((char *)(&i64data))+4) );
+
+ //mov dword ptr[ebp+offset+sizeof(long)],eax
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_EBP, offset+sizeof(long), MOD_BASE_DISP32, Schedule::None, true )
+ );
+
+ //mov eax,LOLONG(i64data)
+ compiler.codeGenerator.op_mov_RV( REG_EAX, *(long *)(&i64data) );
+
+ //mov dword ptr[ebp+offset],eax
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_EBP, offset, MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+ else if( type.IsDWord() || type.IsLong() || type.IsPointer() ){
+ if(type.GetBasicType()==typeOfPtrChar){
+ //文字列定数のとき
+
+ char *temp;
+ temp=(char *)i64data;
+ i2=compiler.GetObjectModule().dataTable.AddString(temp,lstrlen(temp));
+ HeapDefaultFree(temp);
+
+ //mov eax,DataPos
+ compiler.codeGenerator.op_mov_RV( REG_EAX, i2, Schedule::DataTable );
+ }
+ else{
+ //mov eax,InitValue
+ compiler.codeGenerator.op_mov_RV( REG_EAX, (long)i64data );
+ }
+
+ //mov dword ptr[ebp+offset],eax
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_EBP, offset, MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+ else if( type.IsWord() || type.IsInteger() ){
+ //mov word ptr[ebp+offset],InitValue
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_MV( sizeof(short), REG_EBP, offset, Schedule::None, true, (long)i64data )
+ );
+ }
+ else if( type.IsSByte() || type.IsByte() || type.IsBoolean() ){
+ //mov byte ptr[ebp+offset],InitValue
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_MV( sizeof(char), REG_EBP, offset, Schedule::None, true, (long)i64data )
+ );
+ }
+
+ return true;
+}
+
+void dim( char *VarName, const Subscripts &subscripts, const Type &type,const char *InitBuf,const char *ConstractParameter,DWORD dwFlags){
+ if( UserProc::IsGlobalAreaCompiling() ){
+ /////////////////////////
+ // グローバル変数
+ /////////////////////////
+
+ AddGlobalVariable(VarName,subscripts,type,InitBuf,ConstractParameter,dwFlags);
+ }
+ else{
+ /////////////////
+ // ローカル変数
+ /////////////////
+
+ if( UserProc::CompilingUserProc().GetLocalVars().DuplicateCheck( Symbol( VarName ) ) ){
+ //２重定義のエラー
+ SetError(15,VarName,cp);
+ return;
+ }
+
+ bool isConst = ( dwFlags & DIMFLAG_CONST ) ? true:false;
+
+ Variable *pVar = new Variable( VarName, type, isConst, false, ConstractParameter, false );
+
+ if( subscripts.size() > 0 ){
+ //配列あり
+ pVar->SetArray( subscripts );
+ }
+
+ //レキシカルスコープ
+ pVar->SetScopeLevel( compiler.codeGenerator.lexicalScopes.GetNowLevel() );
+ pVar->SetScopeStartAddress( compiler.codeGenerator.lexicalScopes.GetStartAddress() );
+ pVar->isLiving = true;
+
+ //エラー用
+ pVar->source_code_address=cp;
+
+ // 変数を追加
+ UserProc::CompilingUserProc().GetLocalVars().push_back( pVar );
+
+ //アラインメントを考慮
+ if( pVar->GetType().IsStruct() ){
+ int alignment = pVar->GetType().GetClass().GetFixedAlignment();
+
+ if( alignment ){
+ if( AllLocalVarSize % alignment ){
+ AllLocalVarSize += alignment - (AllLocalVarSize % alignment);
+ }
+ }
+
+ if( alignment == PTR_SIZE*2 ){
+ // ポインタに要するサイズよりも一回り大きなアラインメントが指定されているとき
+ // （例:CONTEXT構造体など）
+ // 呼び出し側のオフセットズレを考慮する
+
+ if( 0 == ( UserProc::CompilingUserProc().RealParams().GetMemorySize() + PTR_SIZE /* ret分 */ ) % alignment ){
+ AllLocalVarSize += PTR_SIZE;
+ }
+ }
+ }
+
+ AllLocalVarSize += pVar->GetMemorySize();
+ pVar->SetOffsetAddress( AllLocalVarSize );
+
+ //レキシカルスコープ
+ pVar->SetScopeLevel( compiler.codeGenerator.lexicalScopes.GetNowLevel() );
+ pVar->SetScopeStartAddress( compiler.codeGenerator.lexicalScopes.GetStartAddress() );
+ pVar->isLiving = true;
+
+ if(InitBuf[0]){
+ //初期代入時のみ、書き込みアクセスを許可する
+ if( isConst ){
+ pVar->ConstOff();
+ }
+
+ int result = 0;
+ if( !pVar->GetType().IsObject() ){
+ result = InitLocalVar(-pVar->GetOffsetAddress(),
+ pVar->GetType(),
+ pVar->GetSubscripts(),
+ InitBuf);
+ }
+
+ if(!result){
+ //動的な式だった場合は代入演算を行う
+ char temporary[8192];
+ sprintf(temporary,"%s=%s",VarName,InitBuf);
+ OpcodeCalc(temporary);
+ }
+
+ if( isConst ){
+ pVar->ConstOn();
+ }
+ }
+ else{
+ //push 0
+ compiler.codeGenerator.op_push_V(0);
+
+ //push VarSize
+ compiler.codeGenerator.op_push_V( pVar->GetMemorySize() );
+
+ //mov eax,ebp
+ compiler.codeGenerator.op_mov_RR( REG_EAX, REG_EBP );
+
+ //add eax,offset
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_add_RV( REG_EAX, -pVar->GetOffsetAddress(), Schedule::None, true )
+ );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+ //call FillMemory
+ compiler.codeGenerator.op_call( GetDeclareHash("FillMemory") );
+ }
+ }
+
+ //New呼び出し
+ if( type.IsObject()
+ && !type.IsInterface() && !type.IsComInterface()
+ &&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0
+ &&InitBuf[0]=='\0')
+ {
+ char objectSize[255];
+ if( subscripts.size() == 0 ){
+ objectSize[0] = 0;
+ }
+ else{
+ if( subscripts.size() > 1 ){
+ SetError(300,NULL,cp);
+ }
+ sprintf( objectSize, "%d", subscripts[0] );
+ }
+ Operator_New( type.GetClass(), objectSize, ConstractParameter, type );
+
+ //pop eax
+ compiler.codeGenerator.op_pop( REG_EAX );
+
+ RELATIVE_VAR RelativeVar;
+ GetVarOffset( true, false, VarName, &RelativeVar, Type() );
+ if( RelativeVar.dwKind == VAR_DIRECTMEM ){
+ SetError();
+ }
+ SetVariableFromEax( Type( DEF_OBJECT, *compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr() ), DEF_OBJECT, &RelativeVar );
+ }
+}
+
+void SetVarPtrToEax(RELATIVE_VAR *pRelativeVar){
+ if(pRelativeVar->dwKind==VAR_GLOBAL){
+ if(pRelativeVar->bOffsetOffset){
+ //lea eax,dword ptr[ecx+offset]
+ compiler.codeGenerator.op_lea_RM( REG_EAX, REG_ECX, pRelativeVar->offset, MOD_BASE_DISP32, Schedule::GlobalVar );
+ }
+ else{
+ //mov eax,offset
+ compiler.codeGenerator.op_mov_RV( REG_EAX, pRelativeVar->offset, Schedule::GlobalVar );
+ }
+ }
+ else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
+ if(pRelativeVar->bOffsetOffset){
+ //mov eax,ecx
+ compiler.codeGenerator.op_mov_RR( REG_EAX, REG_ECX );
+
+ //add eax,dword ptr[offset]
+ compiler.codeGenerator.op_add_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32, Schedule::GlobalVar );
+ }
+ else{
+ //mov eax,dword ptr[offset]
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32, Schedule::GlobalVar );
+ }
+ }
+ else if(pRelativeVar->dwKind==VAR_LOCAL){
+ if(pRelativeVar->bOffsetOffset){
+ //add ecx,offset
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_add_RV( REG_ECX, pRelativeVar->offset, Schedule::None, true )
+ );
+
+ //lea eax,dword ptr[ebp+ecx]
+ compiler.codeGenerator.PutOld(
+ (char)0x8D,
+ (char)0x44,
+ (char)0x0D,
+ (char)0x00
+ );
+ }
+ else{
+ //lea eax,dword ptr[ecx+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_lea_RM( REG_EAX, REG_EBP, pRelativeVar->offset, MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+ }
+ else if(pRelativeVar->dwKind==VAR_REFLOCAL){
+ if(pRelativeVar->bOffsetOffset){
+ //mov eax,ecx
+ compiler.codeGenerator.op_mov_RR( REG_EAX, REG_ECX );
+
+ //add eax,dword ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_add_RM( sizeof(long), REG_EAX, REG_EBP, pRelativeVar->offset, MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+ else{
+ //mov eax,dword ptr[ebp+offset]
+ compiler.codeGenerator.localVarPertialSchedules.push_back(
+ compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EBP, pRelativeVar->offset, MOD_BASE_DISP32, Schedule::None, true )
+ );
+ }
+ }
+ else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
+ //mov eax,ecx
+ compiler.codeGenerator.op_mov_RR( REG_EAX, REG_ECX );
+ }
+}
+void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar){
+ if( reg != REG_EAX ){
+ SetError();
+ //TODO: 未完成
+ }
+ SetVarPtrToEax( pRelativeVar );
+}
+
+bool Compile_AddGlobalRootsForGc(){
+ const UserProc *pUserProc_AddGlobalRootPtr = GetClassMethod( "_System_CGarbageCollection", "AddGlobalRootPtr" );
+ if( !pUserProc_AddGlobalRootPtr ){
+ SetError(3, "_System_CGarbageCollection.AddGlobalRootPtr", -1 );
+ return false;
+ }
+
+ BOOST_FOREACH( const Variable *pVar, compiler.GetObjectModule().meta.GetGlobalVars() ){
+ if( pVar->GetType().IsObject() || pVar->GetType().IsPointer() || pVar->GetType().IsStruct() ){
+ // オブジェクトまたはポインタだったとき
+ // ※構造体も含む（暫定対応）
+
+ // 変数領域に要するLONG_PTR単位の個数を引き渡す
+ compiler.codeGenerator.op_push_V( pVar->GetMemorySize()/PTR_SIZE );
+
+
+ /////////////////////////////
+ // ルートポインタを引き渡す
+
+ //mov eax,offset
+ compiler.codeGenerator.op_mov_RV(REG_EAX,(int)pVar->GetOffsetAddress(), Schedule::GlobalVar );
+
+ //push eax
+ compiler.codeGenerator.op_push( REG_EAX );
+
+ //
+ /////////////////////////////
+
+
+ /////////////////////////////
+ // Thisポインタを引き渡す
+
+ SetThisPtrToReg(REG_EAX);
+
+ //push eax
+ compiler.codeGenerator.op_push( REG_EAX );
+
+ //
+ /////////////////////////////
+
+
+ // call AddGlobalRootPtr
+ compiler.codeGenerator.op_call( pUserProc_AddGlobalRootPtr );
+ }
+ }
+
+ return true;
+}
Index: /trunk/ab5.0/abdev/BasicCompiler32/FunctionValue.h
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/FunctionValue.h (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/FunctionValue.h (revision 440)
@@ -0,0 +1,34 @@
+/* 関数定数 */
+
+//データ型変換
+#define FUNC_CUDBL 0x0210
+#define FUNC_FIX 0x0211
+
+//文字列
+#define FUNC_LEN 0x031D
+
+//メモリ操作
+#define FUNC_VARPTR 0x0591
+#define FUNC_OBJPTR 0x0592
+
+//その他
+#define FUNC_ADDRESSOF 0x0619
+#define FUNC_SIZEOF 0x0620
+#define FUNC_DELEGATE_DYNAMICMETHOD_CALL 0x0621
+#define FUNC_DELEGATE_STATICMETHOD_CALL 0x0622
+#define FUNC_SYSTEM_GET_NOW_SCOPE_CATCH_ADDRESS 0x0623
+#define FUNC_SYSTEM_GET_NOW_SCOPE_FINALLY_ADDRESS 0x0624
+#define FUNC_SYSTEM_GET_BP 0x0625
+#define FUNC_SYSTEM_GET_SP 0x0626
+#define FUNC_SYSTEM_GET_COM_VTBL 0x0627
+#define FUNC_SYSTEM_GET_VTBL_LIST 0x0628
+#define FUNC_SYSTEM_GET_DEFAULT_CONSTRUCTOR 0x0629
+#define FUNC_SYSTEM_GET_DESTRUCTOR 0x062A
+
+//ポインタ
+#define FUNC_GETDOUBLE 0x0630
+#define FUNC_GETSINGLE 0x0631
+#define FUNC_GETQWORD 0x0632
+#define FUNC_GETDWORD 0x0633
+#define FUNC_GETWORD 0x0634
+#define FUNC_GETBYTE 0x0635
Index: /trunk/ab5.0/abdev/BasicCompiler32/LoopCheck.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/LoopCheck.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/LoopCheck.cpp (revision 440)
@@ -0,0 +1,5 @@
+/////////////////////////////////////////////////////
+// 循環参照をチェックするためのクラスモジュール
+/////////////////////////////////////////////////////
+
+
Index: /trunk/ab5.0/abdev/BasicCompiler32/MachineFixed.h
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/MachineFixed.h (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/MachineFixed.h (revision 440)
@@ -0,0 +1,39 @@
+#pragma once
+
+
+//未定義の定数情報
+#define IMAGE_FILE_MACHINE_AMD64 0x8664
+
+
+//レジスタを示す定数
+#define REG_NON -1
+#define REG_EAX 0x00 //reg:000
+#define REG_ECX 0x01 //reg:001
+#define REG_EDX 0x02 //reg:010
+#define REG_EBX 0x03 //reg:011
+#define REG_ESP 0x04 //reg:100
+#define REG_EBP 0x05 //reg:101
+#define REG_ESI 0x06 //reg:110
+#define REG_EDI 0x07 //reg:111
+
+#define REG_RAX REG_EAX
+#define REG_RCX REG_ECX
+#define REG_RDX REG_EDX
+#define REG_RBX REG_EBX
+#define REG_RSP REG_ESP
+#define REG_RBP REG_EBP
+#define REG_RSI REG_ESI
+#define REG_RDI REG_EDI
+
+#define REGISTER_OPERAND(reg) (reg&0x07)
+
+
+//Mod（モード）
+#define MOD_BASE (char)0x00
+#define MOD_DISP32 (char)0xFF
+#define MOD_BASE_DISP8 (char)0x40
+#define MOD_BASE_DISP32 (char)0x80
+#define MOD_REG (char)0xC0
+
+#define USE_OFFSET 1
+#define NON_OFFSET 0
Index: /trunk/ab5.0/abdev/BasicCompiler32/MakePeHdr.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/MakePeHdr.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/MakePeHdr.cpp (revision 440)
@@ -0,0 +1,1671 @@
+#include "stdafx.h"
+
+#include
+#include
+#include
+
+#include "../BasicCompiler_Common/common.h"
+#include "../BasicCompiler_Common/DebugSection.h"
+#include "Opcode.h"
+
+
+////////////////////////////
+// 特殊関数の構造体ポインタ
+////////////////////////////
+
+// グローバル関数、静的メソッド
+const UserProc
+ *pSub_System_StartupProgram,
+ *pSub_System_GlobalArea,
+ *pSub_DebugSys_StartProc,
+ *pSub_DebugSys_EndProc,
+ *pSub_DebugSys_SaveContext,
+ *pSub_System_GetEip,
+ *pSub_System_InitDllGlobalVariables,
+ *pSub_System_InitStaticLocalVariables,
+ *pSub_System_Call_Destructor_of_GlobalObject,
+ *pSub_System_End,
+ *pSub_pow,
+ *pSub_calloc,
+ *pSub_realloc,
+ *pSub_free,
+ *pSub_System_GC_malloc_ForObject,
+ *pSub_System_GC_malloc_ForObjectPtr,
+ *pSub_System_GC_free_for_SweepingDelete,
+ *pSub_System_AddNeedFreeTempStructure,
+ *pSub_System_FreeTempStructure,
+ *pSubStaticMethod_System_TypeBase_InitializeUserTypes,
+ *pSubStaticMethod_System_TypeBase_InitializeUserTypesForBaseType,
+
+ *pSub_allrem,
+ *pSub_aullrem,
+ *pSub_allmul,
+ *pSub_alldiv,
+ *pSub_aulldiv,
+ *pSub_allshl,
+ *pSub_allshr,
+ *pSub_aullshr,
+
+ *pSub_esp_error;
+
+// 動的メソッド
+const UserProc
+ *pUserProc_System_CGarbageCollection_RegisterGlobalRoots;
+
+
+//////////////////////////////
+// 各セクションの位置とサイズ
+int FileSize_CodeSection,
+ FileSize_ExportSection,
+ FileSize_ImportSection,
+ FileSize_DataSection,
+ FileSize_RWSection,
+ FileSize_RSrcSection,
+ FileSize_RelocSection,
+ FileSize_DebugSection;
+int FilePos_CodeSection,
+ FilePos_ExportSection,
+ FilePos_ImportSection,
+ FilePos_DataSection,
+ FilePos_RWSection,
+ FilePos_RSrcSection,
+ FilePos_RelocSection,
+ FilePos_DebugSection;
+int MemSize_CodeSection,
+ MemSize_ExportSection,
+ MemSize_ImportSection,
+ MemSize_DataSection,
+ MemSize_RWSection,
+ MemSize_RSrcSection,
+ MemSize_RelocSection,
+ MemSize_DebugSection;
+int MemPos_CodeSection,
+ MemPos_ExportSection,
+ MemPos_ImportSection,
+ MemPos_DataSection,
+ MemPos_RWSection,
+ MemPos_RSrcSection,
+ MemPos_RelocSection,
+ MemPos_DebugSection;
+int bUse_CodeSection,
+ bUse_ExportSection,
+ bUse_ImportSection,
+ bUse_DataSection,
+ bUse_RWSection,
+ bUse_RSrcSection,
+ bUse_RelocSection,
+ bUse_DebugSection;
+
+
+void Compile(void){
+ extern HWND hMainDlg;
+ extern HWND hOwnerEditor;
+ extern HANDLE hHeap;
+ extern BOOL bDebugCompile;
+ extern DWORD ImageBase;
+ extern char *basbuf;
+ extern char OutputFileName[MAX_PATH];
+
+ int i,i2,i3,i4,i5;
+ char temporary[MAX_PATH],*temp2;
+ HANDLE hFile;
+
+
+ //コードセクションのメモリ上の位置
+ MemPos_CodeSection= 0x1000;
+
+ //データセクションのメモリ上の位置（仮定）
+ MemPos_DataSection= 0x10000000;
+
+
+ //エクスポート セクションを利用するかどうか
+ if( compiler.IsDll() ) bUse_ExportSection=1;
+ else bUse_ExportSection=0;
+
+
+ // 静的リンク
+ compiler.StaticLink( compiler.staticLibraries );
+
+
+ //////////////////
+ // データテーブル
+ if(bDebugCompile){
+ compiler.GetObjectModule().dataTable.Add( (long)0x00000002 );
+ }
+
+
+ //////////////////////
+ // コード生成前の準備
+ //////////////////////
+
+ //重複エラー情報管理のメモリを確保（グローバル領域コンパイル用）
+ extern char **SynonymErrorWords;
+ extern int SynonymErrorNum;
+ SynonymErrorNum=0;
+ SynonymErrorWords=(char **)HeapAlloc(hHeap,0,1);
+
+ //列挙体に関する情報を収集
+ compiler.enumInfoCollection.InitEnum();
+
+ //列挙体からクラスコードを生成
+ char *temp;
+ temp=compiler.enumInfoCollection.GenerateSourceCode();
+ AddSourceCode(temp);
+ HeapDefaultFree(temp);
+
+ // 名前空間情報を取得
+ NamespaceSupporter::CollectNamespaces(
+ compiler.GetObjectModule().GetCurrentSource().GetBuffer(),
+ compiler.GetObjectModule().meta.GetNamespaces()
+ );
+
+ // デリゲートに関する情報を収集
+ {
+ compiler.GetObjectModule().meta.GetDelegates().Collect(
+ compiler.GetObjectModule().GetCurrentSource()
+ );
+ compiler.GetObjectModule().meta.GetDelegates().Iterator_Init();
+
+ // デリゲートからクラスコードを生成
+ std::string tempSource;
+ compiler.GetObjectModule().meta.GetDelegates().GenerateSourceCode( tempSource );
+ AddSourceCode( tempSource.c_str() );
+ }
+
+ //クラス名を取得（詳細情報はGetAllClassInfoで取得）
+ // CollectProcedures関数の中で参照されるオブジェクト名を事前に取得する。
+ // ※オブジェクトの内容までは取得しない
+ compiler.GetObjectModule().meta.GetClasses().CollectClassesForNameOnly( compiler.GetObjectModule().GetCurrentSource() );
+
+ //TypeDef情報を初期化
+ compiler.GetObjectModule().meta.GetTypeDefs().CollectTypeDefs();
+
+ /*
+ デリゲートのパラメータを再取得
+ クラス/TypeDefなどの型名前情報がすべて揃ってからでないと
+ 型情報に依存するパラメータ情報を取得できないため、ここでの再取得が必要
+ */
+ compiler.GetObjectModule().meta.GetDelegates().RefleshParameterAndReturnType();
+
+ //定数情報を取得
+ GetConstInfo();
+
+ // サブルーチン（ユーザー定義、DLL関数）の識別子、アドレスを取得
+ compiler.pCompilingClass = NULL;
+ CollectProcedures(
+ compiler.GetObjectModule().GetCurrentSource(),
+ compiler.GetObjectModule().meta.GetUserProcs(),
+ compiler.GetObjectModule().meta.GetDllProcs()
+ );
+
+ // クラス情報を取得（※注 - CollectProceduresの後に呼び出す）
+ compiler.GetObjectModule().meta.GetClasses().GetAllClassInfo();
+
+ // サブルーチン（ユーザー定義、DLL関数）のイテレータの準備
+ compiler.GetObjectModule().meta.GetUserProcs().Iterator_Init();
+ compiler.GetObjectModule().meta.GetDllProcs().Iterator_Init();
+
+
+
+ ///////////////////////////
+ // 最低限必要な関数を取得
+ ///////////////////////////
+ cp=-1;
+
+ if(pSub_System_StartupProgram=GetSubHash("_System_StartupProgram",1))
+ pSub_System_StartupProgram->Using();
+
+ if(pSub_System_GlobalArea=GetSubHash(compiler.globalAreaProcName.c_str(),1))
+ {
+ pSub_System_GlobalArea->Using();
+ pSub_System_GlobalArea->ThisIsAutoGenerationProc();
+ }
+
+ if(pSub_DebugSys_StartProc=GetSubHash("_DebugSys_StartProc",1))
+ pSub_DebugSys_StartProc->Using();
+
+ if(pSub_DebugSys_EndProc=GetSubHash("_DebugSys_EndProc",1))
+ pSub_DebugSys_EndProc->Using();
+
+ if(pSub_DebugSys_SaveContext=GetSubHash("_DebugSys_SaveContext",1))
+ pSub_DebugSys_SaveContext->Using();
+
+ if(pSub_System_GetEip=GetSubHash("_System_GetEip",1)){
+ pSub_System_GetEip->Using();
+ pSub_System_GetEip->ThisIsSystemProc();
+ }
+
+ if(pSub_System_InitDllGlobalVariables=GetSubHash("_System_InitDllGlobalVariables",1)){
+ pSub_System_InitDllGlobalVariables->Using();
+ pSub_System_InitDllGlobalVariables->ThisIsSystemProc();
+ }
+
+ if(pSub_System_InitStaticLocalVariables=GetSubHash("_System_InitStaticLocalVariables",1)){
+ pSub_System_InitStaticLocalVariables->Using();
+ pSub_System_InitStaticLocalVariables->ThisIsSystemProc();
+ }
+
+ if(pSub_System_Call_Destructor_of_GlobalObject=GetSubHash("_System_Call_Destructor_of_GlobalObject",1)){
+ pSub_System_Call_Destructor_of_GlobalObject->Using();
+ pSub_System_Call_Destructor_of_GlobalObject->ThisIsSystemProc();
+ }
+
+ if(pSub_System_End=GetSubHash("_System_End",1)){
+ pSub_System_End->Using();
+ }
+
+ if(pSub_pow=GetSubHash("pow",1))
+ pSub_pow->Using();
+
+ if(pSub_calloc=GetSubHash("calloc",1))
+ pSub_calloc->Using();
+
+ if(pSub_realloc=GetSubHash("realloc",1))
+ pSub_realloc->Using();
+
+ if(pSub_free=GetSubHash("free",1))
+ pSub_free->Using();
+
+ if( pSub_System_GC_malloc_ForObject = GetSubHash( "_System_GC_malloc_ForObject",1 ) )
+ pSub_System_GC_malloc_ForObject->Using();
+
+ if( pSub_System_GC_malloc_ForObjectPtr = GetSubHash( "_System_GC_malloc_ForObjectPtr",1 ) )
+ pSub_System_GC_malloc_ForObjectPtr->Using();
+
+ if( pSub_System_GC_free_for_SweepingDelete = GetSubHash( "_System_GC_free_for_SweepingDelete",1 ) )
+ pSub_System_GC_free_for_SweepingDelete->Using();
+
+ if( pSub_System_AddNeedFreeTempStructure = GetSubHash( "_System_AddNeedFreeTempStructure",1 ) )
+ {
+ pSub_System_AddNeedFreeTempStructure->Using();
+ }
+ if( pSub_System_FreeTempStructure = GetSubHash( "_System_FreeTempStructure",1 ) )
+ {
+ pSub_System_FreeTempStructure->Using();
+ }
+
+ if( pSubStaticMethod_System_TypeBase_InitializeUserTypes = GetSubHash( "ActiveBasic.Core._System_TypeBase.InitializeUserTypes",1 ) ){
+ pSubStaticMethod_System_TypeBase_InitializeUserTypes->Using();
+ pSubStaticMethod_System_TypeBase_InitializeUserTypes->ThisIsAutoGenerationProc();
+ }
+
+ if( pSubStaticMethod_System_TypeBase_InitializeUserTypesForBaseType = GetSubHash( "ActiveBasic.Core._System_TypeBase.InitializeUserTypesForBaseType",1 ) ){
+ pSubStaticMethod_System_TypeBase_InitializeUserTypesForBaseType->Using();
+ pSubStaticMethod_System_TypeBase_InitializeUserTypesForBaseType->ThisIsAutoGenerationProc();
+ }
+
+ if( pUserProc_System_CGarbageCollection_RegisterGlobalRoots = GetClassMethod( "_System_CGarbageCollection", "RegisterGlobalRoots" ) ){
+ pUserProc_System_CGarbageCollection_RegisterGlobalRoots->Using();
+ pUserProc_System_CGarbageCollection_RegisterGlobalRoots->ThisIsAutoGenerationProc();
+ }
+
+ pSub_allrem=GetSubHash("_allrem");
+ pSub_allrem->Using();
+ pSub_allrem->ThisIsSystemProc();
+
+ pSub_aullrem=GetSubHash("_aullrem");
+ pSub_aullrem->Using();
+ pSub_aullrem->ThisIsSystemProc();
+
+ pSub_allmul=GetSubHash("_allmul");
+ pSub_allmul->Using();
+ pSub_allmul->ThisIsSystemProc();
+
+ pSub_alldiv=GetSubHash("_alldiv");
+ pSub_alldiv->Using();
+ pSub_alldiv->ThisIsSystemProc();
+
+ pSub_aulldiv=GetSubHash("_aulldiv");
+ pSub_aulldiv->Using();
+ pSub_aulldiv->ThisIsSystemProc();
+
+ pSub_allshl=GetSubHash("_allshl");
+ pSub_allshl->Using();
+ pSub_allshl->ThisIsSystemProc();
+
+ pSub_allshr=GetSubHash("_allshr");
+ pSub_allshr->Using();
+ pSub_allshr->ThisIsSystemProc();
+
+ pSub_aullshr=GetSubHash("_aullshr");
+ pSub_aullshr->Using();
+ pSub_aullshr->ThisIsSystemProc();
+
+ pSub_esp_error=GetSubHash("_esp_error");
+ pSub_esp_error->Using();
+
+
+ //リロケーション情報
+ pobj_Reloc=new CReloc();
+
+ //レキシカルスコープ情報を初期化
+ compiler.codeGenerator.lexicalScopes.Init( 0 );
+ //compiler.codeGenerator.lexicalScopes.Init( compiler.codeGenerator.GetNativeCodeSize() );
+
+
+ /////////////////////////////////////////////////////////////////
+ // デバッグコンパイル用のログを生成する
+ /////////////////////////////////////////////////////////////////
+#ifdef _DEBUG
+ {
+ ofstream ofs( ( Jenga::Common::Environment::GetAppDir() + "\\middle_code.txt" ).c_str() );
+ ofs << basbuf << endl;
+ ofs.close();
+ }
+#endif
+
+
+ //////////////////////
+ // グローバル実行領域
+ //////////////////////
+
+ cp=-1;
+ UserProc::CompileStartForGlobalArea();
+
+ if( !compiler.IsDll() ){
+ // 名前空間が初期化されているかをチェック
+ if( compiler.GetNamespaceSupporter().GetLivingNamespaceScopes().size() ){
+ SetError();
+ }
+
+ //ラベル管理オブジェクトを初期化
+ compiler.codeGenerator.gotoLabels.clear();
+
+ //Gotoラベルスケジュール
+ compiler.codeGenerator.gotoLabelSchedules.clear();
+
+ //With情報のメモリを確保
+ extern WITHINFO WithInfo;
+ WithInfo.ppName=(char **)HeapAlloc(hHeap,0,1);
+ WithInfo.pWithCp=(int *)HeapAlloc(hHeap,0,1);
+ WithInfo.num=0;
+
+ //Continueアドレスを初期化
+ compiler.codeGenerator.ClearContinueArea();
+
+ // コード生成対象を選択
+ compiler.codeGenerator.Select( compiler.GetObjectModule().globalNativeCode );
+
+ trace_for_sourcecodestep( "★★★ グローバル領域のコンパイルを開始" );
+
+
+ //未完成
+ //breakpoint;
+
+
+ if( compiler.IsCore() )
+ {
+ // コアモジュール（basic.sbp）をコンパイルするとき
+
+ //push ebp
+ compiler.codeGenerator.op_push(REG_EBP);
+
+ if(bDebugCompile)
+ {
+ // デバッグ用の変数を定義
+ DebugVariable();
+ }
+
+ // GC用の変数を定義
+ InitGCVariables();
+
+ // _System_StartupProgram の呼び出し
+ compiler.codeGenerator.op_call(pSub_System_StartupProgram);
+ }
+
+ // _System_GlobalArea の呼び出し
+ compiler.codeGenerator.op_call( pSub_System_GlobalArea );
+
+ if( !compiler.IsStaticLibrary() )
+ {
+ ///////////////////////////////////////
+ // グローバル文字列変数の解放処理
+ ///////////////////////////////////////
+
+ //call _System_End
+ extern const UserProc *pSub_System_End;
+ compiler.codeGenerator.op_call(pSub_System_End);
+
+
+ //xor eax,eax（eaxを0に初期化する）
+ compiler.codeGenerator.op_zero_reg(REG_EAX);
+
+ //pop ebp
+ compiler.codeGenerator.op_pop(REG_EBP);
+
+ //ret
+ compiler.codeGenerator.op_ret();
+ }
+
+ //グローバル実行領域のコードサイズ
+ extern int GlobalOpBufferSize;
+ GlobalOpBufferSize = compiler.linker.GetNativeCode().GetSize();
+
+ //With情報のメモリを解放
+ for(i=0;iIsUsing() ){
+ continue;
+ }
+
+ //エラーチェック
+ HINSTANCE hLib;
+ hLib=LoadLibrary( pDllProc->GetDllFileName().c_str() );
+ if(!hLib){
+ extern char OutputFileName[MAX_PATH];
+ char temp2[MAX_PATH],temp3[MAX_PATH];
+ _splitpath(OutputFileName,temp2,temp3,NULL,NULL);
+ lstrcat(temp2,temp3);
+ lstrcpy(temp3,pDllProc->GetDllFileName().c_str());
+ GetFullPath(temp3,temp2);
+ hLib=LoadLibrary(temp3);
+
+ if(!hLib){
+ SetError(-106,pDllProc->GetDllFileName().c_str(),pDllProc->GetCodePos());
+ }
+ }
+
+ if(hLib){
+ if(!GetProcAddress(hLib,pDllProc->GetAlias().c_str())){
+ FreeLibrary(hLib);
+ SetError(-107,pDllProc->GetAlias(),pDllProc->GetCodePos());
+ }
+ FreeLibrary(hLib);
+ }
+ }
+
+
+
+ /////////////////////////////
+ // リソースデータを読み込む
+ /////////////////////////////
+ extern char ResourceFileName[MAX_PATH];
+ GetResourceData(ResourceFileName);
+
+
+ //////////////////////////////
+ // エクスポート情報（DLLのみ）
+ //////////////////////////////
+ IMAGE_EXPORT_DIRECTORY ImageExportDirectory;
+ DWORD *lpdwExportAddressTable;
+ DWORD *lpdwExportNamePointerTable;
+ WORD *lpwExportOrdinalTable;
+ char lpExportNames[8192];
+ int ExportNamesLength;
+ int ExportNum;
+ int DllMain_EntryPoint;
+
+ DllMain_EntryPoint=-1;
+ ExportNum=0;
+ ExportNamesLength=0;
+ lpdwExportAddressTable=(DWORD *)HeapAlloc(hHeap,0,1);
+ lpdwExportNamePointerTable=(DWORD *)HeapAlloc(hHeap,0,1);
+ lpwExportOrdinalTable=(WORD *)HeapAlloc(hHeap,0,1);
+
+ if(bUse_ExportSection){
+ _splitpath(OutputFileName,NULL,NULL,lpExportNames,temporary);
+ lstrcat(lpExportNames,temporary);
+ ExportNamesLength=lstrlen(lpExportNames)+1;
+
+ UserProc *pUserProc,*psi2;
+ while(1){
+ //辞書順にサーチ
+ temporary[0]=0;
+ compiler.GetObjectModule().meta.GetUserProcs().Iterator_Reset();
+ while( compiler.GetObjectModule().meta.GetUserProcs().Iterator_HasNext() )
+ {
+ pUserProc = compiler.GetObjectModule().meta.GetUserProcs().Iterator_GetNext();
+ if(pUserProc->IsExport()){
+ if(temporary[0]=='\0'){
+ lstrcpy(temporary,pUserProc->GetName().c_str());
+ psi2=pUserProc;
+ }
+ else{
+ i3=lstrlen(temporary);
+ i4=(int)pUserProc->GetName().size();
+ if(i3GetName().c_str(),i3)>0){
+ lstrcpy(temporary,pUserProc->GetName().c_str());
+ psi2=pUserProc;
+ }
+ }
+ }
+ }
+ if(psi2==0) break;
+ pUserProc=psi2;
+
+ pUserProc->ExportOff();
+
+ if( pUserProc->GetName() == "DllMain" ){
+ DllMain_EntryPoint = pUserProc->GetBeginOpAddress();
+ }
+
+ lpdwExportAddressTable=(DWORD *)HeapReAlloc(hHeap,0,lpdwExportAddressTable,(ExportNum+1)*sizeof(DWORD));
+ lpdwExportAddressTable[ExportNum] = pUserProc->GetBeginOpAddress();
+
+ lpdwExportNamePointerTable=(DWORD *)HeapReAlloc(hHeap,0,lpdwExportNamePointerTable,(ExportNum+1)*sizeof(DWORD));
+ lpdwExportNamePointerTable[ExportNum]=ExportNamesLength;
+
+ lpwExportOrdinalTable=(WORD *)HeapReAlloc(hHeap,0,lpwExportOrdinalTable,(ExportNum+1)*sizeof(WORD));
+ lpwExportOrdinalTable[ExportNum]=ExportNum;
+
+ lstrcpy(lpExportNames+ExportNamesLength,pUserProc->GetName().c_str());
+ ExportNamesLength+=lstrlen(lpExportNames+ExportNamesLength)+1;
+
+ ExportNum++;
+ }
+ for(i=0;iIsUsing() ){
+ continue;
+ }
+
+ if( pDllProc->GetDllFileName().size() > 16 ){
+ SetError(7,NULL,cp);
+ break;
+ }
+ for(i2=0;i2GetDllFileName() == ppDllNames[i2] ){
+ break;
+ }
+ }
+ if(i2==ImportDllNum){
+ ppDllNames=(char **)HeapReAlloc(hHeap,0,ppDllNames,(ImportDllNum+1)*sizeof(char **));
+ ppDllNames[ImportDllNum]=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,16);
+ lstrcpy(ppDllNames[ImportDllNum],pDllProc->GetDllFileName().c_str());
+ ImportDllNum++;
+ }
+ }
+
+ //インポート テーブル、及びルックアップ テーブル サイズの計算
+ IMAGE_IMPORT_DESCRIPTOR *pImportTable;
+ int LookupSize;
+ LookupSize=0;
+ pImportTable=(IMAGE_IMPORT_DESCRIPTOR *)HeapAlloc(hHeap,0,(ImportDllNum+1)*sizeof(IMAGE_IMPORT_DESCRIPTOR));
+ i3=(ImportDllNum+1)*sizeof(IMAGE_IMPORT_DESCRIPTOR);
+ for(i=0;iIsUsing() ){
+ continue;
+ }
+
+ if( pDllProc->GetDllFileName() == ppDllNames[i] ){
+ //ルックアップデータのサイズを追加
+ LookupSize+=sizeof(DWORD);
+ }
+ }
+ LookupSize+=sizeof(DWORD); //NULL用
+ }
+ memset(&pImportTable[i],0,sizeof(IMAGE_IMPORT_DESCRIPTOR));
+
+ //ルックアップ テーブル、ヒント テーブル
+ DWORD *pLookupTable;
+ pLookupTable=(DWORD *)HeapAlloc(hHeap,0,LookupSize*sizeof(DWORD)+1);
+ char *pHintTable;
+ int HintSize,HintAllocSize;
+ HintSize=0;
+ HintAllocSize=128*2;
+ pHintTable=(char *)HeapAlloc(hHeap,0,HintAllocSize);
+ i3+=ImportDllNum*0x10;
+ for(i=0,i5=0;iIsUsing() ){
+ continue;
+ }
+
+ if( pDllProc->GetDllFileName() == ppDllNames[i] ){
+ //ルックアップの位置をセット（後にインポート アドレス テーブルにセットしなおされる）
+ pDllProc->SetLookupAddress( i3+(i5*sizeof(DWORD)) );
+
+ //ルックアップ テーブル
+ pLookupTable[i5++]=i3+LookupSize+HintSize;
+
+ //ヒント テーブル
+ pHintTable[HintSize++]=0;
+ pHintTable[HintSize++]=0;
+ lstrcpy(pHintTable+HintSize,pDllProc->GetAlias().c_str());
+ i4=(int)pDllProc->GetAlias().size();
+ HintSize+=i4+1;
+ if(i4%2==0) pHintTable[HintSize++]=0;
+
+ if(HintAllocSizeResetRelocBuffer();
+ }
+
+
+
+ //グローバル変数情報を扱う構造体も初期バッファの有無による配置を行う
+ //（デバッグ情報で利用される）
+ BOOST_FOREACH( Variable *pVar, compiler.GetObjectModule().meta.GetGlobalVars() ){
+ if(pVar->GetOffsetAddress()&0x80000000){
+ pVar->SetOffsetAddress(
+ (pVar->GetOffsetAddress()&0x7FFFFFFF)
+ + compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.GetSize()
+ );
+ }
+ }
+
+
+
+ ////////////////////////////////////
+ // デバッグセクションを生成
+ ////////////////////////////////////
+
+ //デバッグセクションを生成
+ CDebugSection *pobj_DebugSection;
+ pobj_DebugSection=new CDebugSection();
+ extern BOOL bDebugCompile;
+ extern BOOL bError;
+ if(bDebugCompile&&bError==0){
+ CompileMessage( "デバッグ情報を生成しています。" );
+
+ pobj_DebugSection->make();
+
+ CompileMessage( "デバッグ情報の生成が完了しました。" );
+ }
+
+
+
+ /////////////////////////////////////
+ // 各セクションの位置とサイズを計算
+ /////////////////////////////////////
+
+ //コードセッションのファイル上のサイズ
+ if(compiler.linker.GetNativeCode().GetSize()%FILE_ALIGNMENT)
+ {
+ FileSize_CodeSection =
+ compiler.linker.GetNativeCode().GetSize()
+ + (FILE_ALIGNMENT-compiler.linker.GetNativeCode().GetSize()%FILE_ALIGNMENT);
+ }
+ else
+ {
+ FileSize_CodeSection = compiler.linker.GetNativeCode().GetSize();
+ }
+ if(FileSize_CodeSection) bUse_CodeSection=1;
+ else bUse_CodeSection=0;
+
+ //エクスポートセクションのファイル上のサイズ
+ i= sizeof(IMAGE_EXPORT_DIRECTORY)+ //エクスポートディレクトリテーブルを飛び越す
+ ExportNum*sizeof(DWORD)+ //エクスポート アドレス テーブルを飛び越す
+ ExportNum*sizeof(DWORD)+ //エクスポート名ポインタ テーブルを飛び越す
+ ExportNum*sizeof(WORD)+ //エクスポート序数テーブルを飛び越す
+ ExportNamesLength; //シンボル名バッファ
+ if(bUse_ExportSection){
+ if(i%FILE_ALIGNMENT) FileSize_ExportSection=i+(FILE_ALIGNMENT-i%FILE_ALIGNMENT);
+ else FileSize_ExportSection=i;
+ }
+ else FileSize_ExportSection=0;
+
+ //インポートセクションのファイル上のサイズ
+ i=(ImportDllNum+1)*sizeof(IMAGE_IMPORT_DESCRIPTOR)+
+ 16*ImportDllNum+ //DLL名
+ LookupSize+ //ルックアップテーブル
+ HintSize+ //ヒント名（関数名）テーブル
+ LookupSize; //インポート アドレス テーブル
+ if(i%FILE_ALIGNMENT) FileSize_ImportSection=i+(FILE_ALIGNMENT-i%FILE_ALIGNMENT);
+ else FileSize_ImportSection=i;
+ bUse_ImportSection=1; //インポートセクションは必ず存在する
+
+ //データセクションのファイル上のサイズ
+ if(compiler.GetObjectModule().dataTable.GetSize()%FILE_ALIGNMENT) FileSize_DataSection=compiler.GetObjectModule().dataTable.GetSize()+(FILE_ALIGNMENT-compiler.GetObjectModule().dataTable.GetSize()%FILE_ALIGNMENT);
+ else FileSize_DataSection=compiler.GetObjectModule().dataTable.GetSize();
+ if(FileSize_DataSection) bUse_DataSection=1;
+ else bUse_DataSection=0;
+
+ //リライタブルセクションのファイル上のサイズ（グローバル変数の初期情報のみを格納）
+ if( compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.GetSize() % FILE_ALIGNMENT )
+ {
+ FileSize_RWSection =
+ compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.GetSize()
+ + (FILE_ALIGNMENT-compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.GetSize()%FILE_ALIGNMENT);
+ }
+ else{
+ if( compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.GetSize() )
+ {
+ FileSize_RWSection = compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.GetSize();
+ }
+ else FileSize_RWSection=FILE_ALIGNMENT;
+ }
+ bUse_RWSection=1;
+
+ //リソースセクションのファイル上のサイズ
+ char *RSrcSectionBuffer;
+ int RSrcSectionSize;
+ RSrcSectionBuffer=GetRSrcSectionBuffer(&RSrcSectionSize);
+ if(RSrcSectionSize%FILE_ALIGNMENT) FileSize_RSrcSection=RSrcSectionSize+(FILE_ALIGNMENT-RSrcSectionSize%FILE_ALIGNMENT);
+ else FileSize_RSrcSection=RSrcSectionSize;
+ if(FileSize_RSrcSection) bUse_RSrcSection=1;
+ else bUse_RSrcSection=0;
+
+ //リロケーションセクションのファイル上のサイズ
+ if(pobj_Reloc->length%FILE_ALIGNMENT) FileSize_RelocSection=pobj_Reloc->length+(FILE_ALIGNMENT-pobj_Reloc->length%FILE_ALIGNMENT);
+ else FileSize_RelocSection=pobj_Reloc->length;
+ if(FileSize_RelocSection) bUse_RelocSection=1;
+ else bUse_RelocSection=0;
+
+ //デバッグセクションのファイル上のサイズ
+ if(pobj_DebugSection->length%FILE_ALIGNMENT) FileSize_DebugSection=pobj_DebugSection->length+(FILE_ALIGNMENT-pobj_DebugSection->length%FILE_ALIGNMENT);
+ else FileSize_DebugSection=pobj_DebugSection->length;
+ if(FileSize_DebugSection) bUse_DebugSection=1;
+ else bUse_DebugSection=0;
+
+
+ //各セッションのファイル上の位置
+ FilePos_CodeSection= EXE_HEADER_SIZE;
+ FilePos_ExportSection= FilePos_CodeSection+
+ FileSize_CodeSection;
+ FilePos_ImportSection= FilePos_ExportSection+
+ FileSize_ExportSection;
+ FilePos_DataSection= FilePos_ImportSection+
+ FileSize_ImportSection;
+ FilePos_RWSection= FilePos_DataSection+
+ FileSize_DataSection;
+ FilePos_RSrcSection= FilePos_RWSection+
+ FileSize_RWSection;
+ FilePos_RelocSection= FilePos_RSrcSection+
+ FileSize_RSrcSection;
+ FilePos_DebugSection= FilePos_RelocSection+
+ FileSize_RelocSection;
+
+
+ //コードセッションのメモリ上のサイズ
+ if(FileSize_CodeSection%MEM_ALIGNMENT) MemSize_CodeSection=FileSize_CodeSection+(MEM_ALIGNMENT-FileSize_CodeSection%MEM_ALIGNMENT);
+ else MemSize_CodeSection=FileSize_CodeSection;
+
+ //エクスポートセクションのメモリ上のサイズ
+ if(FileSize_ExportSection%MEM_ALIGNMENT) MemSize_ExportSection=FileSize_ExportSection+(MEM_ALIGNMENT-FileSize_ExportSection%MEM_ALIGNMENT);
+ else MemSize_ExportSection=FileSize_ExportSection;
+
+ //インポートセクションのメモリ上のサイズ
+ if(FileSize_ImportSection%MEM_ALIGNMENT) MemSize_ImportSection=FileSize_ImportSection+(MEM_ALIGNMENT-FileSize_ImportSection%MEM_ALIGNMENT);
+ else MemSize_ImportSection=FileSize_ImportSection;
+
+ //データセクションのメモリ上のサイズ
+ if(FileSize_DataSection%MEM_ALIGNMENT) MemSize_DataSection=FileSize_DataSection+(MEM_ALIGNMENT-FileSize_DataSection%MEM_ALIGNMENT);
+ else MemSize_DataSection=FileSize_DataSection;
+
+ //リライタブルセクションのメモリ上のサイズ
+ i = compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.GetSize()
+ + compiler.GetObjectModule().meta.GetGlobalVars().GetAllSize();
+ if(i%MEM_ALIGNMENT) MemSize_RWSection=i+(MEM_ALIGNMENT-i%MEM_ALIGNMENT);
+ else MemSize_RWSection=i;
+
+ //リソースセクションのメモリ上のサイズ
+ if(FileSize_RSrcSection%MEM_ALIGNMENT) MemSize_RSrcSection=FileSize_RSrcSection+(MEM_ALIGNMENT-FileSize_RSrcSection%MEM_ALIGNMENT);
+ else MemSize_RSrcSection=FileSize_RSrcSection;
+
+ //リロケーションセクションのメモリ上のサイズ
+ if(FileSize_RelocSection%MEM_ALIGNMENT) MemSize_RelocSection=FileSize_RelocSection+(MEM_ALIGNMENT-FileSize_RelocSection%MEM_ALIGNMENT);
+ else MemSize_RelocSection=FileSize_RelocSection;
+
+ //デバッグセクションのメモリ上のサイズ
+ if(FileSize_DebugSection%MEM_ALIGNMENT) MemSize_DebugSection=FileSize_DebugSection+(MEM_ALIGNMENT-FileSize_DebugSection%MEM_ALIGNMENT);
+ else MemSize_DebugSection=FileSize_DebugSection;
+
+
+ //各セッションのメモリ上の位置
+ if(bUse_ExportSection) MemPos_ExportSection= 0x1000+
+ MemSize_CodeSection;
+ else MemPos_ExportSection=0;
+ if(bUse_ImportSection) MemPos_ImportSection= 0x1000+
+ MemSize_CodeSection+
+ MemSize_ExportSection;
+ else MemPos_ImportSection=0;
+ if(bUse_DataSection) MemPos_DataSection= 0x1000+
+ MemSize_CodeSection+
+ MemSize_ExportSection+
+ MemSize_ImportSection;
+ else MemPos_DataSection=0;
+ if(bUse_RWSection) MemPos_RWSection= 0x1000+
+ MemSize_CodeSection+
+ MemSize_ExportSection+
+ MemSize_ImportSection+
+ MemSize_DataSection;
+ else MemPos_RWSection=0;
+ if(bUse_RSrcSection) MemPos_RSrcSection= 0x1000+
+ MemSize_CodeSection+
+ MemSize_ExportSection+
+ MemSize_ImportSection+
+ MemSize_DataSection+
+ MemSize_RWSection;
+ else MemPos_RSrcSection=0;
+ if(bUse_RelocSection) MemPos_RelocSection= 0x1000+
+ MemSize_CodeSection+
+ MemSize_ExportSection+
+ MemSize_ImportSection+
+ MemSize_DataSection+
+ MemSize_RWSection+
+ MemSize_RSrcSection;
+ else MemPos_RelocSection=0;
+ if(bUse_DebugSection) MemPos_DebugSection= 0x1000+
+ MemSize_CodeSection+
+ MemSize_ExportSection+
+ MemSize_ImportSection+
+ MemSize_DataSection+
+ MemSize_RWSection+
+ MemSize_RSrcSection+
+ MemSize_RelocSection;
+ else MemPos_DebugSection=0;
+
+
+
+ ////////////////////////////
+ // エクスポート情報の再配置
+ ////////////////////////////
+ if(bUse_ExportSection){
+ for(i=0;iIsUsing() ){
+ continue;
+ }
+
+ if( pDllProc->GetDllFileName() == ppDllNames[i] ){
+ //ルックアップ テーブル
+ pLookupTable[i5++]+=MemPos_ImportSection;
+ }
+ }
+ i5++;
+ }
+
+
+ ////////////////////////////////////////
+ //仮想関数データテーブルスケジュール
+ compiler.GetObjectModule().meta.GetClasses().ActionVtblSchedule( ImageBase, MemPos_CodeSection, MemPos_DataSection );
+
+
+ if( compiler.IsDll() ){
+ //DLLの場合はリロケーション情報を生成
+ pobj_Reloc->ResetRelocBuffer();
+ }
+
+ compiler.linker.SetDataTable( compiler.GetObjectModule().dataTable );
+
+ compiler.linker.SetImageBase( ImageBase );
+ compiler.linker.ResolveDataTableSchedules( MemPos_DataSection );
+ compiler.linker.ResolveCatchAddressSchedules( MemPos_CodeSection );
+ compiler.linker.ResolveDllProcSchedules( MemPos_CodeSection, MemPos_ImportSection, LookupSize, HintSize );
+ compiler.linker.ResolveUserProcSchedules( MemPos_CodeSection );
+ compiler.linker.ResolveGlobalVarSchedules( MemPos_RWSection );
+ compiler.linker.ResolveVtblSchedule( MemPos_DataSection );
+ compiler.linker.ResolveTypeInfoSchedule( MemPos_DataSection );
+
+
+
+ ////////////////////////////////
+ // リソースアドレススケジュール
+ extern DWORD *lpdwRSrcAddrSchedule;
+ extern int RSrcAddrScheduleNum;
+ for(i=0;ilength;
+ ImagePeHdr.OptionalHeader.DataDirectory[6].VirtualAddress=0;
+ ImagePeHdr.OptionalHeader.DataDirectory[6].Size=0;
+ ImagePeHdr.OptionalHeader.DataDirectory[7].VirtualAddress=0;
+ ImagePeHdr.OptionalHeader.DataDirectory[7].Size=0;
+ ImagePeHdr.OptionalHeader.DataDirectory[8].VirtualAddress=0;
+ ImagePeHdr.OptionalHeader.DataDirectory[8].Size=0;
+ ImagePeHdr.OptionalHeader.DataDirectory[9].VirtualAddress=0;
+ ImagePeHdr.OptionalHeader.DataDirectory[9].Size=0;
+ ImagePeHdr.OptionalHeader.DataDirectory[10].VirtualAddress=0;
+ ImagePeHdr.OptionalHeader.DataDirectory[10].Size=0;
+ ImagePeHdr.OptionalHeader.DataDirectory[11].VirtualAddress=0;
+ ImagePeHdr.OptionalHeader.DataDirectory[11].Size=0;
+ ImagePeHdr.OptionalHeader.DataDirectory[12].VirtualAddress=MemPos_ImportSection+
+ (ImportDllNum+1)*sizeof(IMAGE_IMPORT_DESCRIPTOR)+
+ 16*ImportDllNum+ //DLL名
+ LookupSize+ //ルックアップテーブル
+ HintSize; //ヒント名（関数名）テーブル
+ ImagePeHdr.OptionalHeader.DataDirectory[12].Size=LookupSize;
+ ImagePeHdr.OptionalHeader.DataDirectory[13].VirtualAddress=0;
+ ImagePeHdr.OptionalHeader.DataDirectory[13].Size=0;
+ ImagePeHdr.OptionalHeader.DataDirectory[14].VirtualAddress=0;
+ ImagePeHdr.OptionalHeader.DataDirectory[14].Size=0;
+ ImagePeHdr.OptionalHeader.DataDirectory[15].VirtualAddress=0;
+ ImagePeHdr.OptionalHeader.DataDirectory[15].Size=0;
+
+
+ //コードセクションヘッダ
+ IMAGE_SECTION_HEADER CodeSectionHeader;
+ memset((char *)CodeSectionHeader.Name,0,IMAGE_SIZEOF_SHORT_NAME);
+ lstrcpy((char *)CodeSectionHeader.Name,".text");
+ CodeSectionHeader.Misc.VirtualSize= MemSize_CodeSection;
+ CodeSectionHeader.VirtualAddress= MemPos_CodeSection; //開始アドレス
+ CodeSectionHeader.SizeOfRawData= FileSize_CodeSection;
+ CodeSectionHeader.PointerToRawData= FilePos_CodeSection; //ファイル上の開始アドレス
+ CodeSectionHeader.PointerToRelocations= 0;
+ CodeSectionHeader.PointerToLinenumbers= 0;
+ CodeSectionHeader.NumberOfRelocations= 0;
+ CodeSectionHeader.NumberOfLinenumbers= 0;
+ CodeSectionHeader.Characteristics= IMAGE_SCN_MEM_EXECUTE|
+ IMAGE_SCN_MEM_READ|
+ IMAGE_SCN_CNT_CODE;
+
+ //エクスポートセクションヘッダ
+ IMAGE_SECTION_HEADER ExportSectionHeader;
+ memset((char *)ExportSectionHeader.Name,0,IMAGE_SIZEOF_SHORT_NAME);
+ lstrcpy((char *)ExportSectionHeader.Name,".edata");
+ ExportSectionHeader.Misc.VirtualSize= MemSize_ExportSection;
+ ExportSectionHeader.VirtualAddress= MemPos_ExportSection; //開始アドレス
+ ExportSectionHeader.SizeOfRawData= FileSize_ExportSection; //サイズ
+ ExportSectionHeader.PointerToRawData= FilePos_ExportSection; //ファイル上の開始アドレス
+ ExportSectionHeader.PointerToRelocations= 0;
+ ExportSectionHeader.PointerToLinenumbers= 0;
+ ExportSectionHeader.NumberOfRelocations= 0;
+ ExportSectionHeader.NumberOfLinenumbers= 0;
+ ExportSectionHeader.Characteristics= IMAGE_SCN_CNT_INITIALIZED_DATA|
+ IMAGE_SCN_MEM_READ;
+
+ //インポートセクションヘッダ
+ IMAGE_SECTION_HEADER ImportSectionHeader;
+ memset((char *)ImportSectionHeader.Name,0,IMAGE_SIZEOF_SHORT_NAME);
+ lstrcpy((char *)ImportSectionHeader.Name,".idata");
+ ImportSectionHeader.Misc.VirtualSize= MemSize_ImportSection;
+ ImportSectionHeader.VirtualAddress= MemPos_ImportSection; //開始アドレス
+ ImportSectionHeader.SizeOfRawData= FileSize_ImportSection; //サイズ
+ ImportSectionHeader.PointerToRawData= FilePos_ImportSection; //ファイル上の開始アドレス
+ ImportSectionHeader.PointerToRelocations= 0;
+ ImportSectionHeader.PointerToLinenumbers= 0;
+ ImportSectionHeader.NumberOfRelocations= 0;
+ ImportSectionHeader.NumberOfLinenumbers= 0;
+ ImportSectionHeader.Characteristics= IMAGE_SCN_CNT_INITIALIZED_DATA|
+ IMAGE_SCN_MEM_READ;
+
+ //データセクションヘッダ
+ IMAGE_SECTION_HEADER DataSectionHeader;
+ memset((char *)DataSectionHeader.Name,0,IMAGE_SIZEOF_SHORT_NAME);
+ lstrcpy((char *)DataSectionHeader.Name,".sdata");
+ DataSectionHeader.Misc.VirtualSize= MemSize_DataSection;
+ DataSectionHeader.VirtualAddress= MemPos_DataSection;
+ DataSectionHeader.SizeOfRawData= FileSize_DataSection;
+ DataSectionHeader.PointerToRawData= FilePos_DataSection;
+ DataSectionHeader.PointerToRelocations= 0;
+ DataSectionHeader.PointerToLinenumbers= 0;
+ DataSectionHeader.NumberOfRelocations= 0;
+ DataSectionHeader.NumberOfLinenumbers= 0;
+ DataSectionHeader.Characteristics= IMAGE_SCN_CNT_INITIALIZED_DATA|
+ IMAGE_SCN_MEM_READ|
+ IMAGE_SCN_MEM_WRITE;
+
+ //リライタブルセクションヘッダ
+ IMAGE_SECTION_HEADER RWSectionHeader;
+ memset((char *)RWSectionHeader.Name,0,IMAGE_SIZEOF_SHORT_NAME);
+ lstrcpy((char *)RWSectionHeader.Name,".data");
+ RWSectionHeader.Misc.VirtualSize= compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.GetSize()
+ + compiler.GetObjectModule().meta.GetGlobalVars().GetAllSize();
+ RWSectionHeader.VirtualAddress= MemPos_RWSection;
+ RWSectionHeader.SizeOfRawData= FileSize_RWSection;
+ RWSectionHeader.PointerToRawData= FilePos_RWSection;
+ RWSectionHeader.PointerToRelocations= 0;
+ RWSectionHeader.PointerToLinenumbers= 0;
+ RWSectionHeader.NumberOfRelocations= 0;
+ RWSectionHeader.NumberOfLinenumbers= 0;
+ RWSectionHeader.Characteristics= IMAGE_SCN_CNT_INITIALIZED_DATA|
+ IMAGE_SCN_MEM_READ|
+ IMAGE_SCN_MEM_WRITE;
+
+ //リソースセクションヘッダ
+ IMAGE_SECTION_HEADER RSrcSectionHeader;
+ memset((char *)RSrcSectionHeader.Name,0,IMAGE_SIZEOF_SHORT_NAME);
+ lstrcpy((char *)RSrcSectionHeader.Name,".rsrc");
+ RSrcSectionHeader.Misc.VirtualSize= RSrcSectionSize;
+ RSrcSectionHeader.VirtualAddress= MemPos_RSrcSection;
+ RSrcSectionHeader.SizeOfRawData= FileSize_RSrcSection;
+ RSrcSectionHeader.PointerToRawData= FilePos_RSrcSection;
+ RSrcSectionHeader.PointerToRelocations= 0;
+ RSrcSectionHeader.PointerToLinenumbers= 0;
+ RSrcSectionHeader.NumberOfRelocations= 0;
+ RSrcSectionHeader.NumberOfLinenumbers= 0;
+ RSrcSectionHeader.Characteristics= IMAGE_SCN_CNT_INITIALIZED_DATA|
+ IMAGE_SCN_MEM_READ;
+
+ //リロケーションセクションヘッダ
+ IMAGE_SECTION_HEADER RelocSectionHeader;
+ memset((char *)RelocSectionHeader.Name,0,IMAGE_SIZEOF_SHORT_NAME);
+ lstrcpy((char *)RelocSectionHeader.Name,".reloc");
+ RelocSectionHeader.Misc.VirtualSize= pobj_Reloc->length;
+ RelocSectionHeader.VirtualAddress= MemPos_RelocSection; //開始アドレス
+ RelocSectionHeader.SizeOfRawData= FileSize_RelocSection; //サイズ
+ RelocSectionHeader.PointerToRawData= FilePos_RelocSection; //ファイル上の開始アドレス
+ RelocSectionHeader.PointerToRelocations= 0;
+ RelocSectionHeader.PointerToLinenumbers= 0;
+ RelocSectionHeader.NumberOfRelocations= 0;
+ RelocSectionHeader.NumberOfLinenumbers= 0;
+ RelocSectionHeader.Characteristics= IMAGE_SCN_CNT_INITIALIZED_DATA|
+ IMAGE_SCN_MEM_DISCARDABLE|
+ IMAGE_SCN_MEM_READ;
+
+ //デバッグセクションヘッダ
+ IMAGE_SECTION_HEADER DebugSectionHeader;
+ memset((char *)DebugSectionHeader.Name,0,IMAGE_SIZEOF_SHORT_NAME);
+ lstrcpy((char *)DebugSectionHeader.Name,".debug");
+ DebugSectionHeader.Misc.VirtualSize= pobj_DebugSection->length;
+ DebugSectionHeader.VirtualAddress= MemPos_DebugSection; //開始アドレス
+ DebugSectionHeader.SizeOfRawData= FileSize_DebugSection; //サイズ
+ DebugSectionHeader.PointerToRawData= FilePos_DebugSection; //ファイル上の開始アドレス
+ DebugSectionHeader.PointerToRelocations= 0;
+ DebugSectionHeader.PointerToLinenumbers= 0;
+ DebugSectionHeader.NumberOfRelocations= 0;
+ DebugSectionHeader.NumberOfLinenumbers= 0;
+ DebugSectionHeader.Characteristics= IMAGE_SCN_MEM_DISCARDABLE|
+ IMAGE_SCN_MEM_READ;
+
+
+ hFile=CreateFile(OutputFileName,GENERIC_WRITE,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
+ if(hFile==INVALID_HANDLE_VALUE){
+ SetError(53,OutputFileName,-1);
+ goto EndWriteOpcode;
+ }
+
+ //ヘッダ
+ WriteFile(hFile,(void *)&ImageDosHeader,sizeof(IMAGE_DOS_HEADER),(DWORD *)&i2,NULL);
+ i=i2;
+
+ //Dosスタブ
+ WriteFile(hFile,DosStubBuffer,DosStubSize,(DWORD *)&i2,NULL);
+ i+=i2;
+
+ //0x0100までNULLを並べる
+ temp2=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,0x0100-i);
+ WriteFile(hFile,temp2,0x0100-i,(DWORD *)&i2,NULL);
+ HeapDefaultFree(temp2);
+ i+=i2;
+
+ //PEヘッダ
+ WriteFile(hFile,&ImagePeHdr,sizeof(IMAGE_NT_HEADERS),(DWORD *)&i2,NULL);
+ i+=i2;
+
+ //コード セクション ヘッダ
+ WriteFile(hFile,&CodeSectionHeader,sizeof(IMAGE_SECTION_HEADER),(DWORD *)&i2,NULL);
+ i+=i2;
+
+ if(bUse_ExportSection){
+ //エクスポート セクション ヘッダ
+ WriteFile(hFile,&ExportSectionHeader,sizeof(IMAGE_SECTION_HEADER),(DWORD *)&i2,NULL);
+ i+=i2;
+ }
+ if(bUse_ImportSection){
+ //インポート セクション ヘッダ
+ WriteFile(hFile,&ImportSectionHeader,sizeof(IMAGE_SECTION_HEADER),(DWORD *)&i2,NULL);
+ i+=i2;
+ }
+ if(bUse_DataSection){
+ //データ セクション ヘッダ
+ WriteFile(hFile,&DataSectionHeader,sizeof(IMAGE_SECTION_HEADER),(DWORD *)&i2,NULL);
+ i+=i2;
+ }
+ if(bUse_RWSection){
+ //リライタブルセクションヘッダ
+ WriteFile(hFile,&RWSectionHeader,sizeof(IMAGE_SECTION_HEADER),(DWORD *)&i2,NULL);
+ i+=i2;
+ }
+ if(bUse_RSrcSection){
+ //リソースセクションヘッダ
+ WriteFile(hFile,&RSrcSectionHeader,sizeof(IMAGE_SECTION_HEADER),(DWORD *)&i2,NULL);
+ i+=i2;
+ }
+ if(bUse_RelocSection){
+ //リロケーションセクションヘッダ
+ WriteFile(hFile,&RelocSectionHeader,sizeof(IMAGE_SECTION_HEADER),(DWORD *)&i2,NULL);
+ i+=i2;
+ }
+ if(bUse_DebugSection){
+ //デバッグセクションヘッダ
+ WriteFile(hFile,&DebugSectionHeader,sizeof(IMAGE_SECTION_HEADER),(DWORD *)&i2,NULL);
+ i+=i2;
+ }
+
+ //EXE_HEADER_SIZEまでNULLを並べる
+ temp2=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,EXE_HEADER_SIZE-i);
+ WriteFile(hFile,temp2,EXE_HEADER_SIZE-i,(DWORD *)&i2,NULL);
+ HeapDefaultFree(temp2);
+ i+=i2;
+
+ //コード
+ WriteFile(
+ hFile,
+ compiler.linker.GetNativeCode().GetBuffer(),
+ compiler.linker.GetNativeCode().GetSize(),
+ (DWORD *)&i2,
+ NULL
+ );
+ i+=i2;
+
+ //FilePos_ExportSectionまでNULLを並べる
+ temp2=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,FilePos_ExportSection-i);
+ WriteFile(hFile,temp2,FilePos_ExportSection-i,(DWORD *)&i2,NULL);
+ HeapDefaultFree(temp2);
+ i+=i2;
+
+ if(bUse_ExportSection){
+ //エクスポート ディレクトリ テーブル
+ WriteFile(hFile,&ImageExportDirectory,sizeof(IMAGE_EXPORT_DIRECTORY),(DWORD *)&i2,NULL);
+ i+=i2;
+
+ //エクスポート アドレス テーブル
+ WriteFile(hFile,lpdwExportAddressTable,ExportNum*sizeof(DWORD),(DWORD *)&i2,NULL);
+ i+=i2;
+
+ //エクスポート名ポインタ テーブル
+ WriteFile(hFile,lpdwExportNamePointerTable,ExportNum*sizeof(DWORD),(DWORD *)&i2,NULL);
+ i+=i2;
+
+ //エクスポート序数テーブル
+ WriteFile(hFile,lpwExportOrdinalTable,ExportNum*sizeof(WORD),(DWORD *)&i2,NULL);
+ i+=i2;
+
+ //シンボル名
+ WriteFile(hFile,lpExportNames,ExportNamesLength,(DWORD *)&i2,NULL);
+ i+=i2;
+ }
+
+ //FilePos_ImportSectionまでNULLを並べる
+ temp2=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,FilePos_ImportSection-i);
+ WriteFile(hFile,temp2,FilePos_ImportSection-i,(DWORD *)&i2,NULL);
+ HeapDefaultFree(temp2);
+ i+=i2;
+
+ if(bUse_ImportSection){
+ //インポート ディレクトリ テーブル（Nullディレクトリ テーブルを含む）
+ for(i3=0;i3<(ImportDllNum+1);i3++){
+ WriteFile(hFile,&pImportTable[i3],sizeof(IMAGE_IMPORT_DESCRIPTOR),(DWORD *)&i2,NULL);
+ i+=i2;
+ }
+
+ //DLL名
+ for(i3=0;i3buffer,pobj_Reloc->length,(DWORD *)&i2,NULL);
+ i+=i2;
+ }
+
+ //ファイルアラインメントを考慮
+ if(i%FILE_ALIGNMENT){
+ temp2=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,FILE_ALIGNMENT-i%FILE_ALIGNMENT);
+ WriteFile(hFile,temp2,FILE_ALIGNMENT-i%FILE_ALIGNMENT,(DWORD *)&i2,NULL);
+ HeapDefaultFree(temp2);
+ i+=i2;
+ }
+
+ if(bUse_DebugSection){
+ //デバッグセクション
+ WriteFile(hFile,pobj_DebugSection->buffer,pobj_DebugSection->length,(DWORD *)&i2,NULL);
+ i+=i2;
+ }
+
+ //ファイルアラインメントを考慮
+ if(i%FILE_ALIGNMENT){
+ temp2=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,FILE_ALIGNMENT-i%FILE_ALIGNMENT);
+ WriteFile(hFile,temp2,FILE_ALIGNMENT-i%FILE_ALIGNMENT,(DWORD *)&i2,NULL);
+ HeapDefaultFree(temp2);
+ i+=i2;
+ }
+
+ //書き込み終了
+ CloseHandle(hFile);
+
+
+EndWriteOpcode:
+
+ //Dosスタブ用のメモリを解放
+ HeapDefaultFree(DosStubBuffer);
+
+ //エクスポート テーブル情報を解放
+ HeapDefaultFree(lpdwExportAddressTable);
+ HeapDefaultFree(lpdwExportNamePointerTable);
+ HeapDefaultFree(lpwExportOrdinalTable);
+
+ //インポートDLL情報を解放
+ HeapDefaultFree(pImportTable);
+ for(i=0;i
+
+#include
+
+#include "../BasicCompiler_Common/common.h"
+#include "Opcode.h"
+
+void PushReturnValue(int type){
+ //関数の戻り値をスタックへプッシュする
+ //※この処理内では、esi、ediは使用不可
+
+ if(type==DEF_OBJECT || type==DEF_STRUCT){
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else if(type==DEF_DOUBLE){
+ //sub esp,8
+ compiler.codeGenerator.op_sub_esp(8);
+
+ //fstp qword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
+ }
+ else if(type==DEF_SINGLE){
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ //fstp dword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
+ }
+ else if(type==DEF_INT64||type==DEF_QWORD){
+ //push edx
+ compiler.codeGenerator.op_push(REG_EDX);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else if(type==DEF_LONG){
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){
+ //movsx ebx,ax
+ compiler.codeGenerator.op_movsx_R32R16( REG_EBX, REG_EAX );
+
+ //push ebx
+ compiler.codeGenerator.op_push(REG_EBX);
+ }
+ else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
+ //movsx ebx,al
+ compiler.codeGenerator.op_movsx_R32R8( REG_EBX, REG_EAX );
+
+ //push ebx
+ compiler.codeGenerator.op_push(REG_EBX);
+ }
+ else if(type==DEF_DWORD||type==DEF_WORD||type==DEF_BYTE||type==DEF_BOOLEAN||
+ IsPtrType(type)){
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else{
+ SetError();
+ }
+}
+
+void NewStringObject( const char *str ){
+ ///////////////////////////////////////////////////////
+ // lpszTextを元にStringオブジェクトを生成し、
+ // オブジェクトポインタをregに格納する
+ ///////////////////////////////////////////////////////
+
+ char *parameter = (char *)malloc( lstrlen( str ) + 32 );
+ sprintf( parameter, "%s%c%c*Char", str, 1, ESC_AS );
+
+ Operator_New( *compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr(), "", parameter, Type( DEF_OBJECT, *compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr() ) );
+
+ free( parameter );
+}
+
+void ExtendRegToBigType( int reg, int bigBasicType, int baseBasicType ){
+ if( reg != REG_EAX ){
+ SetError();
+ }
+ switch( Type::GetBasicSize( bigBasicType ) ){
+ case sizeof(_int64):
+ ExtendTypeTo64(baseBasicType);
+ break;
+ case sizeof(long):
+ ExtendTypeTo32(baseBasicType,reg);
+ break;
+ case sizeof(short):
+ ExtendTypeTo16(baseBasicType,reg);
+ break;
+ }
+}
+
+
+
+bool VarToReg( RELATIVE_VAR &relativeVar, const Type &baseType, Type &resultType ){
+ const int useReg = REG_EAX;
+
+ //大きな型への暗黙の変換
+ int bigType = AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
+
+ if(resultType.GetBasicType()&FLAG_PTR){
+ //配列ポインタ
+ resultType.SetBasicType( GetPtrType(resultType.GetBasicType()^FLAG_PTR) );
+
+ SetVarPtrToReg(useReg, &relativeVar);
+ }
+ else if( resultType.IsStruct() ){
+ //構造体ポインタをeaxへ格納（構造体は値型）
+ SetVarPtrToReg(useReg, &relativeVar);
+ }
+ else if( resultType.IsReal() ){
+ // 実数
+ SetReg_RealVariable( resultType.GetBasicType(), &relativeVar );
+ }
+ else if( resultType.IsWhole() || resultType.IsObject()){
+ //整数型
+ SetReg_WholeVariable(resultType,&relativeVar,useReg);
+ }
+ else if( resultType.IsStruct() ){
+ //構造体ポインタをUseRegへ格納（構造体は値型）
+ SetVarPtrToReg(useReg,&relativeVar);
+ }
+ else{
+ return false;
+ }
+
+ if( resultType.GetBasicType() != bigType ){
+ // 大きな型へ変換された場合
+ // ※レジスタの値をキャストする
+ ExtendRegToBigType( useReg, bigType, resultType.GetBasicType() );
+
+ resultType.SetBasicType( bigType );
+ }
+
+ return true;
+}
+bool TermMemberOpe( const Type &leftType, bool &isNeedHeapFreeStructure, const Type &baseType, Type &resultType, const char *termFull, const char *termLeft, const char *member, bool &isVariable, RELATIVE_VAR &relativeVar )
+{
+ const CClass &objClass = leftType.GetClass();
+
+ const int useReg = REG_EAX;
+
+
+ ////////////////////////////////
+ // インデクサ（getアクセサ）
+ ////////////////////////////////
+ char VarName[VN_SIZE],ArrayElements[VN_SIZE];
+ GetArrayElement(member,VarName,ArrayElements);
+ if(ArrayElements[0]){
+ Type classType;
+ if( VarName[0] == '\0' )
+ {
+ classType = leftType;
+
+ if( classType.IsObject() )
+ {
+ // 既にuseRegにオブジェクトポインタが格納されており、それに対するインデクサを呼び出す場合
+ // ※「プロパティ値として返ってきたオブジェクトインスタンスのインデクサを呼び出す」場合にここにくる
+
+ //オブジェクトポインタをスタックに入れておく
+ //push useReg
+ compiler.codeGenerator.op_push( useReg );
+ }
+ }
+ else
+ {
+ GetMemberType( leftType, VarName, classType, 0, false );
+
+ if( classType.IsObject() )
+ {
+ // クラス型のメンバに対するインデクサを呼び出す場合
+
+ //オブジェクトポインタをecxにコピー
+ compiler.codeGenerator.op_mov_RR( REG_ECX, useReg );
+
+ RELATIVE_VAR tempRelativeVar;
+ tempRelativeVar.dwKind=VAR_DIRECTMEM;
+
+ if( !_member_offset(
+ true, //エラー表示あり
+ false, //読み込み専用
+ leftType,
+ VarName,&tempRelativeVar,classType,0)){
+ return false;
+ }
+
+ // オブジェクトメンバのポインタをeaxにコピー
+ if( !VarToReg( tempRelativeVar, baseType, resultType ) ){
+ SetError(11,termFull,cp);
+ }
+
+
+ //オブジェクトポインタをスタックに入れておく
+ //push eax
+ compiler.codeGenerator.op_push( REG_EAX );
+ }
+ }
+
+ if( classType.IsObject() )
+ {
+ char objectFullName[VN_SIZE], dummyArrayElements[VN_SIZE];
+ GetArrayElement(termFull,objectFullName,dummyArrayElements);
+
+ CallIndexerGetterProc(/*UseReg,*/classType,objectFullName, ArrayElements,resultType, PROCFLAG_NEW );
+
+ compiler.codeGenerator.op_pop();
+
+ return true;
+ }
+ }
+
+
+ ///////////////////////////////////////////////////////////////////
+ // メンバを検索
+ ///////////////////////////////////////////////////////////////////
+ if( GetMemberType( leftType, member, resultType, 0, false ) ){
+ // メンバが見つかったとき
+
+ if( isNeedHeapFreeStructure )
+ {
+ if( !leftType.IsStruct() )
+ {
+ SetError();
+ }
+
+ // 親となる構造体が一時メモリに存在していた場合、後ほど解放する必要がある
+ compiler.codeGenerator.op_AddNeedFreeTempStructure( useReg );
+ isNeedHeapFreeStructure = false;
+ }
+
+ //オブジェクトポインタをecxにコピー
+ compiler.codeGenerator.op_mov_RR( REG_ECX, useReg );
+
+ relativeVar.dwKind=VAR_DIRECTMEM;
+
+ if( !_member_offset(
+ true, //エラー表示あり
+ false, //読み込み専用
+ leftType,
+ member,&relativeVar,resultType,0)){
+ return false;
+ }
+
+ // 変数として扱う
+ isVariable = true;
+
+ return true;
+ }
+
+
+ ///////////////////////////////////////////////////////////////////
+ // 動的メソッドを検索
+ ///////////////////////////////////////////////////////////////////
+ vector userProcs;
+
+ char methodName[VN_SIZE], lpPtrOffset[VN_SIZE], parameter[VN_SIZE], dummy[1];
+ ReferenceKind refType;
+ PareOrBracket pareOrBracket = None;
+ lstrcpy( methodName, member );
+ GetVarFormatString( methodName, parameter, lpPtrOffset, dummy, refType, &pareOrBracket );
+
+ objClass.EnumDynamicMethodsOrInterfaceMethods( methodName, userProcs );
+ if(userProcs.size()){
+ //オーバーロードを解決
+ const UserProc *pUserProc = OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
+
+ if( pUserProc )
+ {
+ if(
+ pUserProc->Params().size() == 0 // 仮引数の個数は0
+ && parameter[0] // 実引数は1つ以上
+ && pUserProc->ReturnType().IsObject() // 戻り値がクラス型の場合
+ && pareOrBracket == Bracket ) // 実引数は[]で囲まれている
+ {
+ // プロパティ値として返ってきたオブジェクトインスタンスのインデクサを呼び出す
+
+ // まずはプロパティ値を取得
+ bool dummyIsVariable;
+ RELATIVE_VAR dummyRelativeVar;
+ TermMemberOpe( leftType, isNeedHeapFreeStructure, baseType, resultType, termFull, termLeft, methodName, dummyIsVariable, dummyRelativeVar );
+
+ // 戻り値のオブジェクトインスタンスのインデクサを呼び出す
+ char temporary[VN_SIZE], temp2[VN_SIZE];
+ sprintf( temporary, "[%s]", parameter );
+ sprintf( temp2, "%s.%s", termLeft, methodName );
+ Type classType = resultType;
+ return TermMemberOpe( classType, isNeedHeapFreeStructure, baseType, resultType, termFull, temp2, temporary, isVariable, relativeVar );
+ }
+
+ resultType = pUserProc->ReturnType();
+
+ {
+ //オブジェクトポインタをスタックに入れておく
+ //push reg
+ compiler.codeGenerator.op_push( useReg );
+
+ if( !Opcode_CallProc(parameter,pUserProc,PROCFLAG_NEW,termLeft) ){
+
+ return false;
+ }
+
+ compiler.codeGenerator.op_pop();
+
+ /////////////////////
+ // 戻り値の処理
+ /////////////////////
+
+ //大きな型への暗黙の変換
+ int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
+
+ if( resultType.GetBasicType() != bigType ){
+ // 大きな型へ変換された場合
+ // ※レジスタの値をキャストする
+ ExtendRegToBigType( REG_EAX, bigType, resultType.GetBasicType() );
+
+ resultType.SetBasicType( bigType );
+ }
+
+ //SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
+
+ // 型パラメータを解決
+ ResolveFormalGenericTypeParameter( resultType, leftType, pUserProc );
+ }
+
+ return true;
+ }
+ }
+ else if( pareOrBracket == Pare )
+ {
+ // 関数ポインタ
+ SetError();
+
+ ///////////////////////////////////////////////////////////////////
+ // メンバを検索
+ ///////////////////////////////////////////////////////////////////
+ if( GetMemberType( leftType, methodName, resultType, 0, false ) ){
+ // メンバが見つかったとき
+ }
+ }
+
+ SetError();
+
+ return false;
+}
+bool _TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, bool &isNeedHeapFreeStructure, bool *pIsClassName, bool isProcedureCallOnly, bool &isVariable, RELATIVE_VAR &relativeVar, bool isWriteAccess )
+{
+ char parameter[VN_SIZE];
+
+ // Withを解決
+ char termFull[VN_SIZE];
+ if(term[0]=='.'){
+ GetWithName(termFull);
+ lstrcat(termFull,term);
+ }
+ else lstrcpy(termFull,term);
+
+ char termLeft[VN_SIZE];
+ lstrcpy(termLeft,termFull);
+
+ // パース
+ char member[VN_SIZE];
+ ReferenceKind refType;
+ if( SplitMemberName( termFull, termLeft, member, refType ) ){
+ ///////////////////////////////////////////////////////////////////
+ // オブジェクトとメンバに分解できるとき
+ // termLeft.member
+ ///////////////////////////////////////////////////////////////////
+
+ isLiteral = false;
+
+ // オブジェクト側の型を取得
+ bool isClassName = false;
+ Type leftType;
+ if( GetTermType( termLeft, Type(), leftType, isLiteral, &isClassName ) ){
+ if( isClassName == false && compiler.GetObjectModule().meta.GetBlittableTypes().IsExist( leftType ) ){
+ // 左側のオブジェクト部分がBlittable型のとき
+
+ char temporary[VN_SIZE];
+ lstrcpy( temporary, termLeft );
+ sprintf( termLeft, "%s(%s)",
+ compiler.GetObjectModule().meta.GetBlittableTypes().Find( leftType ).GetCreateStaticMethodFullName().c_str(),
+ temporary );
+ }
+ }
+
+ if( !TermOpe( termLeft, baseType, leftType, isLiteral, isNeedHeapFreeStructure, &isClassName ) ){
+ goto globalArea;
+ }
+
+ if( isClassName ){
+ // 静的メンバ/メソッドの場合
+ goto globalArea;
+ }
+
+ if( !leftType.HasMember() ){
+ // メンバを持たない型の場合
+ if( isProcedureCallOnly )
+ {
+ SetError(1,NULL,cp);
+ }
+ return false;
+ }
+
+ return TermMemberOpe( leftType, isNeedHeapFreeStructure, baseType, resultType, termFull, termLeft, member, isVariable, relativeVar );
+ }
+globalArea:
+
+
+ //////////////////////////////////////////////
+ // クラス名かどうかをチェック（静的メンバ用）
+ //////////////////////////////////////////////
+
+ if( pIsClassName ){
+ if( compiler.GetObjectModule().meta.GetClasses().Find( termFull ) ){
+ *pIsClassName = true;
+ return true;
+ }
+ }
+
+
+ /////////////////////////////////////////////////////////////////
+ // グローバル属性エリア
+ /////////////////////////////////////////////////////////////////
+
+ const int useReg = REG_EAX;
+
+
+ if(lstrcmpi(termFull,"This")==0 && isProcedureCallOnly == false ){
+ if( compiler.pCompilingClass == NULL )
+ {
+ SetError(142,NULL,cp);
+ return false;
+ }
+
+ //Thisオブジェクト
+ resultType.SetType( DEF_OBJECT, compiler.pCompilingClass );
+
+ SetThisPtrToReg( useReg );
+
+ isLiteral = false;
+
+ return true;
+ }
+
+
+ //////////////////////////////////////
+ // 関数（DLL、ユーザー定義、組み込み）
+ //////////////////////////////////////
+ char procName[VN_SIZE];
+ char temporary[8192];
+
+ int i2=GetCallProcName(termFull,procName);
+ if(termFull[i2]=='('){
+ int i4=GetStringInPare_RemovePare(parameter,termFull+i2+1);
+
+ void *pInfo;
+ int idProc=GetProc(procName,(void **)&pInfo);
+
+ if(idProc)
+ {
+ if(termFull[i2+1+i4+1]!='\0')
+ {
+ //閉じカッコ")"に続く文字がNULLでないとき
+ SetError(42,NULL,cp);
+ }
+
+
+ {
+ ////////////////
+ // 呼び出し
+ ////////////////
+
+ CallProc(idProc,pInfo,procName,parameter, baseType,resultType);
+
+
+ /////////////////////
+ // 戻り値の処理
+ /////////////////////
+
+ //大きな型への暗黙の変換
+ int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
+
+ /*
+ ※後でNumOpe内でプッシュする
+ //スタックへプッシュ
+ PushReturnValue( resultType.GetBasicType() );
+ */
+
+ if( resultType.GetBasicType() != bigType ){
+ // 大きな型へ変換された場合
+ // ※レジスタの値をキャストする
+ ExtendRegToBigType( useReg, bigType, resultType.GetBasicType() );
+
+ resultType.SetBasicType( bigType );
+ }
+
+ //SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
+ }
+
+
+ if(resultType.IsStruct())
+ {
+ //構造体が戻ったときはヒープ領域にインスタンスが格納されている
+ //※後にfreeする必要あり
+ // TODO: 解放はGCに任せる
+ isNeedHeapFreeStructure = true;
+ }
+
+ isLiteral = false;
+
+ return true;
+ }
+
+ ConstMacro *pConstMacro = compiler.GetObjectModule().meta.GetGlobalConstMacros().Find( procName );
+ if( pConstMacro )
+ {
+ if( pConstMacro->GetCalcBuffer( parameter, temporary ) )
+ {
+ /////////////////////////
+ // マクロ関数
+ /////////////////////////
+
+ //閉じカッコ")"に続く文字がNULLでないときはエラーにする
+ if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
+
+ //マクロ関数の場合
+ NumOpe(useReg, temporary,Type(),resultType);
+
+ if(!IS_LITERAL(resultType.GetIndex())){
+ //リテラル値ではなかったとき
+ isLiteral = false;
+ }
+
+ return true;
+ }
+ }
+ }
+ else if( isProcedureCallOnly ){
+ // 関数呼び出し以外は受け付けない
+ return false;
+ }
+
+
+ ////////////////////////////////
+ // インデクサ（getアクセサ）
+ ////////////////////////////////
+
+ char VarName[VN_SIZE],ArrayElements[VN_SIZE];
+ GetArrayElement(termFull,VarName,ArrayElements);
+ if(ArrayElements[0]){
+ Type classType;
+ GetVarType(VarName,classType,false);
+ if( classType.IsObject() )
+ {
+ CallIndexerGetterProc(/*UseReg,*/classType,VarName, ArrayElements,resultType);
+
+ isLiteral = false;
+
+ return true;
+ }
+ }
+
+
+ ////////////////////////////////
+ // 変数
+ ////////////////////////////////
+
+ if(GetVarOffset(
+ false, //エラー表示なし
+ isWriteAccess,
+ termFull,
+ &relativeVar,resultType)){
+ //////////
+ // 変数
+ //////////
+
+ // 変数として扱う
+ isVariable = true;
+
+ isLiteral = false;
+
+ return true;
+ }
+
+
+ /////////////////////////////////
+ // プロパティ用のメソッド
+ /////////////////////////////////
+
+ //配列要素を排除
+ GetArrayElement(termFull,VarName,ArrayElements);
+
+ if(GetSubHash(VarName,0)){
+
+ {
+ CallPropertyMethod(termFull,NULL,resultType);
+
+ //大きな型への暗黙の変換
+ int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
+
+ if( resultType.GetBasicType() != bigType ){
+ // 大きな型へ変換された場合
+ // ※レジスタの値をキャストする
+ ExtendRegToBigType( REG_EAX, bigType, resultType.GetBasicType() );
+
+ resultType.SetBasicType( bigType );
+ }
+
+ //SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
+ }
+
+
+ if(resultType.IsStruct())
+ {
+ //構造体が戻ったときはヒープ領域にインスタンスが格納されている
+ //※後にfreeする必要あり
+ // TODO: 解放はGCに任せる
+ isNeedHeapFreeStructure = true;
+ }
+
+ isLiteral = false;
+
+ return true;
+ }
+
+ if( isProcedureCallOnly )
+ {
+ SetError(3, termLeft, cp );
+ }
+
+ return false;
+}
+
+bool TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, bool &isNeedHeapFreeStructure, bool *pIsClassName, bool isProcedureCallOnly, bool isWriteAccess )
+{
+ RELATIVE_VAR relativeVar;
+ bool isVariable = false;
+ bool result = _TermOpe( term, baseType, resultType, isLiteral, isNeedHeapFreeStructure, pIsClassName, isProcedureCallOnly, isVariable, relativeVar, isWriteAccess );
+
+ if( isVariable )
+ {
+ // 変数の場合はeaxに変数ポインタを格納する
+ if( !VarToReg( relativeVar, baseType, resultType ) ){
+ SetError(11,term,cp);
+ }
+ }
+
+ return result;
+}
+bool TermOpeOnlyVariable( const char *term, Type &resultType, RELATIVE_VAR &relativeVar, bool isWriteAccess )
+{
+ bool isLiteral, isVariable = false, isNeedHeapFreeStructure = false;
+ bool result = _TermOpe( term, Type(), resultType, isLiteral, isNeedHeapFreeStructure, NULL, false, isVariable, relativeVar, isWriteAccess );
+
+ if( !isVariable )
+ {
+ SetError();
+ }
+
+ return result;
+}
+
+
+bool NumOpe( int reg,
+ const char *expression,
+ const Type &baseType,
+ Type &resultType,
+ bool *pbIsNeedHeapFreeStructure ){
+
+ if( !NumOpe( expression, baseType, resultType, pbIsNeedHeapFreeStructure ) )
+ {
+ return false;
+ }
+
+ if( reg != REG_EAX ){
+ // TODO: 未実装
+ SetError();
+ }
+
+ if( resultType.IsReal() ){
+ //fld ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp( resultType.GetBasicType() );
+
+ //add esp,size
+ compiler.codeGenerator.op_add_esp( resultType.GetBasicSize() );
+ }
+ else{
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ if( resultType.Is64() ){
+ //pop edx
+ compiler.codeGenerator.op_pop(REG_EDX);
+ }
+ }
+ return true;
+}
+bool NumOpe( const char *expression,
+ const Type &baseType,
+ Type &resultType,
+ bool *pbIsNeedHeapFreeStructure )
+{
+ int i,i2,i3;
+ char temporary[1024],temp2[1024];
+
+ if(expression[0]=='\0'){
+ SetError(1,NULL,cp);
+ return false;
+ }
+
+ if( !baseType.IsNull() && expression[0] == '[' ){
+ // リテラル配列の場合
+
+ int dataTableOffset;
+ if( !compiler.GetObjectModule().dataTable.MakeLiteralArrayBuffer( expression, baseType, dataTableOffset ) )
+ {
+ return false;
+ }
+
+ //mov eax,i2
+ compiler.codeGenerator.op_mov_RV(REG_EAX,dataTableOffset, Schedule::DataTable );
+
+ resultType = baseType;
+
+ //push eax
+ compiler.codeGenerator.op_push( REG_EAX );
+
+ return true;
+ }
+
+ bool isLiteralCalculation;
+ if( NumOpe_GetType( expression, baseType, resultType, &isLiteralCalculation ) )
+ {
+ if( isLiteralCalculation )
+ {
+ //右辺値が数値の定数式の場合
+ _int64 i64data;
+ StaticCalculation(true, expression,baseType.GetBasicType(),&i64data,resultType);
+
+ if( resultType.GetBasicSize() == sizeof(_int64) ){
+ //64ビット（符号有り整数/実数）
+
+ //push HILONG(i64data)
+ compiler.codeGenerator.op_push_V((long)*(long *)(((char *)(&i64data))+4));
+
+ //push LOLONG(i64data)
+ compiler.codeGenerator.op_push_V(*(long *)(&i64data));
+ }
+ else if( resultType.IsSingle() ){
+ //single実数
+
+ double dbl;
+ memcpy(&dbl,&i64data,sizeof(_int64));
+
+ float flt;
+ flt=(float)dbl;
+ long l;
+ memcpy(&l,&flt,sizeof(long));
+
+ //push flt
+ compiler.codeGenerator.op_push_V(l);
+ }
+ else{
+ //整数（符号有り/無し）
+
+ long l = (long)i64data;
+
+ if(resultType.GetBasicSize()==sizeof(char)) l = l & 0x000000FF;
+ if(resultType.GetBasicSize()==sizeof(short)) l = l & 0x0000FFFF;
+
+ //push term
+ compiler.codeGenerator.op_push_V(l);
+ }
+ return true;
+ }
+ }
+
+ if(expression[0]==1 )
+ {
+ if( expression[1]==ESC_NEW ){
+ //New演算子（オブジェクト生成）
+
+ if( !Operator_New( expression+2, baseType, resultType ) ){
+ return false;
+ }
+
+ return true;
+ }
+ else if( expression[1] == ESC_SYSTEM_STATIC_NEW )
+ {
+ // 静的領域にオブジェクトを作る
+
+ // 静的領域にオブジェクトを生成
+ int dataTableOffset;
+ if( !compiler.GetObjectModule().dataTable.MakeConstObjectToProcessStaticBuffer( expression + 2, resultType, dataTableOffset ) )
+ {
+ return false;
+ }
+
+ // push value
+ compiler.codeGenerator.op_push_V( dataTableOffset, Schedule::DataTable );
+
+ return true;
+ }
+ }
+
+
+ /////////////////////////////////
+ // 式要素を逆ポーランド式で取得
+ /////////////////////////////////
+
+ char *values[255];
+ long calc[255];
+ long stack[255];
+ int pnum;
+ if(!GetNumOpeElements(expression,&pnum,values,calc,stack)){
+ for(i=0;iIsEqualsOrSubClass( (CClass *)index_stack[sp-2] ) || ((CClass *)index_stack[sp-2])->IsEqualsOrSubClass( (CClass *)index_stack[sp-1] )
+ )){
+ // ダウンキャストを許可する
+ }
+ else{
+ //オーバーロードされたオペレータを呼び出す
+ i2=CallOperatorProc(idCalc,baseType,type_stack,index_stack,isNeedHeapFreeStructureStack,sp);
+ if(i2==0){
+ if(idCalc==CALC_EQUAL) lstrcpy(temp2,"==");
+ else GetCalcName(idCalc,temp2);
+ sprintf(temporary,"Operator %s",temp2);
+ SetError(27,temporary,cp);
+ goto error;
+ }
+ else if(i2==-1) goto error;
+
+ continue;
+ }
+ }
+
+ if(!CheckCalcType(idCalc,type_stack,sp)) goto error;
+ }
+
+ switch(idCalc){
+ //数値
+ case 0:
+ index_stack[sp]=-1;
+ isNothing_stack[sp] = false;
+ isNeedHeapFreeStructureStack[sp] = false;
+
+ char *term;
+ term=values[i];
+
+ if( calc[i+1]%100 == CALC_AS ){
+ // As演算子の右辺値
+ //型名
+ if( compiler.StringToType( term, resultType ) ){
+ resultType.SetBasicType( resultType.GetBasicType() | FLAG_CAST );
+ }
+ else{
+ SetError(3, term, cp );
+ goto error;
+ }
+
+ type_stack[sp] = resultType.GetBasicType();
+ index_stack[sp] = resultType.GetIndex();
+ sp++;
+
+ break;
+ }
+
+ if( (term[0]=='e'||term[0]=='E')
+ && (term[1]=='x'||term[1]=='X')
+ && term[2]=='\"'
+ || term[0] == '\"' )
+ {
+ bool isEx = true;
+ if( term[0] == '\"' )
+ {
+ isEx = false;
+ }
+
+ if( isEx )
+ {
+ // 拡張版リテラル文字列（エスケープシーケンス可能）
+ if(!RemoveStringQuotes(term+2)){
+ SetError(43,NULL,cp);
+ goto error;
+ }
+ i3=FormatString_EscapeSequence(term+2);
+ term+=2;
+ }
+ else
+ {
+ // 通常文字列
+ if(!RemoveStringQuotes(term)){
+ SetError(43,NULL,cp);
+ goto error;
+ }
+ i3=lstrlen(term);
+ }
+
+ if( !baseType.IsPointer() )
+ {
+ //要求タイプがオブジェクト、または未定のとき
+
+ //String型オブジェクトを生成
+ i2 = compiler.GetObjectModule().dataTable.MakeConstStringObjectToProcessStaticBuffer( term );
+
+ // push value
+ compiler.codeGenerator.op_push_V( i2, Schedule::DataTable );
+
+ type_stack[sp]=DEF_OBJECT;
+ index_stack[sp]=(LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
+ bLiteralCalculation=0;
+
+ sp++;
+ break;
+ }
+StrLiteral:
+ type_stack[sp]=typeOfPtrChar;
+ bLiteralCalculation=0;
+
+ i2=compiler.GetObjectModule().dataTable.AddString(term,i3);
+
+ //push DataSize
+ compiler.codeGenerator.op_push_V( i2, Schedule::DataTable );
+ }
+ else if(IsVariableTopChar(term[0])||
+ term[0]=='*'||
+ (term[0]=='.'&&IsVariableTopChar(term[1]))){
+ //////////////////
+ // 何らかの識別子
+
+ bool isLiteral;
+ if( TermOpe( term, baseType, resultType, isLiteral, isNeedHeapFreeStructureStack[sp] ) ){
+ if(resultType.IsNull()){
+ //戻り値が存在しないとき
+ for(i2=0;;i2++){
+ if(term[i2]=='('||term[i2]=='\0'){
+ term[i2]=0;
+ break;
+ }
+ }
+ SetError(38,term,cp);
+
+ goto error;
+ }
+
+ type_stack[sp] = resultType.GetBasicType();
+ index_stack[sp] = resultType.GetIndex();
+
+ if( !isLiteral ){
+ bLiteralCalculation=0;
+ }
+
+ if( resultType.GetBasicType() & FLAG_CAST ){
+ // 型名のみ
+ SetError();
+ }
+ else{
+ if( resultType.IsReal() ){
+ //sub esp,size
+ //fstp ptr[esp]
+ compiler.codeGenerator.op_fstp_push( resultType );
+ }
+ else{
+ if( resultType.Is64() ){
+ //push edx
+ compiler.codeGenerator.op_push( REG_EDX );
+ }
+ else{
+ ExtendTypeTo32( resultType.GetBasicType(), REG_EAX );
+ }
+
+ //push eax
+ compiler.codeGenerator.op_push( REG_EAX );
+ }
+ }
+
+ sp++;
+ break;
+ }
+
+
+ // Nothing
+ if( lstrcmp( term, "Nothing" ) == 0 ){
+ isNothing_stack[sp] = true;
+
+ type_stack[sp] = DEF_OBJECT;
+ if( baseType.IsObject() ){
+ index_stack[sp] = baseType.GetIndex();
+ }
+ else{
+ index_stack[sp] = (LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr();
+ }
+
+ bLiteralCalculation = 0;
+
+ //push 0
+ compiler.codeGenerator.op_push_V( 0 );
+
+ sp++;
+ break;
+ }
+
+
+ //////////////
+ // 定数の場合
+ //////////////
+
+ i3 = compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType(term);
+ if(i3){
+ if( compiler.GetObjectModule().meta.GetGlobalConsts().IsStringPtr( term ) ){
+ //リテラル文字列
+
+ if( baseType.IsObject() || baseType.IsNull() )
+ {
+ //要求タイプがオブジェクト、または未定のとき
+
+ //String型オブジェクトを生成
+ NewStringObject(term);
+
+ type_stack[sp]=DEF_OBJECT;
+ index_stack[sp]=(LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
+ bLiteralCalculation=0;
+
+ sp++;
+ break;
+ }
+
+ double dbl = compiler.GetObjectModule().meta.GetGlobalConsts().GetDoubleData(term);
+ memcpy(&i64data,&dbl,sizeof(double));
+
+ //バイト数
+ i3=lstrlen((char *)i64data);
+
+ memcpy(term,(char *)i64data,i3);
+ term[i3]=0;
+ goto StrLiteral;
+ }
+
+ type_stack[sp]=i3;
+ if(IsRealNumberType(i3)){
+ //実数
+ double dbl = compiler.GetObjectModule().meta.GetGlobalConsts().GetDoubleData(term);
+ memcpy(&i64data,&dbl,sizeof(double));
+ goto Literal;
+ }
+ else if(IsWholeNumberType(i3)){
+ //整数
+ i64data = compiler.GetObjectModule().meta.GetGlobalConsts().GetWholeData(term);
+ goto Literal;
+ }
+ else{
+ SetError(300,NULL,cp);
+ goto error;
+ }
+ }
+
+
+ //該当する識別子が見当たらないときはエラー扱いにする
+ bError=1;
+ SetError(3,term,cp);
+ type_stack[sp]=DEF_DOUBLE;
+ }
+ else{
+ //リテラル値
+ type_stack[sp]=GetLiteralValue(term,&i64data,baseType.GetBasicType());
+Literal:
+ if(type_stack[sp]==DEF_INT64||
+ type_stack[sp]==DEF_QWORD||
+ type_stack[sp]==DEF_DOUBLE){
+ //64ビット（符号有り整数/実数）
+
+ //push HILONG(dbl)
+ compiler.codeGenerator.op_push_V((long)*(long *)(((char *)(&i64data))+4));
+
+ //push LOLONG(dbl)
+ compiler.codeGenerator.op_push_V(*(long *)(&i64data));
+ }
+ else if(type_stack[sp]==DEF_SINGLE){
+ //single実数
+
+ float flt;
+ memcpy(&dbl,&i64data,sizeof(double));
+ flt=(float)dbl;
+ memcpy(&i3,&flt,sizeof(long));
+
+ //push term
+ compiler.codeGenerator.op_push_V(i3);
+ }
+ else{
+ //その他
+
+ //push term
+ compiler.codeGenerator.op_push_V((long)i64data);
+
+ if((long)i64data==0) index_stack[sp]=LITERAL_NULL;
+ }
+
+
+ //リテラル値の種類
+ if(Is64Type(type_stack[sp])==0&&IsRealNumberType(type_stack[sp])==0){
+ //整数（符号有り/無し）
+
+ index_stack[sp]=GetLiteralIndex(i64data);
+ }
+ }
+ sp++;
+ break;
+
+ //論理演算子
+ case CALC_XOR:
+ //value[sp-2] xor= value[sp-1]
+ //xor演算
+ if(!Calc_Xor(type_stack,index_stack,&sp)) goto error;
+ break;
+ case CALC_OR:
+ //value[sp-2] or= value[sp-1]
+ //or演算
+ if(!Calc_Or(type_stack,index_stack,&sp)) goto error;
+ break;
+ case CALC_AND:
+ //value[sp-2] and= value[sp-1]
+ //and演算
+ if(!Calc_And(type_stack,index_stack,&sp)) goto error;
+ break;
+ case CALC_NOT:
+ //value[sp-1]=Not value[sp-1]
+ //NOT演算子
+ if(!Calc_Not(type_stack,sp)) goto error;
+ break;
+
+ //比較演算子
+ case CALC_PE:
+ //value[sp-2]<=value[sp-1]
+ if(!Calc_Relation_PE(type_stack,index_stack,&sp)) goto error;
+ break;
+ case CALC_QE:
+ //value[sp-2]>=value[sp-1]
+ if(!Calc_Relation_QE(type_stack,index_stack,&sp)) goto error;
+ break;
+ case CALC_P:
+ //value[sp-2]value[sp-1]
+ if(!Calc_Relation_Q(type_stack,index_stack,&sp)) goto error;
+ break;
+ case CALC_NOTEQUAL:
+ //value[sp-2]<>value[sp-1]
+ if(!Calc_Relation_NotEqual(type_stack,&sp)) goto error;
+ break;
+ case CALC_EQUAL:
+ //value[sp-2]=value[sp-1]
+ if(!Calc_Relation_Equal(type_stack,&sp)) goto error;
+ break;
+
+ //ビットシフト
+ case CALC_SHL:
+ //value[sp-2]=value[sp-2]<>value[sp-1]
+ if(!Calc_SHR(type_stack,&sp)) goto error;
+ break;
+
+ //算術演算
+ case CALC_ADDITION:
+ case CALC_SUBTRACTION:
+ case CALC_PRODUCT:
+ if(!CalcTwoTerm_Arithmetic(idCalc,type_stack,index_stack,&sp)) goto error;
+ break;
+
+ case CALC_MOD:
+ //value[sp-2]%=value[sp-1]
+ //剰余演算
+ if(!Calc_Mod(type_stack,&sp)) goto error;
+ break;
+ case CALC_QUOTIENT:
+ //value[sp-2]/=value[sp-1];
+ //除算
+ if(!Calc_Divide(type_stack,&sp,baseType.GetBasicType())) goto error;
+ break;
+ case CALC_INTQUOTIENT:
+ //value[sp-2]/=value[sp-1]
+ //整数除算
+ if(!Calc_IntDivide(type_stack,index_stack,&sp)) goto error;
+ break;
+ case CALC_MINUSMARK:
+ //value[sp-1]=-value[sp-1]
+ //符号反転
+ if(!Calc_MinusMark(type_stack,sp)) goto error;
+ index_stack[sp-1]=-1;
+ break;
+ case CALC_POWER:
+ //べき乗演算（浮動小数点演算のみ）
+ if(!Calc_Power(type_stack,&sp)) goto error;
+ break;
+ case CALC_AS:
+ //キャスト
+ if(!Calc_Cast(type_stack,index_stack,&sp)) goto error;
+ break;
+
+ case CALC_BYVAL:
+ //ポインタ型→参照型
+ if( PTR_LEVEL( type_stack[sp-1] ) <= 0 ){
+ //ポインタ型ではないとき
+ SetError( 3, NULL, cp );
+ goto error;
+ }
+
+ type_stack[sp-1] = PTR_LEVEL_DOWN( type_stack[sp-1] );
+
+ break;
+
+ default:
+ SetError(300,NULL,cp);
+ goto error;
+ }
+ }
+
+ if(bError) goto error;
+
+ if(sp!=1){
+ SetError(1,NULL,cp);
+ goto error;
+ }
+
+ if(bLiteralCalculation){
+ //右辺値が数値の定数式の場合
+ SetError();
+ }
+ else{
+ //右辺値が数値の定数式ではないとき
+ if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
+ }
+
+ if(pbIsNeedHeapFreeStructure)
+ {
+ *pbIsNeedHeapFreeStructure = isNeedHeapFreeStructureStack[0];
+ }
+
+ resultType.SetType( type_stack[0], index_stack[0] );
+
+ bool isSuccessful = true;
+ goto finish;
+
+
+error:
+ isSuccessful = false;
+ goto finish;
+
+
+finish:
+
+ for(i=0;i
+
+#include "../BasicCompiler_Common/common.h"
+#include "Opcode.h"
+
+void GetStackData_ToRegister(int *type,int sp){
+ /*NumOpeポーランドのスタック蓄積による演算内容（2つのデータ）を
+ レジスタedx:eax、ecx:ebxに取得する*/
+
+ if(type[sp-1]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //fistp qword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+ }
+ else if(type[sp-1]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ //fistp qword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+ }
+ else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+ }
+ else{
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ if(IsSignedType(type[sp-1])){
+ //符号拡張
+ //edx:eax ← eax
+
+ //cdq
+ compiler.codeGenerator.op_cdq();
+ }
+ else{
+ //ビット拡張
+ //edx:eax ← eax
+
+ //xor edx,edx
+ compiler.codeGenerator.op_zero_reg(REG_EDX);
+ }
+
+ //mov ebx,eax
+ compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
+
+ //mov ecx,edx
+ compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
+ }
+
+ //第1項を64ビットに対応させる
+ if(type[sp-2]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //fistp qword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //pop edx
+ compiler.codeGenerator.op_pop(REG_EDX);
+ }
+ else if(type[sp-2]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ //fistp qword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //pop edx
+ compiler.codeGenerator.op_pop(REG_EDX);
+ }
+ else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //pop edx
+ compiler.codeGenerator.op_pop(REG_EDX);
+ }
+ else{
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ if(IsSignedType(type[sp-2])){
+ //符号拡張
+ //edx:eax ← eax
+
+ //cdq
+ compiler.codeGenerator.op_cdq();
+ }
+ else{
+ //ビット拡張
+ //edx:eax ← eax
+
+ //xor edx,edx
+ compiler.codeGenerator.op_zero_reg(REG_EDX);
+ }
+ }
+}
+
+void FormatStackData_To64bit(int *type,int sp){
+ //NumOpeポーランドのスタック蓄積による演算内容（2つのデータ）を64ビット整数型にする
+
+ GetStackData_ToRegister(type,sp);
+
+ //push ecx
+ compiler.codeGenerator.op_push(REG_ECX);
+
+ //push ebx
+ compiler.codeGenerator.op_push(REG_EBX);
+
+ //push edx
+ compiler.codeGenerator.op_push(REG_EDX);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+}
+
+BOOL CalcTwoTerm_Arithmetic(int idCalc,int *type,LONG_PTR *index_stack,int *pStackPointer){
+ /* value[sp-2] = value[sp-2] + value[sp-1]
+ value[sp-2] = value[sp-2] - value[sp-1]
+ value[sp-2] = value[sp-2] * value[sp-1] */
+
+ int sp;
+ sp=*pStackPointer;
+
+ int AnswerType;
+ AnswerType=NeutralizationType(type[sp-2],index_stack[sp-2],type[sp-1],index_stack[sp-1]);
+
+ if(type[sp-2]==DEF_DOUBLE||type[sp-2]==DEF_SINGLE||
+ type[sp-1]==DEF_DOUBLE||type[sp-1]==DEF_SINGLE){
+ /////////////
+ // 実数演算
+ /////////////
+
+ if(type[sp-1]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else if(type[sp-1]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ //64ビット整数値
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else{
+ //その他整数型
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+
+ if(type[sp-2]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+ }
+ else if(type[sp-2]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+ }
+ else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
+ //64ビット整数値
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+ }
+ else{
+ //その他整数型
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+ }
+
+ if(Type(type[sp-2],-1).GetSize()==sizeof(_int64)){
+ if(AnswerType==DEF_SINGLE){
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ }
+ else{
+ if(AnswerType==DEF_DOUBLE){
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+ }
+ }
+
+ if(idCalc==CALC_ADDITION){
+ //faddp st(1),st
+ compiler.codeGenerator.PutOld(
+ (char)0xDE,
+ (char)0xC1
+ );
+ }
+ else if(idCalc==CALC_SUBTRACTION){
+ //fsubrp st(1),st
+ compiler.codeGenerator.PutOld(
+ (char)0xDE,
+ (char)0xE1
+ );
+ }
+ else if(idCalc==CALC_PRODUCT){
+ //fmulp st(1),st
+ compiler.codeGenerator.PutOld(
+ (char)0xDE,
+ (char)0xC9
+ );
+ }
+
+ if(AnswerType==DEF_DOUBLE){
+ //fstp qword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
+ }
+ else{
+ //fstp dword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
+ }
+ }
+ else if(Is64Type(type[sp-2])||Is64Type(type[sp-1])){
+ //////////////////////
+ // 64ビット整数演算
+ //////////////////////
+
+ if(idCalc==CALC_PRODUCT){
+ if(!((type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD)&&
+ (type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD))){
+ //2つの項のどちらかが64ビット整数でないとき
+ FormatStackData_To64bit(type,sp);
+ }
+
+ //call _allmul
+ extern const UserProc *pSub_allmul;
+ compiler.codeGenerator.op_call(pSub_allmul);
+
+ //push edx
+ compiler.codeGenerator.op_push(REG_EDX);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else{
+ if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ //第2項が64ビット整数値のとき
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+ }
+ else{
+ //第2項がその他整数値のとき
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ if(IsSignedType(type[sp-1])){
+ //符号拡張
+ //edx:eax ← eax
+
+ //cdq
+ compiler.codeGenerator.op_cdq();
+ }
+ else{
+ //ビット拡張
+ //edx:eax ← eax
+
+ //xor edx,edx
+ compiler.codeGenerator.op_zero_reg(REG_EDX);
+ }
+
+ //mov ebx,eax
+ compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
+
+ //mov ecx,edx
+ compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
+ }
+
+ if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
+ //第1項が64ビット整数値のとき
+
+ if(idCalc==CALC_ADDITION){
+ //add dword ptr[esp],ebx
+ compiler.codeGenerator.PutOld(
+ (char)0x01,
+ (char)0x1C,
+ (char)0x24
+ );
+
+ //adc dword ptr[esp+sizeof(long)],ecx
+ compiler.codeGenerator.PutOld(
+ (char)0x11,
+ (char)0x4C,
+ (char)0x24,
+ (char)0x04
+ );
+ }
+ else if(idCalc==CALC_SUBTRACTION){
+ //sub dword ptr[esp],ebx
+ compiler.codeGenerator.PutOld(
+ (char)0x29,
+ (char)0x1C,
+ (char)0x24
+ );
+
+ //sbb dword ptr[esp+sizeof(long)],ecx
+ compiler.codeGenerator.PutOld(
+ (char)0x19,
+ (char)0x4C,
+ (char)0x24,
+ (char)0x04
+ );
+ }
+ }
+ else{
+ //第1項がその他整数値のとき
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ if(IsSignedType(type[sp-2])){
+ //符号拡張
+ //edx:eax ← eax
+
+ //cdq
+ compiler.codeGenerator.op_cdq();
+ }
+ else{
+ //ビット拡張
+ //edx:eax ← eax
+
+ //xor edx,edx
+ compiler.codeGenerator.op_zero_reg(REG_EDX);
+ }
+
+ if(idCalc==CALC_ADDITION){
+ //add ebx,eax
+ compiler.codeGenerator.op_add_RR( REG_EBX, REG_EAX );
+
+ //adc ecx,edx
+ compiler.codeGenerator.op_adc_RR( REG_ECX, REG_EDX );
+ }
+ else if(idCalc==CALC_SUBTRACTION){
+ //sub ebx,eax
+ compiler.codeGenerator.op_sub_RR( REG_EBX, REG_EAX );
+
+ //sbb ecx,edx
+ compiler.codeGenerator.op_sub_RR( REG_ECX, REG_EDX );
+ }
+
+ //push ecx
+ compiler.codeGenerator.op_push(REG_ECX);
+
+ //push ebx
+ compiler.codeGenerator.op_push(REG_EBX);
+ }
+ }
+ }
+ else{
+ //////////////////////////
+ //32ビット以下の整数演算
+ //////////////////////////
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ if(idCalc==CALC_ADDITION){
+ //add eax,ebx
+ compiler.codeGenerator.op_add_RR( REG_EAX, REG_EBX );
+ }
+ else if(idCalc==CALC_SUBTRACTION){
+ //sub eax,ebx
+ compiler.codeGenerator.op_sub_RR( REG_EAX, REG_EBX );
+ }
+ else if(idCalc==CALC_PRODUCT){
+ //imul eax,ebx（64ビット演算ではないので、符号を考慮しない）
+ compiler.codeGenerator.op_imul_RR( REG_EAX, REG_EBX );
+ }
+
+ //mov dword ptr[esp],eax
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
+ }
+
+ sp--;
+ type[sp-1]=AnswerType;
+
+ *pStackPointer=sp;
+
+ return 1;
+}
+
+BOOL Calc_Mod(int *type,int *pStackPointer){
+ //value[sp-2]%=value[sp-1]
+ //剰余演算
+
+ int sp;
+ sp=*pStackPointer;
+
+ if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD||
+ type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
+ ////////////////
+ // 64ビット演算
+ ////////////////
+
+ //第2項を64ビットに対応させる
+ FormatStackData_To64bit(type,sp);
+
+ if(IsSignedType(type[sp-2])==0&&IsSignedType(type[sp-1])==0){
+ //符号なし演算
+
+ //call _aullrem
+ extern const UserProc *pSub_aullrem;
+ compiler.codeGenerator.op_call(pSub_aullrem);
+ }
+ else{
+ //符号あり演算
+
+ //call _allrem
+ extern const UserProc *pSub_allrem;
+ compiler.codeGenerator.op_call(pSub_allrem);
+ }
+
+ //push edx
+ compiler.codeGenerator.op_push(REG_EDX);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+ sp--;
+ if(type[sp-1]==DEF_QWORD&&type[sp]==DEF_QWORD) type[sp-1]=DEF_QWORD;
+ else type[sp-1]=DEF_INT64;
+ }
+ else{
+ ////////////////
+ // 32ビット演算
+ ////////////////
+
+ if(type[sp-1]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+ }
+ else if(type[sp-1]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+ }
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ if(type[sp-2]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+ }
+ else if(type[sp-2]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+ }
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ if(type[sp-2]==DEF_DWORD&&type[sp-1]==DEF_DWORD){
+ //xor edx,edx
+ compiler.codeGenerator.op_zero_reg(REG_EDX);
+
+ //div ebx (eax=eax/ebx...edx)
+ compiler.codeGenerator.op_div_R( REG_EBX );
+ }
+ else{
+ //cdq
+ compiler.codeGenerator.op_cdq();
+
+ //idiv ebx (eax=eax/ebx...edx)
+ compiler.codeGenerator.op_idiv_R( REG_EBX );
+ }
+
+ //mov dword ptr[esp],edx
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EDX, REG_ESP, 0, MOD_BASE );
+
+ sp--;
+ type[sp-1]=DEF_LONG;
+ }
+
+ *pStackPointer=sp;
+
+ return 1;
+}
+
+BOOL Calc_Divide(int *type,int *pStackPointer,int BaseType){
+ //value[sp-2]/=value[sp-1];
+ //除算
+
+ int sp;
+ sp=*pStackPointer;
+
+ ///////////////////////
+ // 浮動小数点演算のみ
+ ///////////////////////
+
+ int AnswerType;
+ if(type[sp-2]==DEF_DOUBLE||type[sp-1]==DEF_DOUBLE||BaseType==DEF_DOUBLE) AnswerType=DEF_DOUBLE;
+ else AnswerType=DEF_SINGLE;
+
+ if(type[sp-1]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else if(type[sp-1]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ //64ビット整数値
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else if(type[sp-1]==DEF_DWORD){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //push 0
+ compiler.codeGenerator.op_push_V(0);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else{
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+
+ if(type[sp-2]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+ }
+ else if(type[sp-2]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+ }
+ else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
+ //64ビット整数値
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+ }
+ else if(type[sp-2]==DEF_DWORD){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //push 0
+ compiler.codeGenerator.op_push_V(0);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+ }
+ else{ //Long
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+ }
+ //↓ここだけ例外DWord
+ if(Type(type[sp-2],-1).GetSize()==sizeof(_int64)||type[sp-2]==DEF_DWORD){
+ if(AnswerType==DEF_SINGLE){
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ }
+ else{
+ if(AnswerType==DEF_DOUBLE){
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+ }
+ }
+
+ //fdivrp st(1),st
+ compiler.codeGenerator.PutOld(
+ (char)0xDE,
+ (char)0xF1
+ );
+
+ sp--;
+ if(AnswerType==DEF_DOUBLE){
+ //fstp qword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
+
+ type[sp-1]=DEF_DOUBLE;
+ }
+ else{
+ //fstp dword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
+
+ type[sp-1]=DEF_SINGLE;
+ }
+
+ *pStackPointer=sp;
+
+ return 1;
+}
+
+BOOL Calc_IntDivide(int *type,LONG_PTR *index_stack,int *pStackPointer){
+ //value[sp-2]/=value[sp-1]
+ //除算（整数）
+
+ int sp;
+ sp=*pStackPointer;
+
+ if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD||
+ type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
+ ////////////////
+ // 64ビット演算
+ ////////////////
+
+ //2つの項を64ビットに対応させる
+ FormatStackData_To64bit(type,sp);
+
+ if(IsSignedType(type[sp-2])==0&&IsSignedType(type[sp-1])==0){
+ //符号なし演算
+
+ //call _aulldiv
+ extern const UserProc *pSub_aulldiv;
+ compiler.codeGenerator.op_call(pSub_aulldiv);
+ }
+ else{
+ //符号あり演算
+
+ //call _alldiv
+ extern const UserProc *pSub_alldiv;
+ compiler.codeGenerator.op_call(pSub_alldiv);
+ }
+
+ //push edx
+ compiler.codeGenerator.op_push(REG_EDX);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+ sp--;
+ if(type[sp-1]==DEF_QWORD&&type[sp]==DEF_QWORD) type[sp-1]=DEF_QWORD;
+ else type[sp-1]=DEF_INT64;
+ }
+ else{
+ ////////////////
+ // 32ビット演算
+ ////////////////
+
+ if(type[sp-1]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+ }
+ else if(type[sp-1]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+ }
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ if(type[sp-2]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+ }
+ else if(type[sp-2]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+ }
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ if((type[sp-2]==DEF_DWORD&&type[sp-1]==DEF_DWORD)||
+ (IS_POSITIVE_LITERAL(index_stack[sp-2])&&type[sp-1]==DEF_DWORD)||
+ (type[sp-2]==DEF_DWORD&&IS_POSITIVE_LITERAL(index_stack[sp-1]))){
+ //xor edx,edx
+ compiler.codeGenerator.op_zero_reg(REG_EDX);
+
+ //div ebx (eax=eax/ebx...edx)
+ compiler.codeGenerator.op_div_R( REG_EBX );
+ }
+ else{
+ //cdq
+ compiler.codeGenerator.op_cdq();
+
+ //idiv ebx (eax=eax/ebx...edx)
+ compiler.codeGenerator.op_idiv_R( REG_EBX );
+ }
+
+ //mov dword ptr[esp],eax
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
+
+ sp--;
+
+ //整数以外の型だったときはLong型にする
+ if(!IsWholeNumberType(type[sp-1])) type[sp-1]=DEF_LONG;
+ }
+
+ *pStackPointer=sp;
+ return 1;
+}
+
+BOOL Calc_MinusMark(int *type,int sp){
+ //value[sp-1]=-value[sp-1]
+ //符号反転
+
+ if(type[sp-1]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //push -1
+ compiler.codeGenerator.op_push_V(-1);
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+
+ //fmulp st(1),st
+ compiler.codeGenerator.PutOld(
+ (char)0xDE,
+ (char)0xC9
+ );
+
+ //fstp qword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
+ }
+ else if(type[sp-1]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //push -1
+ compiler.codeGenerator.op_push_V(-1);
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+
+ //fmulp st(1),st
+ compiler.codeGenerator.PutOld(
+ (char)0xDE,
+ (char)0xC9
+ );
+
+ //fstp dword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
+ }
+ else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //neg eax
+ compiler.codeGenerator.op_neg( REG_EAX );
+
+ //pop edx
+ compiler.codeGenerator.op_pop(REG_EDX);
+
+ //adc edx,0
+ compiler.codeGenerator.op_adc_RV8(REG_EDX,0);
+
+ //neg edx
+ compiler.codeGenerator.op_neg( REG_EDX );
+
+ //push edx
+ compiler.codeGenerator.op_push(REG_EDX);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+ type[sp-1]=DEF_INT64; //QWordはInt64へ
+ }
+ else if(IsWholeNumberType(type[sp-1])){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //imul eax,-1
+ compiler.codeGenerator.op_imul_RV8( REG_EAX, -1 );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+ type[sp-1]=GetSignedType(type[sp-1]);
+ }
+
+ return 1;
+}
+
+BOOL Calc_Power(int *type,int *pStackPointer){
+ //べき乗（実数演算のみ）
+
+ int sp;
+ sp=*pStackPointer;
+
+ if(type[sp-1]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else if(type[sp-1]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ //64ビット整数値
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else{
+ //32ビット整数値
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+
+ if(type[sp-2]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+ }
+ else if(type[sp-2]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+ }
+ else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
+ //64ビット整数値
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+ }
+ else{
+ //32ビット整数値
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+ }
+
+ //sub esp,8
+ compiler.codeGenerator.op_sub_esp(8);
+
+ //fstp qword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
+
+ //fstp qword ptr[esp+8]
+ compiler.codeGenerator.op_fstp_base_offset(DEF_DOUBLE,REG_ESP,8);
+
+ //call pow
+ extern const UserProc *pSub_pow;
+ compiler.codeGenerator.op_call(pSub_pow);
+
+ //sub esp,8
+ compiler.codeGenerator.op_sub_esp(8);
+
+ //fstp qword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
+
+ sp--;
+ type[sp-1]=DEF_DOUBLE;
+
+ *pStackPointer=sp;
+ return 1;
+}
+
+BOOL Calc_Cast(int *type,LONG_PTR *index_stack,int *pStackPointer){
+ //キャスト
+
+ int sp;
+ sp=*pStackPointer;
+
+ int castBasicType = type[sp-1];
+ if((castBasicType&FLAG_CAST)==0){
+ SetError(47,NULL,cp);
+ return 0;
+ }
+ castBasicType = castBasicType&(~FLAG_CAST);
+
+ Type oldType( type[sp-2], index_stack[sp-2] );
+ Type castType( castBasicType, index_stack[sp-1] );
+
+ if( castType.IsPointer() )
+ {
+ ChangeTypeToLong( oldType.GetBasicType() );
+ }
+ else if( castType.IsReal() )
+ {
+ if( castType.IsDouble() )
+ {
+ ChangeTypeToDouble( oldType.GetBasicType() );
+ }
+ else if( castType.IsSingle() )
+ {
+ ChangeTypeToSingle( oldType.GetBasicType() );
+ }
+ }
+ else
+ {
+ ChangeTypeToWhole( oldType, castType );
+ }
+
+ type[sp-2] = castType.GetBasicType();
+ index_stack[sp-2] = castType.GetIndex();
+
+ sp--;
+
+ *pStackPointer=sp;
+ return 1;
+}
+
+BOOL Calc_SHL(int *type,int *pStackPointer){
+ //左ビットシフト
+ //value[sp-2]=value[sp-2]<>value[sp-1]
+
+ int sp;
+ sp=*pStackPointer;
+
+ if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
+ ////////////////
+ // 64ビット演算
+ ////////////////
+
+ //2項目は32ビット整数として利用
+ if(type[sp-1]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+ }
+ else if(type[sp-1]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+ }
+ else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else{
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+ }
+
+ //第1項を64ビットに対応させる
+ if(type[sp-2]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //fistp qword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //pop edx
+ compiler.codeGenerator.op_pop(REG_EDX);
+ }
+ else if(type[sp-2]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ //fistp qword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //pop edx
+ compiler.codeGenerator.op_pop(REG_EDX);
+ }
+ else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //pop edx
+ compiler.codeGenerator.op_pop(REG_EDX);
+ }
+ else{
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ if(IsSignedType(type[sp-2])){
+ //符号拡張
+ //edx:eax ← eax
+
+ //cdq
+ compiler.codeGenerator.op_cdq();
+ }
+ else{
+ //ビット拡張
+ //edx:eax ← eax
+
+ //xor edx,edx
+ compiler.codeGenerator.op_zero_reg(REG_EDX);
+ }
+ }
+
+ if(type[sp-2]==DEF_QWORD){
+ //符号なし演算
+
+ //call _aullshr
+ extern const UserProc *pSub_aullshr;
+ compiler.codeGenerator.op_call(pSub_aullshr);
+ }
+ else{
+ //符号あり演算
+
+ //call _allshr
+ extern const UserProc *pSub_allshr;
+ compiler.codeGenerator.op_call(pSub_allshr);
+ }
+
+ //push edx
+ compiler.codeGenerator.op_push(REG_EDX);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+
+ sp--;
+ }
+ else{
+ ////////////////
+ // 32ビット演算
+ ////////////////
+
+ //2項目は32ビット整数として利用
+ if(type[sp-1]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+ }
+ else if(type[sp-1]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+ }
+ else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else{
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+ }
+
+ if(type[sp-2]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+ }
+ else if(type[sp-2]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+ }
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ if(type[sp-2]==DEF_DWORD){
+ //shr eax,cl
+ compiler.codeGenerator.PutOld(
+ (char)0xD3,
+ (char)0xE8
+ );
+ }
+ else{
+ //sar eax,cl
+ compiler.codeGenerator.PutOld(
+ (char)0xD3,
+ (char)0xF8
+ );
+ }
+
+ //mov dword ptr[esp],eax
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
+
+ sp--;
+
+ //整数以外の型だったときはLong型にする
+ if(!IsWholeNumberType(type[sp-1])) type[sp-1]=DEF_LONG;
+ }
+
+ *pStackPointer=sp;
+ return 1;
+}
Index: /trunk/ab5.0/abdev/BasicCompiler32/NumOpe_Logical.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/NumOpe_Logical.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/NumOpe_Logical.cpp (revision 440)
@@ -0,0 +1,506 @@
+#include "stdafx.h"
+
+#include
+
+#include "../BasicCompiler_Common/common.h"
+#include "Opcode.h"
+
+BOOL Calc_Xor(int *type,LONG_PTR *index_stack,int *pStackPointer){
+ //value[sp-2] xor= value[sp-1]
+ //xor演算
+
+ int sp;
+ sp=*pStackPointer;
+
+ if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){
+ //いずれかの項が実数のとき
+ SetError(45,"xor",cp);
+ return 0;
+ }
+
+ if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD||
+ type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ ////////////////////
+ // 64ビット整数演算
+ ////////////////////
+
+ //第2項を64ビットに対応させる
+ if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ //第2項が64ビット整数値のとき
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+ }
+ else{
+ //第2項がその他整数値のとき
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ if(IsSignedType(type[sp-1])){
+ //符号拡張
+ //edx:eax ← eax
+
+ //cdq
+ compiler.codeGenerator.op_cdq();
+ }
+ else{
+ //ビット拡張
+ //edx:eax ← eax
+
+ //xor edx,edx
+ compiler.codeGenerator.op_zero_reg(REG_EDX);
+ }
+
+ //mov ebx,eax
+ compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
+
+ //mov ecx,edx
+ compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
+ }
+
+ if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
+ //第1項が64ビット整数値のとき
+
+ //xor dword ptr[esp],ebx
+ compiler.codeGenerator.PutOld(
+ (char)0x31,
+ (char)0x1C,
+ (char)0x24
+ );
+
+ //xor dword ptr[esp+sizeof(long)],ecx
+ compiler.codeGenerator.PutOld(
+ (char)0x31,
+ (char)0x4C,
+ (char)0x24,
+ (char)0x04
+ );
+ }
+ else{
+ //第1項がその他整数値のとき
+ if(IsSignedType(type[sp-2])){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //符号拡張
+ //edx:eax ← eax
+
+ //cdq
+ compiler.codeGenerator.op_cdq();
+ }
+ else{
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //ビット拡張
+ //edx:eax ← eax
+
+ //xor edx,edx
+ compiler.codeGenerator.op_zero_reg(REG_EDX);
+ }
+
+ //xor ebx,eax
+ compiler.codeGenerator.op_xor_RR( REG_EBX, REG_EAX );
+
+ //xor ecx,edx
+ compiler.codeGenerator.op_xor_RR( REG_ECX, REG_EDX );
+
+ //push ecx
+ compiler.codeGenerator.op_push(REG_ECX);
+
+ //push ebx
+ compiler.codeGenerator.op_push(REG_EBX);
+ }
+
+ sp--;
+ if(type[sp-1]==DEF_QWORD&&type[sp]==DEF_QWORD) type[sp-1]=DEF_QWORD;
+ else type[sp-1]=DEF_INT64;
+ }
+ else{
+ ////////////////////
+ // 整数演算
+ ////////////////////
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ //xor eax,ebx
+ compiler.codeGenerator.op_xor_RR( REG_EAX, REG_EBX );
+
+ //mov dword ptr[esp],eax
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
+
+ sp--;
+ type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]);
+ }
+
+ *pStackPointer=sp;
+ return 1;
+}
+
+BOOL Calc_Or(int *type,LONG_PTR *index_stack,int *pStackPointer){
+ //value[sp-2] or= value[sp-1]
+ //or演算
+
+ int sp;
+ sp=*pStackPointer;
+
+ if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){
+ //いずれかの項が実数のとき
+ SetError(45,"or",cp);
+ return 0;
+ }
+
+ if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD||
+ type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ ////////////////////
+ // 64ビット整数演算
+ ////////////////////
+
+ //第2項を64ビットに対応させる
+ if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ //第2項が64ビット整数値のとき
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+ }
+ else{
+ //第2項が32ビット整数値のとき
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ if(IsSignedType(type[sp-1])){
+ //符号拡張
+ //edx:eax ← eax
+
+ //cdq
+ compiler.codeGenerator.op_cdq();
+ }
+ else{
+ //ビット拡張
+ //edx:eax ← eax
+
+ //xor edx,edx
+ compiler.codeGenerator.op_zero_reg(REG_EDX);
+ }
+
+ //mov ebx,eax
+ compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
+
+ //mov ecx,edx
+ compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
+ }
+
+ if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
+ //第1項が64ビット整数値のとき
+
+ //or dword ptr[esp],ebx
+ compiler.codeGenerator.PutOld(
+ (char)0x09,
+ (char)0x1C,
+ (char)0x24
+ );
+
+ //or dword ptr[esp+sizeof(long)],ecx
+ compiler.codeGenerator.PutOld(
+ (char)0x09,
+ (char)0x4C,
+ (char)0x24,
+ (char)0x04
+ );
+ }
+ else{
+ //第1項が32ビット整数値のとき
+ if(IsSignedType(type[sp-2])){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //符号拡張
+ //edx:eax ← eax
+
+ //cdq
+ compiler.codeGenerator.op_cdq();
+ }
+ else{
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //ビット拡張
+ //edx:eax ← eax
+
+ //xor edx,edx
+ compiler.codeGenerator.op_zero_reg(REG_EDX);
+ }
+
+ //or ebx,eax
+ compiler.codeGenerator.op_or_RR( sizeof(long), REG_EBX, REG_EAX );
+
+ //or ecx,edx
+ compiler.codeGenerator.op_or_RR( sizeof(long), REG_ECX, REG_EDX );
+
+ //push ecx
+ compiler.codeGenerator.op_push(REG_ECX);
+
+ //push ebx
+ compiler.codeGenerator.op_push(REG_EBX);
+ }
+
+ sp--;
+ if(type[sp-1]==DEF_QWORD&&type[sp]==DEF_QWORD) type[sp-1]=DEF_QWORD;
+ else type[sp-1]=DEF_INT64;
+ }
+ else{
+ ////////////////////
+ // 32ビット整数演算
+ ////////////////////
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ //or eax,ebx
+ compiler.codeGenerator.op_or_RR( sizeof(long), REG_EAX, REG_EBX );
+
+ //mov dword ptr[esp],eax
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
+
+ sp--;
+ type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]);
+ }
+
+ *pStackPointer=sp;
+ return 1;
+}
+
+BOOL Calc_And(int *type,LONG_PTR *index_stack,int *pStackPointer){
+ //value[sp-2] and= value[sp-1]
+ //and演算
+
+ int sp;
+ sp=*pStackPointer;
+
+ if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){
+ //いずれかの項が実数のとき
+ SetError(45,"and",cp);
+ return 0;
+ }
+
+ if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD||
+ type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ ////////////////////
+ // 64ビット整数演算
+ ////////////////////
+
+ //第2項を64ビットに対応させる
+ if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ //第2項が64ビット整数値のとき
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+ }
+ else{
+ //第2項が32ビット整数値のとき
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ if(IsSignedType(type[sp-1])){
+ //符号拡張
+ //edx:eax ← eax
+
+ //cdq
+ compiler.codeGenerator.op_cdq();
+ }
+ else{
+ //ビット拡張
+ //edx:eax ← eax
+
+ //xor edx,edx
+ compiler.codeGenerator.op_zero_reg(REG_EDX);
+ }
+
+ //mov ebx,eax
+ compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
+
+ //mov ecx,edx
+ compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
+ }
+
+ if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
+ //第1項が64ビット整数値のとき
+
+ //and dword ptr[esp],ebx
+ compiler.codeGenerator.PutOld(
+ (char)0x21,
+ (char)0x1C,
+ (char)0x24
+ );
+
+ //and dword ptr[esp+sizeof(long)],ecx
+ compiler.codeGenerator.PutOld(
+ (char)0x21,
+ (char)0x4C,
+ (char)0x24,
+ (char)0x04
+ );
+ }
+ else{
+ //第1項が32ビット整数値のとき
+ if(IsSignedType(type[sp-2])){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //符号拡張
+ //edx:eax ← eax
+
+ //cdq
+ compiler.codeGenerator.op_cdq();
+ }
+ else{
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //ビット拡張
+ //edx:eax ← eax
+
+ //xor edx,edx
+ compiler.codeGenerator.op_zero_reg(REG_EDX);
+ }
+
+ //and ebx,eax
+ compiler.codeGenerator.op_and_RR( REG_EBX, REG_EAX );
+
+ //and ecx,edx
+ compiler.codeGenerator.op_and_RR( REG_ECX, REG_EDX );
+
+ //push ecx
+ compiler.codeGenerator.op_push(REG_ECX);
+
+ //push ebx
+ compiler.codeGenerator.op_push(REG_EBX);
+ }
+
+ sp--;
+ if(type[sp-1]==DEF_QWORD&&type[sp]==DEF_QWORD) type[sp-1]=DEF_QWORD;
+ else type[sp-1]=DEF_INT64;
+ }
+ else{
+ ////////////////////
+ // 32ビット整数演算
+ ////////////////////
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ //and eax,ebx
+ compiler.codeGenerator.op_and_RR( REG_EAX, REG_EBX );
+
+ //mov dword ptr[esp],eax
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
+
+ sp--;
+ type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]);
+ }
+
+ *pStackPointer=sp;
+ return 1;
+}
+
+BOOL Calc_Not(int *type,int sp){
+ //value[sp-1]=Not value[sp-1]
+ //NOT演算子
+
+ if(IsRealNumberType(type[sp-1])){
+ //実数のとき
+ SetError(45,"Not",cp);
+ return 0;
+ }
+
+ if( type[sp - 1] == DEF_BOOLEAN ){
+ //pop eax
+ compiler.codeGenerator.op_pop( REG_EAX );
+
+ //cmp eax,0
+ compiler.codeGenerator.op_cmp_value(Type(type[sp-1]).GetSize(),REG_EAX,0);
+
+ //setne al
+ compiler.codeGenerator.op_setne( REG_EAX );
+
+ //and eax,000000FFh
+ compiler.codeGenerator.op_and_RV(REG_EAX,(int)0xFF);
+
+ //neg
+ compiler.codeGenerator.op_neg( REG_EAX );
+
+ //sbb eax, eax
+ compiler.codeGenerator.op_sbb_RR( REG_EAX, REG_EAX );
+
+ //add eax, 1
+ compiler.codeGenerator.op_add_RV8( REG_EAX, 1 );
+
+ //push eax
+ compiler.codeGenerator.op_push( REG_EAX );
+ }
+ else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ ////////////////////
+ // 64ビット整数演算
+ ////////////////////
+
+ //not dword ptr[esp]
+ compiler.codeGenerator.PutOld(
+ (char)0xF7,
+ (char)0x14,
+ (char)0x24
+ );
+
+ //not dword ptr[esp+4]
+ compiler.codeGenerator.PutOld(
+ (char)0xF7,
+ (char)0x54,
+ (char)0x24,
+ (char)0x04
+ );
+ }
+ else{
+ ////////////////////
+ // 32ビット整数演算
+ ////////////////////
+
+ //not dword ptr[esp]
+ compiler.codeGenerator.PutOld(
+ (char)0xF7,
+ (char)0x14,
+ (char)0x24
+ );
+ }
+
+ return 1;
+}
Index: /trunk/ab5.0/abdev/BasicCompiler32/NumOpe_Relation.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/NumOpe_Relation.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/NumOpe_Relation.cpp (revision 440)
@@ -0,0 +1,1208 @@
+#include "stdafx.h"
+
+#include
+
+#include "../BasicCompiler_Common/common.h"
+#include "Opcode.h"
+
+void AutoExtendToBigType( int *type_stack,int sp, int reg1, int reg2 ){
+ /*
+ int bigSize = GetTypeSize( type_stack[sp-1], -1 );
+ if( bigSize != GetTypeSize( type_stack[sp-2], -1 ) ){
+ int extReg = reg2;
+ int oldType = type_stack[sp-2];
+ if( bigSize < GetTypeSize( type_stack[sp-2], -1 ) ){
+ bigSize = GetTypeSize( type_stack[sp-2], -1 );
+ extReg = reg1;
+ oldType = type_stack[sp-1];
+ }
+ if( bigSize == 2 ){
+ ExtendTypeTo16( oldType, extReg );
+ }
+ else if( bigSize == 4 ){
+ ExtendTypeTo32( oldType, extReg );
+ }
+ else{
+ SetError();
+ }
+ }*/
+}
+
+
+BOOL Calc_Relation_PE(int *type_stack,LONG_PTR *index_stack,int *pStackPointer){
+ //value[sp-2]<=value[sp-1]
+
+ int sp;
+ sp=*pStackPointer;
+
+ int AnswerType;
+ AnswerType=NeutralizationType(type_stack[sp-2],index_stack[sp-2],type_stack[sp-1],index_stack[sp-1]);
+
+ if(IsRealNumberType(AnswerType)){
+ //////////////
+ // 実数演算
+ //////////////
+
+ if(type_stack[sp-1]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else if(type_stack[sp-1]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if(type_stack[sp-1]==DEF_INT64||type_stack[sp-1]==DEF_QWORD){
+ //64ビット整数値
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else{
+ //その他整数型
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+
+ if(type_stack[sp-2]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if(type_stack[sp-2]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+ }
+ else if(type_stack[sp-2]==DEF_INT64||type_stack[sp-2]==DEF_QWORD){
+ //64ビット整数値
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else{
+ //その他整数型
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+ }
+
+ //fcompp
+ compiler.codeGenerator.op_fcompp();
+
+ //fnstsw ax
+ compiler.codeGenerator.op_fnstsw_ax();
+
+ //mov ecx,1
+ compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
+
+ //test ah,41h
+ compiler.codeGenerator.op_test_ah( (char)0x41 );
+
+ //jne 5
+ compiler.codeGenerator.PutOld(
+ (char)0x75,
+ (char)0x02
+ );
+
+ //xor ecx,ecx（ecxを0にする）
+ compiler.codeGenerator.op_zero_reg(REG_ECX);
+
+ //mov dword ptr[esp],ecx
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
+ }
+ else if(Is64Type(AnswerType)){
+ ////////////////////
+ // 64ビット整数演算
+ ////////////////////
+
+ // 第1項 <= 第2項
+
+ //第1項 edx:eax
+ //第2項 ecx:ebx
+ GetStackData_ToRegister(type_stack,sp);
+
+ //cmp edx,ecx
+ compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
+
+ const PertialSchedule *pFalsePertialSchedule1;
+ if(IsSignedType(type_stack[sp-2])==0&&IsSignedType(type_stack[sp-1])==0){
+ //符号なし演算
+
+ //ja FalseSchedule1（偽へジャンプ）
+ pFalsePertialSchedule1 = compiler.codeGenerator.op_ja( 0, sizeof(char), true );
+ }
+ else{
+ //符号あり演算
+
+ //jg FalseSchedule1（偽へジャンプ）
+ pFalsePertialSchedule1 = compiler.codeGenerator.op_jg( 0, sizeof(char), true );
+ }
+
+ const PertialSchedule *pTruePertialSchedule;
+ if(IsSignedType(type_stack[sp-2])==0&&IsSignedType(type_stack[sp-1])==0){
+ //符号なし演算
+
+ //jb TrueSchedule（真へジャンプ）
+ pTruePertialSchedule = compiler.codeGenerator.op_jb( 0, sizeof(char), true );
+ }
+ else{
+ //符号あり演算
+
+ //jl TrueSchedule（真へジャンプ）
+ pTruePertialSchedule = compiler.codeGenerator.op_jl( 0, sizeof(char), true );
+ }
+
+ //cmp eax,ebx
+ compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
+
+ //ja FalseSchedule2（偽へジャンプ）
+ const PertialSchedule *pFalsePertialSchedule2 = compiler.codeGenerator.op_ja( 0, sizeof(char), true );
+
+ //TrueScheduleのジャンプ先の設定
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule );
+
+ //mov eax,1
+ compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
+
+ //jmp 2（演算終了位置へジャンプ）
+ compiler.codeGenerator.op_jmp( 2 );
+
+ //FalseScheduleのジャンプ先の設定
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule1 );
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule2 );
+
+ //xor eax,eax（eaxを0にする）
+ compiler.codeGenerator.op_zero_reg(REG_EAX);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else{
+ ////////////////////
+ // 32ビット整数演算
+ ////////////////////
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ // どちらかのサイズが足りない場合は自動拡張する
+ AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ //mov ecx,1
+ compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
+
+ //cmp eax,ebx
+ compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
+
+ if(IsSignedType(type_stack[sp-2])==0&&IsSignedType(type_stack[sp-1])==0){
+ //符号なし演算
+
+ //jbe 2（次のxorを飛び越す）
+ compiler.codeGenerator.op_jbe( 2 );
+ }
+ else{
+ //符号あり演算
+
+ //jle 2（次のxorを飛び越す）
+ compiler.codeGenerator.op_jle( 2 );
+ }
+
+ //xor ecx,ecx
+ compiler.codeGenerator.op_xor_RR( REG_ECX );
+
+ //mov dword ptr[esp],ecx
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
+ }
+
+ sp--;
+ type_stack[sp-1]=DEF_BOOLEAN;
+
+ *pStackPointer=sp;
+ return 1;
+}
+
+BOOL Calc_Relation_QE(int *type_stack,LONG_PTR *index_stack,int *pStackPointer){
+ //value[sp-2]>=value[sp-1]
+
+ int sp;
+ sp=*pStackPointer;
+
+ int AnswerType;
+ AnswerType=NeutralizationType(type_stack[sp-2],index_stack[sp-2],type_stack[sp-1],index_stack[sp-1]);
+
+ if(IsRealNumberType(AnswerType)){
+ //浮動小数点演算
+ if(type_stack[sp-1]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else if(type_stack[sp-1]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if(type_stack[sp-1]==DEF_INT64||type_stack[sp-1]==DEF_QWORD){
+ //64ビット整数値
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else{
+ //その他整数型
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+
+ if(type_stack[sp-2]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if(type_stack[sp-2]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+ }
+ else if(type_stack[sp-2]==DEF_INT64||type_stack[sp-2]==DEF_QWORD){
+ //64ビット整数値
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else{
+ //その他整数型
+
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+ }
+
+ //fcompp
+ compiler.codeGenerator.op_fcompp();
+
+ //fnstsw ax
+ compiler.codeGenerator.op_fnstsw_ax();
+
+ //mov ecx,1
+ compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
+
+ //test ah,1
+ compiler.codeGenerator.op_test_ah( (char)0x01 );
+
+ //je 2（次のxorを飛び越す）
+ compiler.codeGenerator.op_je( 2 );
+
+ //xor ecx,ecx
+ compiler.codeGenerator.op_xor_RR( REG_ECX );
+
+ //mov dword ptr[esp],ecx
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
+ }
+ else if(Is64Type(AnswerType)){
+ ////////////////////
+ // 64ビット整数演算
+ ////////////////////
+
+ // 第1項 >= 第2項
+
+ //第1項 edx:eax
+ //第2項 ecx:ebx
+ GetStackData_ToRegister(type_stack,sp);
+
+ //cmp edx,ecx
+ compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
+
+ const PertialSchedule *pFalsePertialSchedule1;
+ if(IsSignedType(AnswerType)){
+ //符号あり演算
+
+ //jl FalseSchedule1（偽へジャンプ）
+ pFalsePertialSchedule1 = compiler.codeGenerator.op_jl( 0, sizeof(char), true );
+ }
+ else{
+ //符号なし演算
+
+ //jb FalseSchedule1（偽へジャンプ）
+ pFalsePertialSchedule1 = compiler.codeGenerator.op_jb( 0, sizeof(char), true );
+ }
+
+ const PertialSchedule *pTruePertialSchedule;
+ if(IsSignedType(AnswerType)){
+ //符号あり演算
+
+ //jg TrueSchedule（真へジャンプ）
+ pTruePertialSchedule = compiler.codeGenerator.op_jg( 0, sizeof(char), true );
+ }
+ else{
+ //符号なし演算
+
+ //ja TrueSchedule（真へジャンプ）
+ pTruePertialSchedule = compiler.codeGenerator.op_ja( 0, sizeof(char), true );
+ }
+
+ //cmp eax,ebx
+ compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
+
+ //jb FalseSchedule2（偽へジャンプ）
+ const PertialSchedule *pFalsePertialSchedule2 = compiler.codeGenerator.op_jb( 0, sizeof(char), true );
+
+ //TrueScheduleのジャンプ先の設定
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule );
+
+ //mov eax,1
+ compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
+
+ //jmp 2（演算終了位置へジャンプ）
+ compiler.codeGenerator.op_jmp( 2 );
+
+ //FalseScheduleのジャンプ先の設定
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule1 );
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule2 );
+
+ //xor eax,eax（eaxを0にする）
+ compiler.codeGenerator.op_zero_reg(REG_EAX);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else{
+ ////////////////////
+ // 32ビット整数演算
+ ////////////////////
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ // どちらかのサイズが足りない場合は自動拡張する
+ AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ //mov ecx,1
+ compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
+
+ //cmp eax,ebx
+ compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
+
+ if(IsSignedType(AnswerType)){
+ //符号あり演算
+
+ //jge 2（次のxorを飛び越す）符号有り
+ compiler.codeGenerator.op_jge( 2 );
+ }
+ else{
+ //符号なし演算
+
+ //jae 2（次のxorを飛び越す）
+ compiler.codeGenerator.op_jae( 2 );
+ }
+
+ //xor ecx,ecx
+ compiler.codeGenerator.op_xor_RR( REG_ECX );
+
+ //mov dword ptr[esp],ecx
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
+ }
+
+ sp--;
+ type_stack[sp-1]=DEF_BOOLEAN;
+
+ *pStackPointer=sp;
+ return 1;
+}
+
+BOOL Calc_Relation_P(int *type_stack,LONG_PTR *index_stack,int *pStackPointer){
+ //value[sp-2]value[sp-1]
+
+ int sp;
+ sp=*pStackPointer;
+
+ int AnswerType;
+ AnswerType=NeutralizationType(type_stack[sp-2],index_stack[sp-2],type_stack[sp-1],index_stack[sp-1]);
+
+ if(IsRealNumberType(AnswerType)){
+ //////////////
+ // 実数演算
+ //////////////
+
+ if(type_stack[sp-1]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else if(type_stack[sp-1]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if(type_stack[sp-1]==DEF_INT64||type_stack[sp-1]==DEF_QWORD){
+ //64ビット整数値
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else{ //Long、DWord
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+
+ if(type_stack[sp-2]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if(type_stack[sp-2]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+ }
+ else if(type_stack[sp-2]==DEF_INT64||type_stack[sp-2]==DEF_QWORD){
+ //64ビット整数値
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else{ //Long、DWord
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+ }
+
+ //fcompp
+ compiler.codeGenerator.op_fcompp();
+
+ //fnstsw ax
+ compiler.codeGenerator.op_fnstsw_ax();
+
+ //mov ecx,1
+ compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
+
+ //test ah,41
+ compiler.codeGenerator.op_test_ah( (char)0x41 );
+
+ //je 2（次のxorを飛び越す）
+ compiler.codeGenerator.op_je( 2 );
+
+ //xor ecx,ecx
+ compiler.codeGenerator.op_xor_RR( REG_ECX );
+
+ //mov dword ptr[esp],ecx
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
+ }
+ else if(Is64Type(AnswerType)){
+ ////////////////////
+ // 64ビット整数演算
+ ////////////////////
+
+ // 第1項 > 第2項
+
+ //第1項 edx:eax
+ //第2項 ecx:ebx
+ GetStackData_ToRegister(type_stack,sp);
+
+ //cmp edx,ecx
+ compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
+
+ const PertialSchedule *pTruePertialSchedule1;
+ if(IsSignedType(AnswerType)){
+ //符号有り
+
+ //jg TrueSchedule1（真へジャンプ）
+ pTruePertialSchedule1 = compiler.codeGenerator.op_jg( 0, sizeof(char), true );
+ }
+ else{
+ //符号無し
+
+ //ja TrueSchedule1（真へジャンプ）
+ pTruePertialSchedule1 = compiler.codeGenerator.op_ja( 0, sizeof(char), true );
+ }
+
+ const PertialSchedule *pFalsePertialSchedule;
+ if(IsSignedType(AnswerType)){
+ //符号有り
+
+ //jl FalseSchedule（偽へジャンプ）
+ pFalsePertialSchedule = compiler.codeGenerator.op_jl( 0, sizeof(char), true );
+ }
+ else{
+ //符号無し
+
+ //jb FalseSchedule（偽へジャンプ）
+ pFalsePertialSchedule = compiler.codeGenerator.op_jb( 0, sizeof(char), true );
+ }
+
+ //cmp eax,ebx
+ compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
+
+ //ja TrueSchedule2（真へジャンプ）
+ const PertialSchedule *pTruePertialSchedule2 = compiler.codeGenerator.op_ja( 0, sizeof(char), true );
+
+ //FalseScheduleのジャンプ先の設定
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule );
+
+ //xor eax,eax（eaxを0にする）
+ compiler.codeGenerator.op_zero_reg(REG_EAX);
+
+ //jmp 5（演算終了位置へジャンプ）
+ compiler.codeGenerator.op_jmp( 5 );
+
+ //TrueScheduleのジャンプ先の設定
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule1 );
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule2 );
+
+ //mov eax,1
+ compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else{
+ ////////////////////
+ // 32ビット整数演算
+ ////////////////////
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ // どちらかのサイズが足りない場合は自動拡張する
+ AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ //mov ecx,1
+ compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
+
+ //cmp eax,ebx
+ compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
+
+ if(IsSignedType(AnswerType)){
+ //jg 2（次のxorを飛び越す）
+ compiler.codeGenerator.op_jg( 2 );
+ }
+ else{
+ //ja 2（次のxorを飛び越す）
+ compiler.codeGenerator.op_ja( 2 );
+ }
+
+ //xor ecx,ecx
+ compiler.codeGenerator.op_xor_RR( REG_ECX );
+
+ //mov dword ptr[esp],ecx
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
+ }
+
+ sp--;
+ type_stack[sp-1]=DEF_BOOLEAN;
+
+ *pStackPointer=sp;
+ return 1;
+}
+
+BOOL Calc_Relation_NotEqual(int *type,int *pStackPointer){
+ //value[sp-2]<>value[sp-1]
+
+ int sp;
+ sp=*pStackPointer;
+
+ if(type[sp-2]==DEF_DOUBLE||type[sp-2]==DEF_SINGLE||
+ type[sp-1]==DEF_DOUBLE||type[sp-1]==DEF_SINGLE){
+ //////////////
+ // 実数演算
+ //////////////
+
+ if(type[sp-1]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else if(type[sp-1]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ //64ビット整数値
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else{ //Long、DWord
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+
+ if(type[sp-2]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if(type[sp-2]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+ }
+ else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
+ //64ビット整数値
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else{ //Long、DWord
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+ }
+
+ //fcompp
+ compiler.codeGenerator.op_fcompp();
+
+ //fnstsw ax
+ compiler.codeGenerator.op_fnstsw_ax();
+
+ //mov ecx,1
+ compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
+
+ //test ah,40
+ compiler.codeGenerator.op_test_ah( (char)0x40 );
+
+ //je 2
+ compiler.codeGenerator.op_je( 2 );
+
+ //xor ecx,ecx
+ compiler.codeGenerator.op_xor_RR( REG_ECX );
+
+ //mov dword ptr[esp],ecx
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
+ }
+ else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD||
+ type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ ////////////////////
+ // 64ビット整数演算
+ ////////////////////
+
+ // 第1項 <> 第2項
+
+ //第1項 edx:eax
+ //第2項 ecx:ebx
+ GetStackData_ToRegister(type,sp);
+
+ //cmp eax,ebx
+ compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
+
+ //jne TrueSchedule1（真へジャンプ）
+ const PertialSchedule *pTruePertialSchedule1 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
+
+ //cmp edx,ecx
+ compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
+
+ //jne TrueSchedule2（真へジャンプ）
+ const PertialSchedule *pTruePertialSchedule2 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
+
+ //xor eax,eax（eaxを0にする）
+ compiler.codeGenerator.op_zero_reg(REG_EAX);
+
+ //jmp 5（演算終了位置へジャンプ）
+ compiler.codeGenerator.op_jmp( 5 );
+
+ //TrueScheduleのジャンプ先の設定
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule1 );
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule2 );
+
+ //mov eax,1
+ compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else{
+ ////////////////////
+ // 32ビット整数演算
+ ////////////////////
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ // どちらかのサイズが足りない場合は自動拡張する
+ AutoExtendToBigType( type, sp, REG_EAX, REG_EBX );
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ //xor eax,ebx
+ compiler.codeGenerator.op_xor_RR( REG_EAX, REG_EBX );
+
+ //je 5（次のmovを飛び越す）
+ compiler.codeGenerator.op_je( 5 );
+
+ //mov eax,1
+ compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
+
+ //mov dword ptr[esp],eax
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
+ }
+
+ sp--;
+ type[sp-1]=DEF_BOOLEAN;
+
+ *pStackPointer=sp;
+ return 1;
+}
+
+BOOL Calc_Relation_Equal(int *type,int *pStackPointer){
+ //value[sp-2]=value[sp-1]
+
+ int sp;
+ sp=*pStackPointer;
+
+ if(type[sp-2]==DEF_DOUBLE||type[sp-2]==DEF_SINGLE||
+ type[sp-1]==DEF_DOUBLE||type[sp-1]==DEF_SINGLE){
+ //////////////
+ // 実数演算
+ //////////////
+
+ if(type[sp-1]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else if(type[sp-1]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ //64ビット整数値
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else{ //Long、DWord
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+
+ if(type[sp-2]==DEF_DOUBLE){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if(type[sp-2]==DEF_SINGLE){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+ }
+ else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
+ //64ビット整数値
+
+ //fild qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else{ //Long、DWord
+ //fild dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+ }
+
+ //fcompp
+ compiler.codeGenerator.op_fcompp();
+
+ //fnstsw ax
+ compiler.codeGenerator.op_fnstsw_ax();
+
+ //mov ecx,1
+ compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
+
+ //test ah,40
+ compiler.codeGenerator.op_test_ah( (char)0x40 );
+
+ //jne 2（次のxorを飛び越す）
+ compiler.codeGenerator.op_jne( 2 );
+
+ //xor ecx,ecx
+ compiler.codeGenerator.op_xor_RR( REG_ECX );
+
+ //mov dword ptr[esp],ecx
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
+ }
+ else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD||
+ type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
+ ////////////////////
+ // 64ビット整数演算
+ ////////////////////
+
+ // 第1項 == 第2項
+
+ //第1項 edx:eax
+ //第2項 ecx:ebx
+ GetStackData_ToRegister(type,sp);
+
+ //cmp eax,ebx
+ compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
+
+ //jne FalseSchedule1（偽へジャンプ）
+ const PertialSchedule *pFalsePertialSchedule1 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
+
+ //cmp edx,ecx
+ compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
+
+ //jne FalseSchedule2（偽へジャンプ）
+ const PertialSchedule *pFalsePertialSchedule2 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
+
+ //mov eax,1
+ compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
+
+ //jmp 2（演算終了位置へジャンプ）
+ compiler.codeGenerator.op_jmp( 2 );
+
+ //FalseScheduleのジャンプ先の設定
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule1 );
+ compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule2 );
+
+ //xor eax,eax（eaxを0にする）
+ compiler.codeGenerator.op_zero_reg(REG_EAX);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else{
+ ////////////////////
+ // 32ビット整数演算
+ ////////////////////
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //pop ebx
+ compiler.codeGenerator.op_pop(REG_EBX);
+
+ // どちらかのサイズが足りない場合は自動拡張する
+ AutoExtendToBigType( type, sp, REG_EAX, REG_EBX );
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ //xor eax,ebx
+ compiler.codeGenerator.op_xor_RR( REG_EAX, REG_EBX );
+
+ //je 4（次のxorとjmpを飛び越す）
+ compiler.codeGenerator.op_je( 4 );
+
+ //xor eax,eax
+ compiler.codeGenerator.op_xor_RR( REG_EAX );
+
+ //jmp 5
+ compiler.codeGenerator.op_jmp( 5 );
+
+ //mov eax,1
+ compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
+
+ //mov dword ptr[esp],eax
+ compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
+ }
+
+ sp--;
+ type[sp-1]=DEF_BOOLEAN;
+
+ *pStackPointer=sp;
+ return 1;
+}
Index: /trunk/ab5.0/abdev/BasicCompiler32/NumOpe_TypeOperation.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/NumOpe_TypeOperation.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/NumOpe_TypeOperation.cpp (revision 440)
@@ -0,0 +1,215 @@
+#include "stdafx.h"
+
+#include
+
+#include
+
+#include "../BasicCompiler_Common/common.h"
+#include "Opcode.h"
+
+void ExtendStackTo32( const Type &oldType );
+
+void ExtendStackTo64( const Type &oldType )
+{
+ if( oldType.Is64() )
+ {
+ return;
+ }
+
+ //32ビットに拡張
+ ExtendStackTo32( oldType );
+
+ //64ビットに拡張
+ if( oldType.IsSigned() )
+ {
+ //符号あり
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //cdq
+ compiler.codeGenerator.op_cdq();
+
+ //push edx
+ compiler.codeGenerator.op_push(REG_EDX);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else{
+ //符号なし
+
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //push 0
+ compiler.codeGenerator.op_push_V(0);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+}
+void ExtendStackTo32( const Type &oldType )
+{
+ if( oldType.GetSize() == sizeof(long) )
+ {
+ return;
+ }
+
+ if( oldType.Is64() )
+ {
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //pop edx
+ compiler.codeGenerator.op_pop(REG_EDX);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else if( oldType.IsInteger() )
+ {
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //movsx eax,ax
+ compiler.codeGenerator.op_movsx_R32R16( REG_EAX );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else if( oldType.IsWord() )
+ {
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //and eax,0000FFFFh
+ compiler.codeGenerator.op_and_RV( REG_EAX, 0x0000FFFF );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else if( oldType.IsSByte() )
+ {
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //movsx eax,al
+ compiler.codeGenerator.op_movsx_R32R8( REG_EAX );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else if( oldType.IsByte() || oldType.IsBoolean() )
+ {
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //and eax,000000FFh
+ compiler.codeGenerator.op_and_RV( REG_EAX, 0x000000FF );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+}
+void ExtendStackTo16( const Type &oldType ){
+ if( oldType.IsSByte() )
+ {
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //movsx eax,al
+ compiler.codeGenerator.op_movsx_R32R8( REG_EAX );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else if( oldType.IsByte() )
+ {
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //and eax,000000FFh
+ compiler.codeGenerator.op_and_RV( REG_EAX, 0x000000FF );
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+}
+void ExtendStackTo8( const Type &oldType )
+{
+ if( oldType.Is64() )
+ {
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //pop edx
+ compiler.codeGenerator.op_pop(REG_EDX);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+}
+
+
+void ChangeTypeToWhole( const Type &oldType, const Type &newType ){
+ if( oldType.IsDouble() )
+ {
+ if( newType.Is64() )
+ {
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //fistp qword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
+ }
+ else{
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+ }
+ }
+ else if( oldType.IsSingle() )
+ {
+ if( newType.Is64() )
+ {
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ //fistp qword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
+ }
+ else{
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+ //fistp dword ptr[esp]
+ compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+ }
+ }
+ else{
+ //整数から整数へ変換
+
+ if( newType.Is64() )
+ {
+ ExtendStackTo64( oldType );
+ }
+ else if( newType.GetSize()==sizeof(long)){
+ ExtendStackTo32( oldType );
+ }
+ else if( newType.GetSize()==sizeof(short)){
+ ExtendStackTo16( oldType );
+ }
+ else if( newType.GetSize()==sizeof(char)){
+ ExtendStackTo8( oldType );
+ }
+ }
+}
Index: /trunk/ab5.0/abdev/BasicCompiler32/Opcode.h
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/Opcode.h (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/Opcode.h (revision 440)
@@ -0,0 +1,249 @@
+#pragma once
+
+#include
+#include
+#include "MachineFixed.h"
+
+
+//変数の種類
+#define NON_VAR 0
+#define VAR_GLOBAL 1 // Global Variable
+#define VAR_REFGLOBAL 2 // Global Refference Variable
+#define VAR_LOCAL 3 // Local Variable
+#define VAR_REFLOCAL 4 // Local Refference Variable
+#define VAR_DIRECTMEM 5 // Direct memory
+
+
+extern int cp;
+
+#define breakpoint compiler.codeGenerator.PutOld( (char)0xCC );
+
+
+//プロシージャ
+struct PROCEDURE{
+ char name[255];
+ int address;
+ int types[MAX_PARMS];
+ _int8 ByVal[MAX_PARMS];
+ BOOL ReturnType;
+};
+
+//With情報
+struct WITHINFO{
+ char **ppName;
+ int *pWithCp;
+ int num;
+};
+
+
+//RSrcSection.cpp
+char *GetRSrcSectionBuffer(int *pLen);
+
+//Compile.cpp
+void Compile( const char *source );
+void ChangeOpcode(char *Command);
+void GetGlobalDataForDll(void);
+DWORD CompileBuffer(char Return_Sequence,WORD Return_Command);
+
+//Compile_Calc.cpp
+void ChangeTypeToDouble_ToFpuReg(int OldType);
+void ChangeTypeToDouble(int OldType);
+void ChangeTypeToSingle(int OldType);
+void ChangeTypeToInt64(int OldType);
+void ChangeTypeToLong(int OldType);
+void ChangeTypeToInteger(int OldType);
+void ChangeTypeToByte(int OldType);
+void SetVariableFromEax( const Type &varType, int CalcType,RELATIVE_VAR *pRelativeVar);
+void OpcodeCalc( const char *Command );
+
+//NumOpe.cpp
+void PushReturnValue(int type);
+bool TermOpeOnlyVariable( const char *term, Type &resultType, RELATIVE_VAR &relativeVar, bool isWriteAccess );
+bool TermOpe(
+ const char *term,
+ const Type &baseType,
+ Type &resultType,
+ bool &isLiteral,
+ bool &isNeedHeapFreeStructure,
+ bool *pIsClassName = NULL,
+ bool isProcedureCallOnly = false,
+ bool isWriteAccess = false );
+bool NumOpe( int reg,
+ const char *expression,
+ const Type &baseType,
+ Type &resultType,
+ bool *pbIsNeedHeapFreeStructure = NULL );
+bool NumOpe( const char *Command,
+ const Type &baseType,
+ Type &resultType,
+ bool *pbIsNeedHeapFreeStructure = NULL );
+
+//NumOpe_Arithmetic.cpp
+void GetStackData_ToRegister(int *type,int sp);
+BOOL CalcTwoTerm_Arithmetic(int idCalc,int *type,LONG_PTR *index_stack,int *pStackPointer);
+BOOL Calc_Mod(int *type,int *pStackPointer);
+BOOL Calc_Divide(int *type,int *pStackPointer,int BaseType);
+BOOL Calc_IntDivide(int *type,LONG_PTR *index_stack,int *pStackPointer);
+BOOL Calc_MinusMark(int *type,int sp);
+BOOL Calc_Power(int *type,int *pStackPointer);
+BOOL Calc_Cast(int *type,LONG_PTR *index_stack,int *pStackPointer);
+BOOL Calc_SHL(int *type,int *pStackPointer);
+BOOL Calc_SHR(int *type,int *pStackPointer);
+
+//NumOpe_Logical.cpp
+BOOL Calc_Xor(int *type,LONG_PTR *index_stack,int *pStackPointer);
+BOOL Calc_Or(int *type,LONG_PTR *index_stack,int *pStackPointer);
+BOOL Calc_And(int *type,LONG_PTR *index_stack,int *pStackPointer);
+BOOL Calc_Not(int *type,int sp);
+
+//NumOpe_Relation.cpp
+BOOL Calc_Relation_PE(int *type_stack,LONG_PTR *index_stack,int *pStackPointer);
+BOOL Calc_Relation_QE(int *type_stack,LONG_PTR *index_stack,int *pStackPointer);
+BOOL Calc_Relation_P(int *type_stack,LONG_PTR *index_stack,int *pStackPointer);
+BOOL Calc_Relation_Q(int *type_stack,LONG_PTR *index_stack,int *pStackPointer);
+BOOL Calc_Relation_NotEqual(int *type,int *pStackPointer);
+BOOL Calc_Relation_Equal(int *type,int *pStackPointer);
+
+//NumOpe_TypeOperation.cpp
+void ExtendStackTo64( const Type &oldType );
+void ChangeTypeToWhole( const Type &oldType, const Type &newType );
+
+//Compile_Set_Var.cpp
+BOOL IsUse_ecx(RELATIVE_VAR *pRelativeVar);
+void SetStructVariable( const Type &varType, const Type &calcType, BOOL bUseHeap);
+void SetRealVariable(int VarType, int CalcType, RELATIVE_VAR *pRelativeVar);
+void SetWholeVariable( int varSize,int calcType, RELATIVE_VAR *pRelative );
+
+void SetDoubleVariable(int type,DWORD VarKind,DWORD offset,BOOL bOffsetOffset);
+void SetSingleVariable(int type,DWORD VarKind,DWORD offset,BOOL bOffsetOffset);
+void SetInt64Variable(int type,RELATIVE_VAR *pRelative);
+void SetDWordVariable(int type,DWORD VarKind,DWORD offset,BOOL bOffsetOffset);
+void SetLongVariable(int type,DWORD VarKind,DWORD offset,BOOL bOffsetOffset);
+void Set16Variable(int type,DWORD VarKind,DWORD offset,BOOL bOffsetOffset);
+void Set8Variable(int type,DWORD VarKind,DWORD offset,BOOL bOffsetOffset);
+void SetBooleanVariable(int type,RELATIVE_VAR *pRelative);
+void ExtendTypeTo64(int type);
+void ExtendTypeTo32(int type,int reg);
+void ExtendTypeTo16(int type,int reg);
+
+//increment.cpp
+void IncDec(int idCalc, const char *lpszLeft, const char *lpszRight);
+
+//calc2.cpp
+#define EXP_TYPE_NUMBER 1
+#define EXP_TYPE_EAX 2
+#define EXP_TYPE_FPU 3
+#define EXP_TYPE_VAR 4
+int NumOpEx(char *Command,double *pDbl,DWORD *pdwType,RELATIVE_VAR *pRelativeVar);
+
+//SetVar.cpp
+BOOL SetVariable(DWORD dwVarType,RELATIVE_VAR *pVarRelativeVar,
+ DWORD dwExpType,DWORD dwType,void *data);
+
+//Compile_Calc_PushVar.cpp
+void SetReg_RealVariable(int type,RELATIVE_VAR *pRelativeVar);
+void SetReg_WholeVariable( const Type &type, RELATIVE_VAR *pRelativeVar,int reg, bool is64Head = false);
+void PushLongVariable(RELATIVE_VAR *pRelativeVar);
+
+//Compile_Object.cpp
+void Operator_New( const CClass &classObj, const char *objectSizeStr, const char *parameter, const Type &baseType );
+void OpcodeDelete(const char *Parameter, bool isSweeping);
+
+//Compile_Var.cpp
+void SetRelativeOffset( RELATIVE_VAR &relativeVar );
+bool _member_offset(bool isErrorEnabled, bool isWriteAccess, const Type &classType, const char *member, RELATIVE_VAR *pRelativeVar, Type &resultType, BOOL bPrivateAccess);
+void SetThisPtrToReg(int reg);
+bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType, Subscripts *pResultSubscripts = NULL );
+bool SetInitGlobalData(int offset,const Type &type,const Subscripts &subscripts,const char *InitBuf);
+#define DIMFLAG_INITDEBUGVAR 1
+#define DIMFLAG_NONCALL_CONSTRACTOR 2
+#define DIMFLAG_STATIC 4
+#define DIMFLAG_CONST 8
+void dim( char *VarName, const Subscripts &subscripts, const Type &type, const char *InitBuf,const char *ConstractParameter,DWORD dwFlags);
+void SetVarPtrToEax(RELATIVE_VAR *pRelativeVar);
+void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar);
+bool Compile_AddGlobalRootsForGc();
+
+//ParamImpl.cpp
+class ParamImpl{
+ char *Parms[255];
+ Types types;
+ int ParmsNum;
+
+ Type leftType;
+ Type returnType;
+
+ //一時オブジェクト管理用
+ bool useTempObject;
+ bool useTempParameters[255];
+ bool isNeedFreeStructures[255];
+ int nCountOfTempObjects;
+
+public:
+ ParamImpl(const char *buffer);
+ ParamImpl(const Parameters ¶ms);
+ ~ParamImpl();
+ void SetLeftType( const Type &type )
+ {
+ this->leftType = type;
+ }
+ void SetReturnType( const Type &returnType );
+
+private:
+ bool EvaluateOverloadScore( int level, const Parameters &targetParms, const Type &targetResultType, const Type &leftType, const UserProc &userProc, bool &isErrored );
+public:
+ const UserProc *_OverloadSolution( const char *name, std::vector &subs, const Type &leftType, bool isEnabledReturnType );
+ const UserProc *OverloadSolution( const char *name, std::vector &subs, const Type &leftType, bool isEnabledReturnType = false );
+
+ void ApplyDefaultParameters( const Parameters ¶ms );
+ bool ErrorCheck( const string &procName, const Parameters ¶ms, int SecondParmNum = -1 );
+ void MacroParameterSupport( const Parameters ¶ms );
+ void SetStructParameter( const Type &baseType, const char *expression );
+ int SetParameter( const string &procName, const Parameters ¶ms, int SecondParmNum = -1, const UserProc *pUserProc = NULL );
+
+ //一時オブジェクトパラメータの生成と破棄
+ int NewTempParameters( const string &procName, const Parameters ¶ms, int SecondParmNum = -1 );
+ void DeleteTempParameters();
+};
+
+//Compile_CallProc.cpp
+#define PROCFLAG_NEW 1
+bool Opcode_CallProcPtr( const char *variable, const char *lpszParms,ProcPointer *pProcPointer);
+bool Opcode_CallProc(const char *Parameter,const UserProc *pUserProc,DWORD dwFlags,const char *ObjectName );
+bool Opcode_CallDllProc( const char *lpszParms, const DllProc *pDllProc );
+void Opcode_CallDelegate( const Delegate &dg, const char *methodPtrValueStr, const char *objPtrValueStr, const char *params );
+
+//Compile_ProcOp.cpp
+void _compile_proc(const UserProc *pUserProc);
+
+//Compile_Func.cpp
+int GetFunctionFromName(char *FuncName);
+bool Opcode_CallFunc( const char *Parameter, const int FuncNum, const Type &baseType, Type &resultType, bool isCallOn = true );
+
+//OperatorProc.cpp
+void FreeTempObject(int reg,const CClass *pobj_c);
+int CallOperatorProc(int idCalc, const Type &baseType, int *type_stack, LONG_PTR *index_stack,bool isNeedHeapFreeStructureStack[],int &sp);
+void CallCastOperatorProc(Type &calcType,BOOL bCalcUseHeap,const Type &toType);
+void CallIndexerGetterProc( const Type &classType, const char *ObjectName, char *Parameter,Type &resultType, DWORD dwProcFlags = 0 );
+
+//Compile_Statement.cpp
+void OpcodeOthers( const char *Command );
+void OpcodeIf(char *Parameter);
+void OpcodeGoto(char *Parameter);
+void OpcodeWhile(char *Parameter);
+void OpcodeFor(char *Parameter);
+void OpcodeForeach( const char *Parameter );
+void OpcodeDo(char *Parameter);
+void OpcodeContinue(void);
+void OpcodeExitSub(void);
+void OpcodeSelect(const char *lpszParms);
+void OpcodeCase(char *Parameter);
+void OpcodeGosub(char *Parameter);
+void OpcodeReturn(char *Parameter);
+void OpcodeSetPtrData(char *Parameter,int type);
+
+
+
+
+//op32_main.cpp
+BOOL IsSafeReg(int reg);
Index: /trunk/ab5.0/abdev/BasicCompiler32/OperatorProc.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/OperatorProc.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/OperatorProc.cpp (revision 440)
@@ -0,0 +1,273 @@
+#include "stdafx.h"
+
+#include
+
+#include "../BasicCompiler_Common/common.h"
+#include "Opcode.h"
+
+void FreeTempObject(int reg,const CClass *pobj_c){
+ if(!IsSafeReg(reg)) SetError(300,NULL,cp);
+
+ const CMethod *method = pobj_c->GetDestructorMethod();
+ if( method ){
+ //push reg
+ compiler.codeGenerator.op_push(reg);
+
+ //call DestructorProcAddr
+ compiler.codeGenerator.op_call( &method->GetUserProc() );
+ }
+
+ //push reg
+ compiler.codeGenerator.op_push(reg);
+
+ //call free
+ extern const UserProc *pSub_free;
+ compiler.codeGenerator.op_call(pSub_free);
+}
+
+int CallOperatorProc(int idCalc, const Type &baseType, int *type_stack, LONG_PTR *index_stack,bool isNeedHeapFreeStructureStack[],int &sp)
+{
+ Type leftType( type_stack[sp-2], index_stack[sp-2] );
+ Type rightType( type_stack[sp-1] & (~FLAG_CAST), index_stack[sp-1] );
+
+ //オーバーロードされたオペレータ関数を呼び出す
+ const CClass *pobj_c = &leftType.GetClass();
+
+ std::vector subs;
+ pobj_c->GetDynamicMethods().Enum( idCalc, subs );
+ if( subs.size() == 0 ){
+ return 0;
+ }
+
+
+ //項の数
+ BOOL bTwoTerm=1;
+ if(idCalc==CALC_AS) bTwoTerm=0;
+
+
+ /////////////////////////////////////////////
+ // オーバーロード解決用のパラメータを設定
+ /////////////////////////////////////////////
+
+ Parameters params;
+
+ if(bTwoTerm){
+ params.push_back( new Parameter( "", rightType ) );
+ }
+
+ //オーバーロードを解決
+ char temporary[255];
+ if(idCalc==CALC_EQUAL) lstrcpy(temporary,"==");
+ else GetCalcName(idCalc,temporary);
+ const UserProc *pUserProc = OverloadSolution( temporary, subs, params, baseType, leftType );
+
+ if(!pUserProc){
+ if(bTwoTerm){
+ delete params[0];
+ }
+ return -1;
+ }
+ else{
+ //オーバーロードされていないが、パラメータ個数が一致しないとき
+ if(params.size()!=pUserProc->Params().size()){
+ if(bTwoTerm){
+ delete params[0];
+ }
+ return -1;
+ }
+ }
+
+ for(int i=0;i<(int)params.size();i++){
+ CheckDifferentType(
+ *pUserProc->Params()[i],
+ *params[i],
+ "",
+ i);
+ }
+
+ if(bTwoTerm){
+ delete params[0];
+ }
+
+ int right_side_size = rightType.GetSize();
+
+ if(bTwoTerm){
+ if( pUserProc->RealParams()[1]->IsStruct() &&pUserProc->RealParams()[1]->IsRef() == false ){
+ //一時オブジェクトはメソッド内で破棄される
+ isNeedHeapFreeStructureStack[sp-1] = false;
+ }
+ }
+
+
+ if( pUserProc->ReturnType().IsStruct() ){
+ //////////////////////////////////////////////////////
+ // 戻り値に構造体インスタンスを持つ場合
+ // ※ByRef _System_ReturnValue パラメータ用領域を取得
+ //////////////////////////////////////////////////////
+
+ int object_size = pUserProc->ReturnType().GetClass().GetSize();
+
+ //push object_size
+ compiler.codeGenerator.op_push_V(object_size);
+
+ //call calloc
+ extern const UserProc *pSub_calloc;
+ compiler.codeGenerator.op_call(pSub_calloc);
+
+ //mov ebx,eax
+ compiler.codeGenerator.op_mov_RR(REG_EBX,REG_EAX);
+ }
+
+
+ //2つの項を取り出す
+ if(bTwoTerm){
+ if(right_side_size==sizeof(_int64)){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //pop edx
+ compiler.codeGenerator.op_pop(REG_EDX);
+ }
+ else{
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+ }
+ }
+
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+
+
+ //ヒープ解放用に退避
+ if(isNeedHeapFreeStructureStack[sp-1]){
+ //mov esi,eax
+ compiler.codeGenerator.op_mov_RR(REG_ESI,REG_EAX);
+ }
+ if(isNeedHeapFreeStructureStack[sp-2]){
+ //mov edi,ecx
+ compiler.codeGenerator.op_mov_RR(REG_EDI,REG_ECX);
+ }
+
+
+
+ if(bTwoTerm){
+ if(right_side_size==sizeof(_int64)){
+ //push edx
+ compiler.codeGenerator.op_push(REG_EDX);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else{
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+
+ if( pUserProc->RealParams()[1]->IsRef() ){
+ //一時参照を作成
+
+ //mov eax,esp
+ compiler.codeGenerator.op_mov_RR( REG_EAX, REG_ESP );
+
+ //push eax
+ compiler.codeGenerator.op_push( REG_EAX );
+ }
+ }
+
+ if( pUserProc->ReturnType().IsStruct() ){
+ //push ebx
+ compiler.codeGenerator.op_push(REG_EBX);
+ }
+
+ //push ecx
+ compiler.codeGenerator.op_push(REG_ECX);
+
+ //call operator_proc
+ compiler.codeGenerator.op_call(pUserProc);
+
+ if(bTwoTerm){
+ if( pUserProc->RealParams()[1]->IsRef() ){
+ //一時参照を破棄
+ compiler.codeGenerator.op_pop( REG_NON );
+ }
+ }
+
+ if( !pUserProc->ReturnType().IsNull() ){
+ //スタックへプッシュ
+ PushReturnValue(pUserProc->ReturnType().GetBasicType());
+ }
+
+ if(isNeedHeapFreeStructureStack[sp-1]){
+ FreeTempObject(REG_ESI,(CClass *)index_stack[sp-1]);
+ }
+ if(isNeedHeapFreeStructureStack[sp-2]){
+ FreeTempObject(REG_EDI,(CClass *)index_stack[sp-2]);
+ }
+
+ sp--;
+ type_stack[sp-1]=pUserProc->ReturnType().GetBasicType();
+ index_stack[sp-1]=pUserProc->ReturnType().GetIndex();
+
+ if( pUserProc->ReturnType().IsStruct() )
+ {
+ //構造体が戻ったときはヒープ領域にインスタンスが格納されている
+ //※後にfreeする必要あり
+ isNeedHeapFreeStructureStack[sp-1] = true;
+ }
+ else
+ {
+ isNeedHeapFreeStructureStack[sp-1] = false;
+ }
+
+ return 1;
+}
+
+void CallCastOperatorProc(Type &calcType,BOOL bCalcUseHeap,const Type &toType){
+ int type_stack[10];
+ LONG_PTR index_stack[10];
+ bool array_bUseHeap[10];
+ int sp=2;
+
+ if(bCalcUseHeap){
+ //未解放のインスタンスが存在する旨を示す警告
+ SetError(-105,NULL,cp);
+ }
+
+ //左辺
+ type_stack[0]=calcType.GetBasicType();
+ index_stack[0]=calcType.GetIndex();
+ array_bUseHeap[0]=0;
+ type_stack[1]=toType.GetBasicType();
+ index_stack[1]=toType.GetIndex();
+ array_bUseHeap[1]=0;
+
+ int iRet = CallOperatorProc(CALC_AS,toType,type_stack,index_stack,array_bUseHeap,sp);
+
+ if(iRet==1){
+ //成功したとき
+ calcType.SetType( type_stack[0], index_stack[0] );
+ return;
+ }
+ else if(iRet==-1){
+ //エラーが発行されたとき
+ return;
+ }
+
+ //エラーを発行
+ SetError(-1,"キャスト演算子がオーバーロードされていません。",cp);
+}
+void CallIndexerGetterProc( const Type &classType, const char *ObjectName, char *Parameter,Type &resultType, DWORD dwProcFlags ){
+ std::vector subs;
+ classType.GetClass().GetDynamicMethods().Enum( CALC_ARRAY_GET, subs );
+ if( subs.size() == 0 ){
+ return;
+ }
+
+ const UserProc *pUserProc = subs[0];
+
+ Opcode_CallProc(Parameter,pUserProc,dwProcFlags,ObjectName);
+ resultType = pUserProc->ReturnType();
+
+ // 型パラメータを解決
+ ResolveFormalGenericTypeParameter( resultType, classType, pUserProc );
+}
Index: /trunk/ab5.0/abdev/BasicCompiler32/commandvalue.h
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/commandvalue.h (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/commandvalue.h (revision 440)
@@ -0,0 +1,102 @@
+/* 命令語定数 */
+
+//条件、分岐、繰り返し
+#define COM_DO 0x1021
+/* 0x22は「"」なので使用不可 */
+#define COM_GOTO 0x1023
+#define COM_GOSUB 0x1024
+#define COM_LOOP 0x1026
+#define COM_RETURN 0x1027
+/* 0x28は「(」なので使用不可 */
+/* 0x29は「)」なので使用不可 */
+#define COM_FOR 0x1031
+#define COM_NEXT 0x1032
+#define COM_WHILE 0x1036
+#define COM_WEND 0x1037
+#define COM_FOREACH 0x1038
+
+//データ操作
+#define COM_DIM 0x1062
+#define COM_LET 0x1066
+#define COM_DELETE 0x1068
+#define COM_SWEEPINGDELETE 0x1069
+
+//その他
+#define COM_DEBUG 0x1073
+
+//ポインタ
+#define COM_SETDOUBLE 0x10C1
+#define COM_SETSINGLE 0x10C2
+#define COM_SETQWORD 0x10C3
+#define COM_SETDWORD 0x10C4
+#define COM_SETWORD 0x10C5
+#define COM_SETBYTE 0x10C6
+
+
+
+///////////////////////////////////
+// 以下はProjectEditorで使用される
+
+//入出力コマンド
+#define COM_PRINT 0x1150
+#define COM_INPUT 0x1151
+#define COM_OPEN 0x1152
+#define COM_CLOSE 0x1153
+#define COM_FIELD 0x1154
+#define COM_WRITE 0x1155
+
+//条件、分岐、繰り返し
+#define COM_IF 0x1160
+#define COM_SELECT 0x1161
+
+//ファイル操作
+#define COM_CHDIR 0x1170
+#define COM_KILL 0x1171
+#define COM_MKDIR 0x1172
+#define COM_GET 0x1173
+#define COM_PUT 0x1174
+
+//グラフィックス
+#define COM_CIRCLE 0x1180
+#define COM_LINE 0x1181
+#define COM_PAINT 0x1182
+#define COM_PSET 0x1183
+
+//データ操作
+#define COM_CONST 0x1190
+#define COM_TYPEDEF 0x1191
+
+//クラス関連
+#define COM_CLASS 0x1195
+#define COM_PRIVATE 0x1196
+#define COM_PUBLIC 0x1197
+#define COM_INHERITS 0x1198
+#define COM_PROTECTED 0x1199
+#define COM_INTERFACE 0x119A
+
+//その他
+#define COM_BEEP 0x11A0
+#define COM_CLS 0x11A1
+#define COM_COLOR 0x11A2
+#define COM_DECLARE 0x11A4
+#define COM_DEF 0x11A5
+#define COM_END 0x11A6
+#define COM_FUNCTION 0x11A7
+#define COM_LOCATE 0x11A8
+#define COM_RANDOMIZE 0x11A9
+#define COM_REM 0x11AA
+#define COM_SLEEP 0x11AB
+#define COM_SUB 0x11AC
+#define COM_TYPE 0x11AD
+#define COM_VIRTUAL 0x11AE
+#define COM_OVERRIDE 0x11AF
+#define COM_WITH 0x11B0
+#define COM_ENUM 0x11B1
+#define COM_ABSTRACT 0x11B2
+#define COM_NAMESPACE 0x11B3
+#define COM_TRY 0x11B4
+
+//ウィンドウ制御
+#define COM_DELWND 0x11C0
+#define COM_MSGBOX 0x11C1
+#define COM_WINDOW 0x11C2
Index: /trunk/ab5.0/abdev/BasicCompiler32/increment.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/increment.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/increment.cpp (revision 440)
@@ -0,0 +1,220 @@
+#include "stdafx.h"
+
+#include
+
+#include "../BasicCompiler_Common/common.h"
+#include "Opcode.h"
+
+void IncDec(int idCalc, const char *lpszLeft, const char *lpszRight)
+{
+ Type varType;
+ if( GetVarType( lpszLeft, varType, false ) )
+ {
+ if( varType.IsObject() )
+ {
+ // オブジェクトが対象だったとき
+ char temporary[8192];
+ char calcStr[32];
+ GetCalcName( idCalc, calcStr );
+ sprintf( temporary, "%s=%s %s %s", lpszLeft, lpszLeft, calcStr, lpszRight );
+ SetEscapeSequenceFormat( temporary );
+ KillStringSpaces( temporary );
+ OpcodeCalc( temporary );
+ return;
+ }
+ }
+
+ ///////////////////////////
+ // 変数アドレスを取得
+ ///////////////////////////
+ RELATIVE_VAR VarRelativeVar;
+ if(!GetVarOffsetReadWrite(
+ lpszLeft,
+ &VarRelativeVar,
+ varType)) return;
+
+ if(IsUse_ecx(&VarRelativeVar)){
+ //push ecx
+ compiler.codeGenerator.op_push(REG_ECX);
+ }
+
+
+ ///////////////////////////////////
+ // レジスタへ変数の内容をコピー
+ ///////////////////////////////////
+
+ if( varType.IsReal() ){
+ //実数
+ SetReg_RealVariable(varType.GetBasicType(),&VarRelativeVar);
+ }
+ else{
+ //整数
+ SetReg_WholeVariable(varType,&VarRelativeVar,REG_EAX);
+ }
+
+
+ if(varType.IsWhole()&&lstrcmp(lpszRight,"1")==0&&
+ (idCalc==CALC_ADDITION||idCalc==CALC_SUBTRACTION)){
+ ////////////////////////////////////////////
+ // 整数型のインクリメント・デクリメント
+ ////////////////////////////////////////////
+
+ if( varType.Is64() ){
+ if(idCalc==CALC_ADDITION){
+ //64ビット インクリメント
+
+ //add eax,1
+ compiler.codeGenerator.op_add_RV8(REG_EAX,1);
+
+ //adc edx,0
+ compiler.codeGenerator.op_adc_RV8(REG_EDX,0);
+ }
+ else if(idCalc==CALC_SUBTRACTION){
+ //64ビット デクリメント
+
+ //sub eax,1
+ compiler.codeGenerator.op_sub_RV8(REG_EAX,1);
+
+ //sbb edx,0
+ compiler.codeGenerator.op_sbb_RV8(REG_EDX,0);
+ }
+ }
+ else{
+ if(idCalc==CALC_ADDITION){
+ //インクリメント
+ compiler.codeGenerator.op_inc(REG_EAX);
+ }
+ else if(idCalc==CALC_SUBTRACTION){
+ //デクリメント
+ compiler.codeGenerator.op_dec(REG_EAX);
+ }
+ }
+ }
+ else{
+ //変数オフセットを一時退避
+ //push ecx
+ compiler.codeGenerator.op_push(REG_ECX);
+
+ if( varType.IsDouble() ){
+ //sub esp,8
+ compiler.codeGenerator.op_sub_esp(8);
+
+ //fstp qword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg(varType.GetBasicType(),REG_ESP);
+ }
+ else if( varType.IsSingle() ){
+ //sub esp,4
+ compiler.codeGenerator.op_sub_esp(4);
+
+ //fstp dword ptr[esp]
+ compiler.codeGenerator.op_fstp_basereg(varType.GetBasicType(),REG_ESP);
+ }
+ else if( varType.Is64() ){
+ //push edx
+ compiler.codeGenerator.op_push(REG_EDX);
+
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+ else{
+ //push eax
+ compiler.codeGenerator.op_push(REG_EAX);
+ }
+
+ Type calcType;
+ if( !NumOpe(lpszRight,varType,calcType) ){
+ return;
+ }
+
+ if( varType.IsDouble() ) ChangeTypeToDouble(calcType.GetBasicType());
+ else if( varType.IsSingle() ) ChangeTypeToSingle(calcType.GetBasicType());
+ else ChangeTypeToWhole( calcType, varType );
+
+ int type_stack[255],sp;
+ LONG_PTR index_stack[255];
+ type_stack[0]=varType.GetBasicType();
+ type_stack[1]=varType.GetBasicType();
+ index_stack[0]=varType.GetIndex();
+ index_stack[1]=varType.GetIndex();
+ sp=2;
+
+ switch(idCalc){
+ case CALC_XOR:
+ Calc_Xor(type_stack,index_stack,&sp);
+ break;
+ case CALC_OR:
+ Calc_Or(type_stack,index_stack,&sp);
+ break;
+ case CALC_AND:
+ Calc_And(type_stack,index_stack,&sp);
+ break;
+ case CALC_SHL:
+ Calc_SHL(type_stack,&sp);
+ break;
+ case CALC_SHR:
+ Calc_SHR(type_stack,&sp);
+ break;
+ case CALC_ADDITION:
+ case CALC_SUBTRACTION:
+ case CALC_PRODUCT:
+ CalcTwoTerm_Arithmetic(idCalc,type_stack,index_stack,&sp);
+ break;
+ case CALC_MOD:
+ Calc_Mod(type_stack,&sp);
+ break;
+ case CALC_QUOTIENT:
+ Calc_Divide(type_stack,&sp,varType.GetBasicType());
+ break;
+ case CALC_INTQUOTIENT:
+ Calc_IntDivide(type_stack,index_stack,&sp);
+ break;
+ case CALC_POWER:
+ Calc_Power(type_stack,&sp);
+ break;
+ }
+
+
+ if( varType.IsDouble() ){
+ //fld qword ptr[esp]
+ compiler.codeGenerator.op_fld_basereg(varType.GetBasicType(),REG_ESP);
+
+ //add esp,8
+ compiler.codeGenerator.op_add_esp(8);
+ }
+ else if( varType.IsSingle() ){
+ //fld dword ptr[esp]
+ compiler.codeGenerator.op_fld_basereg(varType.GetBasicType(),REG_ESP);
+
+ //add esp,4
+ compiler.codeGenerator.op_add_esp(4);
+ }
+ else if( varType.Is64() ){
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+
+ //pop edx
+ compiler.codeGenerator.op_pop(REG_EDX);
+ }
+ else{
+ //pop eax
+ compiler.codeGenerator.op_pop(REG_EAX);
+ }
+
+
+ //変数オフセットを復元
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+ }
+
+
+ /////////////////////////////////////////////////
+ // レジスタの内容を変数にコピー
+ /////////////////////////////////////////////////
+
+ if(IsUse_ecx(&VarRelativeVar)){
+ //pop ecx
+ compiler.codeGenerator.op_pop(REG_ECX);
+ }
+
+ SetVariableFromEax(varType,varType.GetBasicType(),&VarRelativeVar);
+}
Index: /trunk/ab5.0/abdev/BasicCompiler32/manifest.xml
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/manifest.xml (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/manifest.xml (revision 440)
@@ -0,0 +1,22 @@
+
+
+
+Description
+
+
+
+
+
+
Index: /trunk/ab5.0/abdev/BasicCompiler32/op32_main.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/op32_main.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/op32_main.cpp (revision 440)
@@ -0,0 +1,11 @@
+#include "stdafx.h"
+
+#include "../BasicCompiler_Common/common.h"
+#include "Opcode.h"
+
+
+
+BOOL IsSafeReg(int reg){
+ if(reg==REG_EBX||reg==REG_ESI||reg==REG_EDI) return 1;
+ return 0;
+}
Index: /trunk/ab5.0/abdev/BasicCompiler32/resource.h
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/resource.h (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/resource.h (revision 440)
@@ -0,0 +1,56 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by BasicCompiler.rc
+//
+#define IDD_MAIN 101
+#define IDD_VARLIST 103
+#define IDI_MAIN 108
+#define IDI_VARSTRUCT 109
+#define IDI_VARDATA 110
+#define IDI_VARSTR 111
+#define IDI_VARARRAY 112
+#define IDI_VARPTRSTRUCT 113
+#define IDD_CLIPMAIN 114
+#define IDD_DEBUGGER 115
+#define IDR_DEBUGGERTOOLBAR 117
+#define IDD_DEBUGGER_TOOLBARBASE 120
+#define IDR_DEBUGGER_VARLIST_MENU 122
+#define IDR_DEBUGGERTOOLBAR_DISABLED 125
+#define IDC_EXEPATH 1000
+#define IDC_PROGRESS 1001
+#define IDC_ERRORLIST 1002
+#define IDC_MESSAGE 1003
+#define IDC_DEBUGLIST 1005
+#define IDC_SHOWERROR 1006
+#define IDC_SHOWDEBUG 1007
+#define IDC_THREADCOMBO 1014
+#define IDC_VARTREE 1015
+#define IDC_GLOBAL 1016
+#define IDC_LOCAL 1017
+#define IDC_PROCCOMBO 1018
+#define IDC_HIDESYSVAR 1019
+#define IDC_STEPIN 1021
+#define IDC_STEPOVER 1022
+#define IDC_ESP 1023
+#define IDC_DUMMYCANCEL 1024
+#define IDC_TAB1 1025
+#define IDC_VARPOS 1029
+#define IDC_WATCHLIST 1033
+#define IDC_STATIC_VERSION 1034
+#define IDC_DEBUG_START 40003
+#define IDC_DEBUG_STEPOVER 40004
+#define IDC_DEBUG_STEPIN 40005
+#define IDM_SHOW_DEFAULTSYSTEM_VAR 40007
+#define IDM_SHOW_RAD_VAR 40008
+#define IDM_SHOW_GUID_VAR 40009
+
+// Next default values for new objects
+//
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE 126
+#define _APS_NEXT_COMMAND_VALUE 40010
+#define _APS_NEXT_CONTROL_VALUE 1035
+#define _APS_NEXT_SYMED_VALUE 101
+#endif
+#endif
Index: /trunk/ab5.0/abdev/BasicCompiler32/stdafx.cpp
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/stdafx.cpp (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/stdafx.cpp (revision 440)
@@ -0,0 +1,1 @@
+#include "stdafx.h"
Index: /trunk/ab5.0/abdev/BasicCompiler32/stdafx.h
===================================================================
--- /trunk/ab5.0/abdev/BasicCompiler32/stdafx.h (revision 440)
+++ /trunk/ab5.0/abdev/BasicCompiler32/stdafx.h (revision 440)
@@ -0,0 +1,27 @@
+#pragma once
+
+#include