plxcompileboss.cpp

一个PLX教学编译器IDE

#include "stdafx.h"
#include "plxc.h"
#include "plxCompileBoss.h"

#include "AdvEditCtrl.h"
#include "AdvRichEdit.h"
#include "AdvFileTree.h"
#include "DebugOutInfoView.h"
#include "AdvResultView.h"
#include "AdvVariableList.h"

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

static CString keyword = " integer logical program const begin end procedure "
                         " write if do else then end while until repeat call "
						 " true and false or ";

plxCompileBoss::plxCompileBoss()
{
    pDebugView        = NULL;
    pSourceView       = NULL;
	pSearchView       = NULL;
    pFileNameView     = NULL;
	pDebugOutInfoView = NULL;
	pResultView       = NULL;
	pVariableList     = NULL;

    m_bIsfileOpen = FALSE;
}

plxCompileBoss::~plxCompileBoss()
{
}

/* 中心消息处理函数   */
void plxCompileBoss::DefMsgProc(LPACTION pAction)
{
    switch(pAction->msg)
	{
	   case WM_INITDOCUMENT:
		    InitDocument(pAction);	    
		    break;
	   case WM_INITVIEW:
		    getWndHandle(pAction);
		    break;
	   case WM_APP_FILE_OPEN:
		    openFirstFile(pAction);
		    break;
   	   case WM_APP_FILE_NEW:
		    newFile(pAction);
			break;
	   case WM_APP_FILE_SAVE:
		    saveFile(pAction);
		    break;
	   case WM_APP_FILE_CLOSE:
		    OnDocumentClose(pAction);
		    break;
	   case WM_COM_COMPILE:
		    compile(pAction);
		    break;
	   case WM_COM_BUILD:
		    Build(pAction);
		    break;
	   case WM_COM_RUN:
		    Run(pAction);
		    break;
	   case WM_COM_SEARCHSTRING:
		    OnSearchText(pAction);
		    break;
	   case WM_COM_CUT:
		    onCut(pAction);
		    break;
	   case WM_COM_PASTE:
		    onPaste(pAction);
		    break;
	   case WM_COM_COPY:
		    onCopy(pAction);
		    break;
	   case WM_COM_UNDO:
		    onUndo(pAction);
		    break;
	   case WM_COM_DEBUG:
		    onDebug(pAction);
		    break;
	   case WM_COM_STEPINTO:
		    onStepInto(pAction);
		    break;
	   default:;
	}
}

/* ---------------------- 初始化 -------------------------------------------------- */
void plxCompileBoss::InitDocument(LPACTION pAction)
{
    switch(pAction->wParam)
	{
	   case IDENT_WND_DEBUG:
		    pDebugView    = (CDebugView*)pAction->pWnd; 
			core.SetDebugView(pDebugView); 	
		    break;
	   case IDENT_WND_COMBOSEARCH:
		    pSearchView   = (CComboBox*)pAction->pWnd;
		    break;
	   case IDENT_WND_COMBOFILENAME:
		    pFileNameView = (CComboBox*)pAction->pWnd;           
		    break;
	   case IDENT_WND_FILELIST:
		    pFileList     = (CAdvFileTree*)pAction->pWnd; 
		    break;
	   case IDENT_WND_CODEVIEW:
		    pDebugOutInfoView = (CDebugOutInfoView*)pAction->pWnd; 
			core.SetCodeOutView(pDebugOutInfoView);	
		    break;
	   case IDENT_WND_RESULTVIEW:
		    pResultView   = (CAdvResultView*)pAction->pWnd; 
			core.SetOutputView(pResultView);
		    break;
	   case IDENT_WND_VARIABLELIST:
		    pVariableList = (CAdvVariableList*)pAction->pWnd; 
			core.SetVariableList(pVariableList);
		    break;
	   default:;
	}
}
			
void plxCompileBoss::getWndHandle(LPACTION pAction)
{
    pSourceView = (CAdvRichEdit*)pAction->pWnd;	
	setEditorText();
}

void plxCompileBoss::openFirstFile(LPACTION pAction)
{
	ASSERT_VALID(pFileList);
    ASSERT_VALID(pFileNameView);

	m_bIsfileOpen = TRUE;
    strFilepath   = pAction->text;

	pFileList->AddItem(strFilepath);
	pFileNameView->SetWindowText(strFilepath);
}

void plxCompileBoss::newFile(LPACTION pAction)
{
	m_bIsfileOpen = FALSE;
    strFilepath   = pAction->text;

    pAction->lParam = CreateNewFile(strFilepath);
}

/* 创建新文件 */
bool plxCompileBoss::CreateNewFile(LPCTSTR filePath)
{
    CFile newfile;

	if(!newfile.Open(filePath,CFile::modeCreate))
	{
	    AfxMessageBox(_T("Cann't Create new file!"));
        return FALSE;
	}
    
	newfile.Close();
	pFileList->AddItem(filePath);
	pFileNameView->SetWindowText(strFilepath);

	return TRUE;
}

/*  存储文件   */
void plxCompileBoss::saveFile(LPACTION pAction)
{
	ASSERT_VALID(pSourceView);

	if(pSourceView->m_hWnd != NULL)
	{
		if(pSourceView->SaveFile(pAction->text))
		{
            strFilepath  = pAction->text;
		}else
		{
		    pAction->lParam = 0;
		}
	}else
	{
	    pAction->lParam = 0;
	}
}

void plxCompileBoss::setEditorText()
{
    ASSERT_VALID(pSourceView);

	pSourceView->Initialize();
    pSourceView->AddKeywords(keyword);

    if(m_bIsfileOpen)
	{
		pSourceView->LoadFile(strFilepath);
	}
}

/*  关闭文档            */
void plxCompileBoss::OnDocumentClose(LPACTION pAction)
{
     ASSERT_VALID(pFileList);

	 pFileList->RemoveItem(strFilepath);
}

/*     编译运行函数     */
void plxCompileBoss::compile(LPACTION pAction)
{	
	ASSERT_VALID(pSourceView);
	
	if(!pSourceView->SaveFile(strFilepath))		
		return;
				
	if(core.OpenFile(strFilepath))
	{				
		ASSERT_VALID(pDebugView);		
		pDebugView->Clean();
		
		core.Compiler();
		
		pDebugView->AddText(_T(""));
		
		CString result;
		result.Format(_T("Compile - %d error(s)"),core.GetErrorNumber());
		
		pDebugView->AddText(result);
	}else
	{
		pDebugView->AddText(_T("Cann't open unitized source file."));
	}	
}

void plxCompileBoss::Build(LPACTION pAction)
{
	 ASSERT_VALID(pDebugView);

     compile(pAction);

	 if(core.GetErrorNumber() == 0)
	 {
		 pDebugView->AddText(_T(""));
         pDebugView->AddText(_T("Create object code....."));

		 CString strBuffer(strFilepath);
	     strBuffer.Replace(_T(".plx"),_T(".plo"));

         pDebugView->AddText(_T("Export to ")+strBuffer);
		 pDebugView->AddText(_T(""));
         
		 if(core.outputCode(strBuffer))
		 {			 
		     pDebugView->AddText(_T("Build successfully."));
		 }else
		 {
		     pDebugView->AddText(_T("Build failed"));
		 }
	 }
}

void plxCompileBoss::Run(LPACTION pAction)
{	
	CString strBuffer(strFilepath);
	strBuffer.Replace(_T(".plx"),_T(".plo"));
	::ShellExecute(NULL,_T("open"),GetExecutePath(),strBuffer,_T(""),SW_NORMAL);
}

/*  获取当前虚拟机的启动路径  */
CString plxCompileBoss::GetExecutePath()
{
    TCHAR appPath[256];
    GetModuleFileName(NULL,appPath,256);

	CString sPath(appPath);
    sPath = sPath.Left(sPath.ReverseFind('\\'));
    sPath += _T("\\bin\\plxw.exe");
    
	return sPath;
}

/*    编辑处理函数     */
void plxCompileBoss::onPaste(LPACTION pAction)
{
    pSourceView->DoPaste();
}

void plxCompileBoss::onCopy(LPACTION pAction)
{
    pSourceView->DoCopy();
}

void plxCompileBoss::onUndo(LPACTION pAction)
{
    pSourceView->DoUndo();
}

void plxCompileBoss::onCut(LPACTION pAction)
{
    pSourceView->DoCut();
}

/*  响应查询    */
void plxCompileBoss::OnSearchText(LPACTION pAction)
{
	CString  strText;
	pSearchView->GetWindowText(strText);

	if(!strText.IsEmpty())
	{
	    pSourceView->Search(strText);
	}   
}

/*    调试函数   */
void plxCompileBoss::onDebug(LPACTION pAction)
{
    ASSERT_VALID(pDebugOutInfoView);
	ASSERT_VALID(pResultView);
	ASSERT_VALID(pVariableList);
    
	pResultView->Clean();
	pDebugOutInfoView->Clean();
    pVariableList->Clean();

	pResultView->AddText("---------- RESULT --------");
	pDebugOutInfoView->AddText("------------ CODE ----------");

	compile(pAction);
	
    if(core.GetErrorNumber() == 0)
	{	
		core.showCode();
		core.Debug();
	}else
	{
        pAction->wParam = 0;	  
	}
}

/*  调试单步进入 */
void plxCompileBoss::onStepInto(LPACTION pAction)
{
    int line = core.interpret(plxCompiler::RUNINTO);

	if(oldLine == line)
		return;

//	ASSERT_VALID(pSourceView);
//	pSourceView->SetLineSel(line);
}