第一篇：編譯原理課程報告（共）

編譯原理課程報告

學院： 信息工程學院專業： 軟件工程 姓名： 賴杰學號： 09927212 指導老師： 朱文華完成時間： 2012.5.19

編譯原理是計算機專業的一門重要專業課，旨在介紹編譯程序構造的一般原理和基本方法，在計算機本科教學中占有十分重要的地位。

編譯程序是現代計算機系統的基本組成部分之一，而且多數計算機系統都配有不止一個高級語言的編譯程序，對有些高級語言甚至配置了幾個不同性能的編譯程序。從功能上講，一個編譯程序就是一個語言翻譯程序。語言翻譯程序把一種源語言書寫的程序翻譯成另一種目標語言的等價程序，所以總的說編譯程序是一種翻譯程序，其源程序是高級語言，目標語言程序是低級語言。

編譯程序完成從源程序到目標程序的翻譯工作，是一個復雜的整體的過程。從概念上來講，一個編譯程序的整個工作過程是劃分成幾個階段進行的，每個階段將源程序的一種表示形式轉換成另一種表示形式，各個階段進行的操作在邏輯上是緊密連接在一起的。一般一個編譯過程是詞法分析、語法分析、語義分析、中間代碼生成、代碼優化和目標代碼生成。

編寫編譯器的原理和技術具有十分普遍的意義，以至于在每個計算機工作者的職業生涯中，本書中的原理和技術都會反復用到。在這本書中，向我們介紹了文法的概念，在講詞法分析的章節中講述了構造一個有窮自動機的方法，以及如何將一個不確定的有窮自動機轉化成確定的有窮自動機和有窮自動機的最小化等方法。

該門課中主要講述的是兩種分析方法，即自上而下分析的方法和自下而上分析的方法。自上而下分析法是從文法的開始符號出發，反復使用各種產生式，尋找“匹配”于輸入符號串的推導。自下而上的分析方法是從輸入符號串開始，逐步進行“歸約”到文法的開始符號。

1.自上而下的分析法主要的就是LL(1)文法，首先要判斷某個文法是否是

LL(1)文法，如果是就可以按照LL(1)文法分析的方法去判斷某一個輸入串是否為該文法的句子。LL(1)f分析方法是，首先根據判斷是否為LL(1)文法求出每一個非終結符的SELECTE集合來構造該文法的預測分析表，然后根據預測分析表去分析輸入串得出結果；如果不是LL(1)文法，比如說文法產生式中含有左遞歸和相同的因子，就要消去左遞歸或公共因子，再根據每一個非終結符的SELECT集合來判斷是否為LL(1)文法。利用LL(1)文法分析一個輸入串是不是某一個文法的句子，根據預測分析表是比較直觀的，而且分析的效率也是比較高的。

2.自下而上的分析方法主要是算符優先分析方法。算符優先分析的基本思

想是只規定算符之間的優先關系，也就是只考慮終結符之間的優先關系，由于算符優先分析不考慮非終結符之間的優先關系，在歸約的過程中只要找到可歸約串就歸約，沒有考慮非終結符之間的優先關系，所以說算符優先歸約不是規范規約。算符優先分析首先是要構造算符

優先關系矩陣；然后就是分析輸入串，根據關系矩陣進行移進或歸約操作；最后分析得出判斷的結果。

3.算符優先分析是有缺點的，由于算符優先分析方法在分析的過程中不知

道如何確定句柄。下面要說的就是LR(0)文法，這種方法能夠根據當前分析棧中的符號串就可以惟一的確定分析器的動作是移進還是歸約，并且是用哪一個產生式。根據規則寫出LR(0)的分析的項目集，再由項目集構造LR(0)的分析表，其次根據分析棧的元素和狀態，查看分析表，找出相關的句柄，是歸約還是移進，最后就是分析得出結果了。SLR(0)文法是以LR(0)文法為基礎的文法，是為了解決程序設計語言的文法不能夠滿足LR(0)文法條件的另一種文法分析的方法，大致的與LR(0)的分析過程相似，只是在項目集的組合上有些區別。

該課程理論性與實踐性都很強，我在學習時普遍感到內容非常抽象，不易理解，內容多且繁瑣，難以完整、全面地掌握編譯原理的有關知識，更不用說靈活運用編譯原理知識從事相關設計或應用于其他領域。雖然只有少數人從事編譯方面的工作，但是這門課在理論、技術、方法上都對我提供了系統而有效的訓練，有利于提高軟件人員的素質和能力。

在我學習編譯原理以前，都認為編譯原理只能應用在寫程序語言的編譯器上,覺得用處不大,學習興趣不高。而在后來的學習中，我逐漸認識到計算機專業的學生，除了要會編寫程序語言之外，還應該了解它是如何被計算機所識別，這才是真正并且透徹地學習軟件。另外，編譯器中每一個模塊的編寫，都能對我的編程能力的提高有很大幫助。在今后若從事軟件工程，這門課程也能夠對編寫程序有所幫助。

為了能夠系統掌握這門專業課，我把編譯原理分為以下幾個模塊：①語言和文法；②詞法分析；③語法分析；④語義分析和中間代碼生成；⑤代碼優化和目標代碼生成。

在學習的開始，我需要掌握什么是編譯，編譯分為哪些階段，編譯程序和解釋程序的區別等等。在做好了這些方面的準備后，開始了系統的學習。

語言和文法部分的知識包括文法基本概念及文法的二義性。基本概念有文法定義、推導、句型、句子等等。二義性文法是通過畫語法樹的方法來證明。

詞法分析中的重點是有窮自動機DFA的生成以及DFA和正規式與正規文法的關系。還要熟練掌握NFA轉換為DFA的方法及DFA的化簡。

語法分析包括自上而下和自下而上分析。自上而下分析著重掌握LL(1)文法，自下而上分析重點掌握算符優先文法和LR(0)、SLR（1）文法。

語義分析重點是其功能，中間代碼生成和語法制導翻譯定義與方法。

最后，優化分為局部優化和循環優化，重點理解一些關鍵詞，如基本塊、流圖等，要學會自己畫出程序流圖。用DAG圖進行局部優化是重點。

在學習文法時，對文法的組成，用法都較為明了，而在真正做題時卻感到十分吃力。例如給出了一個語言，要求寫出它的上下文無關文法，就感到十分棘手，所以今后在這方面要加大練習量，以熟練掌握。

而在之后的詞法分析和語法分析中，我感到在看基本原理時十分困難，通常要長時間鉆研才能夠有所了解，而一旦掌握了基本原理，做題時就感到十分順暢了。例如，在剛接觸到LR（0）文法時，我用了大量的時間去學習它的原理，掌

握之后，在列LR(0)分析表和寫分析過程時，只要思路清晰，就會比較順暢，而且不會犯錯。

通過這學期的對編譯原理課程的學習，這么課程讓我學會了如何去編譯程序的一個理論知識，知道編譯程序是通過怎樣的方法把程序員編寫的源程序翻譯成計算機能夠執行的機器語言的，我覺得主要的是大大加深了我對程序設計的理解，也對計算機的理論和軟件編譯有了深一步的理解。這學期的編譯原理的實驗使我知道了編譯程序的工作的基本過程及其各階段的基本任務，了解了 編譯程序流程框圖，編譯程序的生成過程、構造工具及其相關的技術對課本上的知識有了更深的理解，可以說這是將書本上的理論知識的應用，是對理論知識的更深一步的理解和掌握。

第二篇：編譯原理課程-教學計劃

編譯原理教學大綱2001,9

周次課內學時課內安排(講授內容)建議課外安排備注

12編譯原理概述閱讀PL/0程序文本

24介紹PL/0編譯程序閱讀PL/0程序文本

32詞法分析程序自動構造閱讀PL/0程序文本

(正規式,有窮自動機)

44(2)詞法分析程序自動構造練習題

Lex(Flex)介紹,布置PP1實踐題一PP1

52文法和語言練習題

64自頂向下語法分析練習題提交PP1LL(1)文法

72自底向上語法分析練習題

LR文法

84LR分析練習題

期中考試

92Yacc介紹,布置PP2實踐題一PP2

104習題課

語法分析方法比較提交PP2 112語法制導翻譯,布置PP3實踐題一PP3

124語法制導翻譯

運行時存儲組織提交PP3 132運行時存儲組織練習題144代碼優化, 布置PP4實踐題一PP4

152代碼生成164實踐題目總結答辯

習題課

附1 實踐題目(從中選一)

實踐題一 Deacf編譯程序的設計和實現.實踐題二Pl/0編譯程序擴充,用Lex和 Yacc實現一個小解釋器.實踐題三 java實現的Mini-Triangle編譯程序.(限少數同學選,在第四周作選題報告)附2 課程評分

1課堂小測驗,作業抽查 10%期中考試20%

3實踐題一 40% 實踐題二20% 實踐題三 50%

4期末考試 完成實踐題一 30% 完成實踐題二50% 完成實踐題三 20%

第三篇：編譯原理課程和助教工作總結

編譯原理課程和助教工作總結

時間如流水般，轉眼，一學期將至，每個人為了能交上一份滿意的答卷，無時無刻不在傾注著汗水，揮灑著熱淚。掩卷長思，細細品味，這學期的點點滴滴不禁又浮上心頭，現在讓我們一起回顧一下，希望可以對今后的教學工作有所幫助。

編譯原理是我們北京師范大學信息科學與技術學院計算機專業本科生的專業必修課，它旨在介紹編譯程序構造的一般原理和基本方法，其內容主要包括語言和文法、詞法分析、語法分析、語法制導翻譯、中間代碼生成、存儲管理、代碼優化和目標代碼生成等。這門課程關注的是編譯器方面的產生原理和技術問題，似乎和計算機的基礎領域不沾邊，但是編譯原理課程是所有計算機專業學生應該習得的一門重要課程，因為雖然在將來并不是所有人都會從事編譯方面的工作，但是通過編譯原理的學習之后，可從許多不同的角度來觀察編譯器的結構，編譯器的物理結構、操作的順序等等，會涉及到數據結構、計算機組成原理等課程，所以同學們在理論、技術和方法上都能得到系統而有效的訓練，而且有利于將來希望從事軟件開發的學生的相關素質和能力的進一步提高，更能夠讓每個學生更清楚的了解和熟悉一段程序從源代碼到可執行文件之間具體的轉換過程，這樣能夠更好的理解代碼的編譯和計算機內部的工作原理，對學生以后計算機相關的學習乃至工作從業都會有非常大的幫助。

編譯原理這門課程是計算機專業課程中偏難的一門課，不管是在平時的課堂教學上，還是在上機實驗的過程中，學生都會產生很多困惑之處，在這些方面我們的編譯原理助教就承擔了相當重要的工作和任務：

每周課堂隨堂聽課，跟進教學進度，并且上課之前做好復習工作，對每節課同學們可能會產生的問題提前做好歸納，以便更好的在課余時間跟同學們討論，給同學們提供答疑解惑的機會；

能動手編寫代碼完成變異原理實驗是本課程技能培養的重要一環，在每周的上機實驗時，助教幫助同學們進行分組，以小組合作的方式來完成每次的實驗任務，依照課程進度循序漸進的給同學們分派布置實驗任務，在實驗課上跟同學們隨時交流，一同調試代碼，一對一的解答實驗疑惑等，并且協助同學們理解實驗原理和內容，輔助同學們能夠順利完成上機實驗，通過上機實驗的手動操作，同學們也可以更直接、更具體的理解編譯程序代碼過程中一些具體的原理和方法；實驗課我選取的是基于C++或者是基于flex和bison的實驗，助教會主動和實驗課本的作者老師聯系溝通，獲得更多實驗相關的資料，比如書上給出代碼的電子版和用例測試等。

助教在課后會主動收集同學們課堂上課或者實驗過程中遇到的問題向我反映，這樣可以及時發現同學們在課堂中理解較為模糊甚至有偏差的地方，并在課堂或者實驗課上進行一個集中的講解，更利于同學們的學習；

每次課結束之后，我會布置課后作業來讓同學們對課堂教學內容進行鞏固和查漏補缺，助教認真批改同學們的課后作業、所交的實驗報告和運行的代碼，做好每位同學的評分與登記，對課后作業、實驗報告和代碼中關鍵性的錯誤做出標記，并要求學生改正。登記課后成績時，按10分制來決定，登記實驗成績時按照20分制來決定。在每次批改作業結束后，助教會及時整理，匯總學生的成績和作業實驗中出現的問題，助教通過批改課后作業和實驗來了解同學們真實的學習情況，從而能夠更好的輔助教學工作的進行。

平時為了同學們能獲得更好的學習體驗，會進行一些與國外教授的視頻課程或者相關活動等，助教會組織同學們進行視頻授課前的預習工作，同大家一起討論上課形式，提出可能遇到的問題等等，在課前會負責批教室，布置桌椅場地，設置視頻授課環境，調試攝像頭、話筒和音響等相關的設備，為進行正常的視頻授課或其他活動做準備。

對自己的要求：

一、師德方面：加強修養，塑造“師德”，我始終認為作為一名教師應把“師德”放在一個極其重要的位置上，因為這是教師的立身之本。“學高為師，身正為范”，這個道理古今皆然。從踏上講臺的第一天，我就時刻嚴格要求自己，力爭做一個有崇高師德的人，為每一個學生“傳道授業解惑”。

二、認真備課，不但備學生而且備教材備教法，根據教材內容及學生的實際，設計課的類型，擬定采用的教學方法，并對教學過程的程序及時間安排都作了詳細的安排，認真寫好教案。每一課都做到“有備而來”，每堂課都在課前做好充分的準備，并制作各種有利于吸引學生注意力的有趣教具，課后及時對該課作出總結，并認真搜集每課書的知識要點，歸納總結。

三、增強上課技能，提高教學質量，使講解清晰化，條理化，準確化，生動化，做到線索清晰，言簡意賅，深入淺出。在課堂上特別注意調動學生的積極性，讓學生多動手，從而加深理解掌握知識。加強師生交流，充分體現學生的主動作用，讓學生學得容易，學得輕松，學得愉快；注意精講精練，在課堂上老師講得盡量少，學生動口動手動腦盡量多；同時在每一堂課上都充分考慮每一個層次的學生學習需求和學習能力，讓各個層次的學生都得到提高。

四、認真批改作業：布置作業做到精讀精練。有針對性，有層次性。同時對學生的作業批改及時、認真，分析并記錄學生的作業情況，將他們在作業過程中出現的問題作出分類總結，進行透切的評講，并針對有關情況及時改進教學方法，做到有的放矢。對學生：

“不積跬步，無以致千里；不積小流，無以成江海”，學生要從點點滴滴做起，一步一個腳印，一份耕耘，一份收獲。學習要靠你們自己，踏踏實實做事，所謂“行百里路半九十”，學習要鍥而不舍，奮進永遠是核心，讓努力充實自己，厚積而薄發，達到“書香引蝶宜養蘭，胸中點墨繪新顏”的水平。

第四篇：《編譯原理》課程培訓心得體會

《編譯原理》課程培訓心得體會

天津科技大學 吳江紅

首先感謝全國高校教師網絡培訓中心為我們這些工作在教學第一線的教師提供一個提高自己教學水平、方法和能力的機會，使得我們學習到更好的方法能更好地為學生服務。經過本次培訓之后，我個人覺得可以通過以下幾個方面提高教學質量。

1、認清編譯原理，明確學習意義，激發學生的熱情 幫助學生認清編譯原理的作用和地位。給學生介紹清楚可以通過編譯原理的學習，有助于學生快速理解、定位和解決在程序編譯、測試與運行中出現的問題。幫助學生克服畏難心理，提高學生的興趣。編譯原理中的原理除了可以用于分析編譯器以外，還對諸如人工智能、并行處理技術等課程的學習具有指導作用。本門課程學習對其它課程的學習和今后很多領域的理論研究具有深遠的意義，如計算機軟件技術領域、計算機系統結構領域、人工智能系統的機器學習領域、并行處理技術等領域。

2、優化教學內容，搞好課堂教學

可以采用以人本主義學習理論為基礎，充分發揮學生的學習主動性，注重啟發式教學，注重提高學生的素質、培養學生的創新能力。使得學生對編譯原理課程的興趣提高，能主動學習，理解、體會前輩們在解決相應問題時是如何考慮的，同學們自己又是如何考慮的。

編譯系統中的一些概念很抽象，學生無法理解，就只會死記硬背，當然更無興趣可言。在講解的過程中，可以選用學生最熟悉的一些實例，通過類比使抽象的概念更容易被理解。我本人覺著對于工學學科的同學來說，不用在數學定義上花費太多時間，因為他們對數學符號不敏感，而應該盡量多安排例子，使得同學們能把數學符號代表的含義通過例子理解清楚，以及知道如何使用。

有效地利用教學輔助手段，增強課堂教學效果。由于本課程涉及形式語言、有窮自動機等抽象內容，學生在學習過程中接受起來較困難。為了提高學生的學習興趣、增強課堂教學效果，可以將教學過程中一些需要教師在黑板上動態演示的過程做成CAI課件，既可在課堂上演示，也可在課后由學生自己觀摩，有助于加深學生對所學知識的理解。

同時可在課堂上和習題中，多準備了一些從實際程序的編譯和運行時碰到的問題中抽象出來的例子，供學生用所學的知識去分析、理解、并加以解決。通過采用這種實例教學方式，既能夠對前期課程起到復習鞏固的作用，又能讓學生切實體會到本課程的實際價值，從而有力地激發了學生學習編譯原理和技術的積極性。

3、選取合適的教材

把理論知識具體化、通俗化，教材在教學過程中起關鍵作用。一本好的教材不僅對老師教的過程很重要，同時在學生進行預習和復習時也是相當重要的。我們可以選擇蔣宗禮教授編寫的編譯原理教材來達到我們的目標。

4、精心設計實驗教學內容

編譯原理課程對實踐的要求比較高，所以實驗課是培養學生實踐能力的重要環節，是鞏固和驗證所學理論知識，培養學生分析問題、解決問題能力的重要環節。因此為了能達到好的實驗效果，極大地促進學生對原理的理解，可以通過認真設計合適的實驗內容、采用適當的實驗形式以及教師的耐心指導等途徑。

第五篇：編譯原理課程設計報告

武 漢 紡 織 大 學

編譯原理課程設計實驗報告

學院：數學與計算機 專業：計算機 姓名： 班級： 學號： 編譯原理

編譯原理課設報告

一、實驗目的

加強對編譯程序的整體認識和了解，鞏固《編譯原理》課程所學知識。通過本次課程設計掌握編譯程序調試技巧和設計編譯程序一般的原則，加深對詞法分析、語法分析、語義分析等編譯階段及實用編譯系統的認識。使學生能將編譯理論與實際應用結合起來，提高學生軟件開發的能力。

二、實驗內容

1）仔細閱讀PL/0編譯程序文本（編譯原理(第二版)張素琴 呂映芝 蔣維杜 戴桂蘭 主編

清華大學出版社），并上機調試通過。

2）對PL/0語言進行下列擴充（1）擴充一維整型數組。

擴充var數組：VAR <數組標識名>（<下界>：<上界>）〈下界〉和〈上界〉可用常量標識名。

（2）擴充條件語句的功能使其為：IF<條件>THEN<語句>[ELSE<語句>]（3）增加repeat重復語句: REPEAT<語句>{;<語句>}UNTIL<條件> 可根據自己具體情況從中選擇2個以上題目進行擴充。

三、實驗原理

PL/0語言可以看成PASCAL語言的子集，它的編譯程序是一個編譯解釋執行系統。PL/0的目標程序為假想棧式計算機的匯編語言，與具體計算機無關。

PL/0的編譯程序和目標程序的解釋執行程序都是用PASCAL語言書寫的，因此PL/0語言可在配備PASCAL語言的任何機器上實現。其編譯過程采用一趟掃描方式，以語法分析程序為核心，詞法分析和代碼生成程序都作為一個獨立的過程，當語法分析需要讀單詞時就調用詞法分析程序，而當語法分析正確需要生成相應的目標代碼時，則調用代碼生成程序。

用表格管理程序建立變量、常量和過程表示符的說明與引用之間的信息聯系。

當源程序編譯正確時，PL/0編譯程序自動調用解釋執行程序，對目標代碼進行解釋執行，并按用戶程序的要求輸入數據和輸出運行結果。

四、實驗分析

PL/0語言編譯程序采用以語法分析為核心、一遍掃描的編譯方法。詞法分析和代碼生成作為獨立的子程序供語法分析程序調用。語法分析的同時，提供了出錯報告和出錯恢復的功能。在源程序沒有錯誤編譯通過的情況下，調用類PCODE解釋程序解釋執行生成的類PCODE代碼。

詞法分析子程序分析：

詞法分析子程序名為GETSYM，功能是從源程序中讀出一個單詞符號（TOTAKEN），把它的信息放入全局變量 SYM、ID和NUM中，字符變量放入CH中，語法分析器需要單詞時，直接從這三個變量中獲得。Getch過程通過反復調用Getch子過程從源程序過獲取字符，并把它們拼成單詞。GETCH過程中使用了行緩沖區技術以提高程序運行效率。

詞法分析器的分析過程：調用GETSYM時，它通過GETCH過程從源程序中獲得一個字符。如果這個字符是字母，則繼續獲取字符或數字，最終可以拼成一個單詞，查保留字表，如果查到為保留字，則把SYM變量賦成相應的保留字類型值；如果沒有查到，則這個單詞應是一個用戶自定義的標識符（可能是變量名、常量名或是過程的名字），把SYM置為IDENT，把這個單詞存入ID變量。查保留字表時使用了二分法查找以提高效率。如果Getch獲得的字符是數字，則繼續用Getch獲取數字，并把它們拼成一個整數或實數，然后把SYM置為 INTEGER或REAL，并把拼成的數值放入NUM變量。如果識別出其它合法的符號（比如：賦值號、大于號、小于等于號等），則把SYM則成相應的類型。如果遇到不合法的字符，把SYM置成NUL。

語法分析子程序分析：

語法分析子程序采用了自頂向下的遞歸子程序法，語法分析同時也根據程序的語義生成相應三元代碼，并提供了出錯處理的機制。語法分析主要由分程序分析過程（BLOCK）、參數變量分析過程（ParaDeclaration）、參數變量處理過程（ParaGetSub）、數組處理過程（ParaGetSub）、常量定義分析過程（ConstDeclaration）、變量定義分析過程（Vardeclaration）、語句分析過程（Statement）、表達式處理過程（Expression）、項處理過程（Term）、因子處理過程（Factor）和條件處理過程（Condition）構成。這些過程在結構上構成一個嵌套的層次結構。除此之外，還有出錯報告過程（Error）、代碼生成過程（Gen）、測試單詞合法性及出錯恢復過程（Test）、登錄名字表過程（Enter）、查詢名字表函數（Position）以及列出類 PCODE代碼過程（Listcode）作過語法分析的輔助過程。

由PL/0的語法圖可知：一個完整的PL/0程序是由分程序和句號構成的。因此，本編譯程序在運行的時候，通過主程序中調用分程序處理過程block來分析分程序部分（分程序分析過程中還可能會遞歸調用block過程），然后，判斷最后讀入的符號是否為句號。如果是句號且分程序分析中未出錯，則是一個合法的PL/0程序，可以運行生成的代碼，否則就說明源PL/0程序是不合法的，輸出出錯提示即可。

if-then-else語句的處理：

按if語句的語法，首先調用邏輯表達式處理過程處理if語句的條件，把相應的真假值放到數據棧頂。接下去記錄下代碼段分配位置（即下面生成的jpc指令的位置），然后生成 條件轉移jpc指令（遇0或遇假轉移），轉移地址未知暫時填0。然后調用語句處理過程處理 then語句后面的語句或語句塊。then后的語句處理完后，如果遇到else，就調用語句處理過程處理else語句后面的語句或語句塊，這時當前代碼段分配指針的位置就應該是上面的jpc指令的轉移位置。通過前面記錄下的jpc指令的位置，把它的跳轉位置改成當前的代碼段指針位置，否則沒遇到else，那么此時的當前代碼段分配指針的位置也是上面jpc指令的轉移位置，也是通過前面記錄下的jpc位置指令的位置，把它的跳轉到當前的代碼段指針位置。

Repeat語句的處理：

首先用CX1變量記下當前代碼段分配位置，作為循環的開始位置。然后通過遞歸調用語句分析過程分析，直到遇到until保留字，如果未對應until則出錯。調用條件表達式處理過程生成相應代碼把結果放在數據棧頂，再生成條件轉移指令，轉移位置為上面記錄的CX1。

五、相關代碼及運行結果

實驗代碼； PL0.h代碼： #include #include #include #include #include #include

#ifndef WIRTH_ZYC_ #define WIRTH_ZYC_ using namespace std;

const int norw = 16;

// no.of reserved words 保留字的個數

const int txmax = 100;

// length of identifier table 標示符表的長度（容量）const int al = 10;

// length of identifiers 標示符的最大長度

const int nmax = 14;

// max.no.of digits in numbers 數字的最大長度 const int amax = 2047;

// maximum address 尋址空間

const int levmax = 3;

// maximum depth of block nesting 最大允許的塊嵌套層數 const int cxmax = 200;

// size of code array 類PCODE目標代碼數組長度（可容納代碼行數）

const int lineLength = 82;// 行緩沖區長度

typedef enum {NUL,IDENT,NUMBER,PLUS,MINUS,TIMES,SLASH,ODDSYM,EQL,NEQ,LSS,LEQ,GTR,GEQ,LPAREN，RPAREN,COMMA,SEMICOLON,PERIOD,BECOMES,BEGINSYM,ENDSYM,IFSYM,THENSYM,WHILESYM，WRITESYM,READSYM,DOSYM,CALLSYM,CONSTSYM,VARSYM,PROCSYM,ELSESYM,REPEATSYM,UNTILSYM} symbol;// symobl類型標識了不同類型的詞匯

typedef char alfa[al+1];

// alfa類型用于標識符 typedef enum {CONSTANT,VARIABLE,PROCEDURE,ARRAY} obj0;

// 三種標識符的類型 typedef enum {LIT,OPR,LOD,STO,CAL,INT,JMP,JPC} fct;

// functions typedef set symset;

struct instruction{ fct f;// function code int l;// level,cann't big than levmax

int a;// displacement address,cann't big than amax };

// 類PCODE指令類型，包含三個字段：指令f、層差l和另一個操作數a

/******************************************* * lit 0,a: load constant a

* * opr 0,a: execute operation a

* * lod l,a: load variable l,a

* * sto l,a: store variable l,a

* * cal l,a: call procedure a at level l

* * int 0,a: increment t-register by a

* * jmp 0,a: jump to a

* * jpc 0,a: jump conditional to a

* *******************************************/

typedef struct{ alfa name;obj0 kind;union {

struct{int level,adr,size;}inOther;

int val;}other;} Table;

class PL0 {

protected:

bool listswitch,sourceEnd;char ch;

// last character read symbol sym;

// last symbol read alfa id;

// last identifier read int num;

// last number read

int cc;

// character count int ll;

// line length int kk,err;int cx;

// code allocation index int codeNo;

// code line no.static string errStr[];

// error string

char line[lineLength];

// code line vector errorString;

// error array alfa a;

// 詞法分析器中用于臨時存放正在分析的詞

instruction code[cxmax+1];

// destination code array

alfa word[norw+1];

// 保留字表

symbol wsym[norw+1];

// 保留字表中每一個保留字對應的symbol類型

symbol ssym[100];

// 一些符號對應的symbol類型表

合 char mnemonic[8][6];

// 類PCODE指令助記符表

symset declbegsys,statbegsys,facbegsys;// 聲明開始、表達式開始和項開始符號集 Table table[txmax+1];

// 符號表

FILE* fin,*fout;

public:

PL0(char* source,char*destination);

~PL0(){fclose(fin),fclose(fout);}

void error(int n);

位置和出錯代碼

void getsym();

個單詞

void getch();

個字符

void gen(fct x,int y,int z);

程序區

void test(symset s1,symset s2,int n);

合法

void block(int lev,int tx,symset fsys);

void enter(obj0 k,int &tx,int &dx,int lev);

int position(alfa id,int tx);的位置

void constdeclaration(int&tx,int&dx,int lev);

void vardeclaration(int&tx,int&dx,int lev);

void listcode(int cx0);

void statement(symset fsys,int tx,int lev);

void expression(symset fsys,int tx,int lev);

void term(symset fsys,int tx,int lev);

void factor(symset fsys,int tx,int lev);

void condition(symset fsys,int tx,int lev);

void arraydeclaration(int& tx,int& dx,int lev);

void interpret();

執行程序

int base(int l,int b,int s[]);

基地址

void SaveCode();

// 構造函數

// 析構函數

// 出錯處理，打印出錯

// 詞法分析，讀取一

// 漏掉空格，讀取一// 生成目標代碼，并送入目標

// 測試當前單詞符號是否

// 分程序分析處理過程

// 登入名字表

// 查找標示符在名字表中

// 常量定義處理

// 變量說明處理

// 列出目標代碼清單

// 語句部分處理

// 表達式處理

// 項處理

// 因子處理

// 條件處理

// 數組說明處理

// 對目標代碼的解釋

// 通過靜態鏈求出數據區的 // 保存代碼

};#endif PL0.cpp代碼： #include “pl0.h”

// 錯誤字符串數組

string PL0::errStr[]={“",”error 0001: 常數說明中“=”寫成“：=”“, ”error 0002: 常數說明中的“=”后應為數字“, ”error 0003: 常數說明中的標識符后應是“=”“, ”error 0004: const,var,procedure后應為標識符“, ”error 0005: 漏掉了‘,’或‘;’“, ”error 0006: 過程說明后的符號不正確（應是語句開始符或過程開始符）“, ”error 0007: 應是語句開始符“, ”error 0008: 過程體內語句部分的后跟符不正確“, ”error 0009: 程序皆為丟了句號‘.’“, ”error 0010: 語句之間漏了‘;’“, ”error 0011: 標識符沒說明“, ”error 0012: 賦值語句中，賦值號左部標識符屬性應是變量“, ”error 0013: 賦值語句左部標識符應是賦值號:=“, ”error 0014: call后應為標識符“, ”error 0015: call后標識符屬性應為過程“, ”error 0016: 條件語句中丟了then“, ”error 0017: 丟了end或;“, ”error 0018: while型循環語句中丟了do“, ”error 0019: 語句后的標識符不正確“, ”error 0020: 應為關系運算符“, ”error 0021: 表達式內標識符屬性不能是過程“, ”error 0022: 表達式中漏掉了右括號‘)’“, ”error 0023: 因子后的非法符號“, ”error 0024: 表達式開始符不能是此符號“, ”error 0025: 文件在不該結束的地方結束了“, ”error 0026: 結束符出現在不該結束的地方“, ”error 0027: “,”error 0028: “,”error 0029: “,”error 0030: “, ”error 0031: 數越界“, ”error 0032: read語句括號中標識符不是變量“, ”error 0033: else附近錯誤“ , ”error 0034: repeat附近錯誤“};

// PL0構造函數

PL0::PL0(char* source,char*destination){ listswitch=true,sourceEnd=false;

strcpy(word[1],”begin“);

// 初始化存儲保留字

strcpy(word[2],”call“);strcpy(word[3],”const“);

strcpy(word[4],”do“);strcpy(word[5],”else“);strcpy(word[6],”end“);strcpy(word[7],”if“);strcpy(word[8],”odd“);strcpy(word[9],”procedure“);strcpy(word[10],”read“);

strcpy(word[11],”repeat“);strcpy(word[12],”then“);strcpy(word[13],”until“);strcpy(word[14],”var“);

strcpy(word[15],”while“);strcpy(word[16],”write“);

wsym[1]= BEGINSYM;

wsym[2]= CALLSYM;留字對應的symbol類型

wsym[3]= CONSTSYM;

wsym[4]= DOSYM;wsym[5]= ELSESYM;

wsym[6]= ENDSYM;wsym[7]= IFSYM;

wsym[8]= ODDSYM;wsym[9]= PROCSYM;

wsym[10]= READSYM;

wsym[11]= REPEATSYM;wsym[12]= THENSYM;wsym[13]= UNTILSYM;wsym[14]= VARSYM;

wsym[15]= WHILESYM;wsym[16]= WRITESYM;

memset(code,0,sizeof(code));memset(ssym,0,100*sizeof(symbol));memset(table,0,sizeof(table));memset(line,0,sizeof(line));

ssym['+']= PLUS;

類型表

ssym['-']= MINUS;ssym['*']= TIMES;ssym['/']= SLASH;ssym['(']= LPAREN;ssym[')']= RPAREN;ssym['=']= EQL;ssym[',']= COMMA;ssym['.']= PERIOD;

// 初始化保留字表中每一個保

// 初始化一些符號對應的symbol

ssym['#']= NEQ;ssym['<']= LSS;ssym['>']= GTR;ssym[';']= SEMICOLON;

strcpy(mnemonic[LIT],” lit “);

// 初始化類PCODE指令助記符表

strcpy(mnemonic[OPR],” opr “);strcpy(mnemonic[LOD],” lod “);strcpy(mnemonic[STO],” sto “);strcpy(mnemonic[CAL],” cal “);strcpy(mnemonic[INT],” int “);strcpy(mnemonic[JMP],” jmp “);strcpy(mnemonic[JPC],” jpc “);

declbegsys.insert(CONSTSYM),declbegsys.insert(VARSYM),declbegsys.insert(PROCSYM);// 初始化聲明開始符號集合 statbegsys.insert(BEGINSYM),statbegsys.insert(CALLSYM),statbegsys.insert(IFSYM),statbegsys.insert(WHILESYM);// 初始化表達式開始符號集合facbegsys.insert(IDENT),facbegsys.insert(NUMBER),facbegsys.insert(LPAREN);// 初始化項開始符號集合

err= 0;cc= 0;

// 行緩沖區指針

cx= 0;

// 代碼分配指針，代碼生成模塊總在cx所指位置生成新的代碼

ll= 0;

// 行緩沖區長度

ch= ' ';

// last character read

}

kk= al;

// 引入此變量是出于程序性能考慮 codeNo=0;

// code line no.fin=fopen(source,”r“);fout=fopen(destination,”w“);// 出錯處理，打印出錯位置和出錯代碼 void PL0::error(int n){ char s[10];sprintf(s,”第 %d 行:“,codeNo);errorString.push_back(s+errStr[n]);err= err+1;//error count }//error end // 詞法分析，讀取一個單詞

void PL0::getsym(){ if(sourceEnd)

return;int i,j,k;while(ch ==' '||ch==9)

getch();

// cls space and tab if(isalpha(ch))// id or reserved word {

k=0;

memset(a,0,al+1);

// 檢測一個單詞長度 do{ if(k < al){

a[k]= ch;

k= k+1;} getch();if(sourceEnd)

return;}while(isalpha(ch)||isdigit(ch));if(k >= kk)kk = k;else { do{

a[kk]= ' ';

kk= kk-1;}while(kk > k);} strcpy(id,a);i= 1;j= norw;// 判斷是否是關鍵字（二分搜索）do{ k=(i+j)/ 2;if(strcmp(id, word[k])<=0)

j= k-1;if(strcmp(id,word[k])>=0)

i= k+1;}while(i<=j);if(i-1 > j)

sym= wsym[k];else

sym= IDENT;} else if(isdigit(ch))// number { k= 0;num= 0;sym= NUMBER;do{

num= 10 * num + ch-'0';

k= k+1;

getch();}while(isdigit(ch));if(k > nmax)

error(30);} else if(ch == ':'){ getch();if(ch == '='){

sym= BECOMES;

getch();} else

sym= NUL;} else if(ch == '<')

// extra stuff added to support <= { getch();if(ch== '='){

sym= LEQ;

getch();} else

sym= LSS;} else if(ch == '>'){ getch();if(ch == '='){

sym= GEQ;

getch();} else

sym= GTR;} else

// end of extra stuff { sym= ssym[ch];// 其它符號的賦值

getch();} }

// 漏掉空格，讀取一個字符

void PL0::getch(){ if(cc == ll){

if(feof(fin))

{

if(sym!=PERIOD)

error(25);

sourceEnd=true;

return;

}

cc= 0;

fgets(line,lineLength,fin);

codeNo++;

ll=strlen(line);

if(line[ll-1]==10)ll--;} ch= line[cc];cc= cc+1;}

// 生成目標代碼，并送入目標程序區void PL0::gen(fct x,int y,int z){ if(cx > cxmax){

cout<<”Program too longn“;

return;}

code[cx].f= x;code[cx].l= y;code[cx].a= z;

cx= cx+1;}//gen end

// 測試當前單詞符號是否合法

void PL0::test(symset s1,symset s2,int n){ if(sourceEnd)

return;if(s1.find(sym)==s1.end()){

error(n);

symset::iterator it;

for(it=s2.begin();it!=s2.end();it++)

s1.insert(*it);//s1=s1+s2

while(s1.find(sym)==s1.end())

getsym();} }//test end

// 分程序分析處理過程

void PL0::block(int lev,int tx,symset fsys){ if(sourceEnd)

return;int dx;// data allocation index int tx0;// initial table index int cx0;// initial code index

dx= 3;

// 變量的個數 tx0= tx;// 表指針

table[tx].other.inOther.adr= cx;gen(JMP,0,0);if(lev>levmax)error(32);do{

if(sym == CONSTSYM)

// 處理常量聲明

{

getsym();

do{

constdeclaration(tx,dx,lev);

while(sym == COMMA)

{

}

getsym();

constdeclaration(tx,dx,lev);} if(sym ==SEMICOLON)

getsym();else

error(5);}while(sym==IDENT);if(sym == VARSYM)

// 處理變量聲明 { getsym();do{

vardeclaration(tx,dx,lev);

while(sym == COMMA){

getsym();

vardeclaration(tx,dx,lev);

}

if(sym ==SEMICOLON)

getsym();

else

error(5);}while(sym==IDENT);} while(sym ==PROCSYM)

// 處理過程的聲明 { getsym();if(sym ==IDENT){

enter(PROCEDURE,tx,dx,lev);

getsym();} else

error(4);if(sym ==SEMICOLON)

getsym();else

error(5);symset tmp = fsys;tmp.insert(SEMICOLON);block(lev+1,tx,tmp);if(sym == SEMICOLON){

getsym();

symset tmp = statbegsys;

for(int i= IDENT;i<=PROCSYM;i++)

tmp.insert((symbol)i);

test(tmp,fsys,6);

}

else

error(5);

}

symset tmp=statbegsys;

tmp.insert(IDENT);

test(tmp,declbegsys,7);}while(declbegsys.find(sym)!=declbegsys.end());

code[table[tx0].other.inOther.adr].a= cx;table[tx0].other.inOther.adr= cx;// start adr of code table[tx0].other.inOther.size=dx;

cx0= cx;gen(INT,0,dx);symset tmp=statbegsys;for(int i=SEMICOLON;i <= ENDSYM;i++)

tmp.insert((symbol)i);statement(tmp,tx,lev);gen(OPR,0,0);// return symset s2;test(fsys,s2,8);listcode(cx0);}// block end

// 登入名字表

void PL0::enter(obj0 k,int &tx,int &dx,int lev){ tx= tx+1;strcpy(table[tx].name,id);table[tx].kind=k;switch(k){ case CONSTANT:

if(num>amax)

{

error(31);

num=0;

}

table[tx].other.val=num;

break;case VARIABLE:

table[tx].other.inOther.level=lev;

table[tx].other.inOther.adr=dx;

dx++;

break;case PROCEDURE:

table[tx].other.inOther.level=lev;

break;case ARRAY:

table[tx].other.inOther.size = lev;

break;} }//enter end

// 查找標示符在名字表中的位置

int PL0::position(alfa id,int tx)//find identifier id in table { int i;strcpy(table[0].name, id);i= tx;while(strcmp(table[i].name,id)!=0)i--;return i;}//position end

// 常量定義處理

void PL0::constdeclaration(int&tx,int&dx,int lev){ if(sym == IDENT){

getsym();

if(sym>=EQL&&sym<=BECOMES)

{

if(sym ==BECOMES)

error(1);

getsym();

if(sym == NUMBER)

{

enter(CONSTANT,tx,dx,lev);

getsym();

}

else

error(2);

}

else

error(3);} else

error(4);}// constdeclaration end

// 變量說明處理

void PL0::vardeclaration(int&tx,int&dx,int lev){ if(sym == IDENT){

enter(VARIABLE,tx,dx,lev);

getsym();} else

error(4);}//vardeclaration end

// 數組說明處理

void PL0::arraydeclaration(int&tx,int&dx,int lev){

int upscript=0,downscript=0;getsym();if(sym == NUMBER || sym == CONSTSYM){

if(num == 0)

{

upscript = num;

getsym();

}

else

error(32);} if(sym == COMMA)

getsym();else

error(32);if(sym == NUMBER || sym == CONSTSYM){

downscript = num;

getsym();} if(sym!= RPAREN)

} error(32);else { enter(ARRAY,tx,dx,downscript+1);getsym();} // 列出目標代碼清單

void PL0::listcode(int cx0)//list code generated for this block { int i;if(listswitch)

for(i= cx0;i

cout<<”“<

<<”“<

// 語句部分處理

void PL0::statement(symset fsys,int tx,int lev){ if(sourceEnd)

return;int i,cx1,cx2;if(sym ==IDENT){

i= position(id,tx);

if(i == 0)

error(11);

else if(table[i].kind!=VARIABLE)

{

error(12);

i= 0;

}

getsym();

if(sym ==BECOMES)

getsym();

else

error(13);

expression(fsys,tx,lev);

if(sym!= SEMICOLON)

error(10);

if(i!= 0)

gen(STO,lev-table[i].other.inOther.level,table[i].other.inOther.adr);

} else if(sym == READSYM){ getsym();if(sym!=LPAREN)

error(34);else

do{

getsym();

if(sym==IDENT)

i=position(id,tx);

else

i=0;

if(i==0)

error(35);

else

{

gen(OPR,0,16);

gen(STO,lev-table[i].other.inOther.level,table[i].other.inOther.adr);

}

getsym();

}while(sym == COMMA);

if(sym!= RPAREN)

{

error(33);

while(fsys.find(sym)!=fsys.end())getsym();

}

else

getsym();} else if(sym == WRITESYM){ getsym();if(sym==LPAREN){

do{

getsym();

symset tmp=fsys;

for(int t=RPAREN;t<=COMMA;t++)

tmp.insert((symbol)t);

expression(tmp,tx,lev);

gen(OPR,0,14);

}while(sym==COMMA);

if(sym!=RPAREN)

error(33);

else

getsym();} gen(OPR,0,15);} else if(sym ==CALLSYM){ getsym();if(sym!=IDENT)

error(14);else {

i= position(id,tx);

if(i == 0)

error(11);

else if(table[i].kind = PROCEDURE)

gen(CAL,lev-table[i].other.inOther.level,table[i].other.inOther.adr);

else

error(15);

getsym();} } else if(sym ==IFSYM){ getsym();symset tmp=fsys;for(int i = THENSYM;i<= DOSYM;i++)

tmp.insert((symbol)i);condition(tmp,tx,lev);if(sym == THENSYM)

getsym();else

error(16);cx1= cx;gen(JPC,0,0);tmp.insert(ELSESYM);statement(tmp,tx,lev);getsym();

code[cx1].a= cx;

if(sym == ELSESYM){

getsym();

cx2=cx;

gen(JMP,0,0);

code[cx1].a=cx;

statement(fsys,tx,lev);

code[cx2].a=cx;} } else if(sym ==BEGINSYM){ getsym();symset tmp=fsys;for(int i=SEMICOLON;i<=ENDSYM;i++)

tmp.insert((symbol)i);statement(tmp,tx,lev);tmp=statbegsys;tmp.insert(SEMICOLON);while(tmp.find(sym)!=tmp.end()){

if(sourceEnd)return;

if(sym ==SEMICOLON||sym ==ENDSYM)

getsym();

else if(sym=PERIOD)

{

error(26);

getsym();

}

else

error(10);

tmp=fsys;

for(i=SEMICOLON;i<=ENDSYM;i++)

tmp.insert((symbol)i);

if(sourceEnd)return;

if(sym==ENDSYM)

break;

statement(tmp,tx,lev);} if(sym ==ENDSYM)

getsym();else if(!sourceEnd)

error(17);} else if(sym ==WHILESYM){ cx1= cx;

// 記下當前代碼分配位置，這是while循環的開始位置

getsym();symset tmp=fsys;tmp.insert(DOSYM);condition(tmp,tx,lev);

cx2= cx;

// 記下當前代碼分配位置，這是while的do中的語句的開始位置

gen(JPC,0,0);

if(sym ==DOSYM)

getsym();

else

error(18);

statement(fsys,tx,lev);

gen(JMP,0,cx1);

code[cx2].a= cx;} else if(sym == REPEATSYM){

symset temp1, temp2;

temp1= fsys,temp1.insert(SEMICOLON),temp1.insert(UNTILSYM);

cx1= cx;

getsym();

statement(temp1,tx,lev);

temp2 = statbegsys;

temp2.insert(SEMICOLON);

while(temp2.find(sym)!= temp2.end())

{

if(sym == SEMICOLON)

getsym();

else

error(34);

statement(temp1,tx,lev);

}

if(sym == UNTILSYM)

{

getsym();

condition(fsys,tx,lev);

gen(JPC,0,cx1);

}

else

error(34);

} symset setT;test(fsys,setT,19);}//statement end

// 表達式處理

void PL0::expression(symset fsys,int tx,int lev){ symbol addop;symset tmp=fsys;for(int t=PLUS;t<=MINUS;t++)

tmp.insert((symbol)t);if(sym>=PLUS&&sym<=MINUS){

addop= sym;

getsym();

term(tmp,tx,lev);

if(addop ==MINUS)

gen(OPR,0,1);} else

term(tmp,tx,lev);while(sym >=PLUS&&sym<=MINUS){

addop= sym;

getsym();

term(tmp,tx,lev);

if(addop ==PLUS)

gen(OPR,0,2);

else

gen(OPR,0,3);} }// expression end

// 項處理

void PL0::term(symset fsys,int tx,int lev){ if(sourceEnd)

return;symbol mulop;symset tmp=fsys;for(int t=TIMES;t<=SLASH;t++)

tmp.insert((symbol)t);factor(tmp,tx,lev);while(sym>=TIMES && sym<=SLASH){

mulop= sym;

getsym();

factor(tmp,tx,lev);

if(mulop ==TIMES)

gen(OPR,0,4);

else

gen(OPR,0,5);} }// term end

// 因子處理

void PL0:: factor(symset fsys,int tx,int lev){ int i;test(facbegsys,fsys,24);while(facbegsys.find(sym)!=facbegsys.end()){

if(sym ==IDENT)

{

i= position(id,tx);

if(i == 0)

error(11);

else

switch(table[i].kind)

{

case CONSTANT:

gen(LIT,0,table[i].other.val);

break;

case VARIABLE:

gen(LOD,lev-table[i].other.inOther.level,table[i].other.inOther.adr);

break;

case PROCEDURE:

error(21);

break;

}

getsym();

}

else if(sym ==NUMBER)

{

if(num>amax)

{

error(31);

num= 0;

}

gen(LIT,0,num);

getsym();

}

else if(sym ==LPAREN)

{

getsym();

symset tmp=fsys;

tmp.insert(RPAREN);

expression(tmp,tx,lev);

if(sym == RPAREN)

getsym();

else

error(22);

}

test(fsys,facbegsys,23);} }//factor end

// 條件處理

void PL0::condition(symset fsys,int tx,int lev){ symbol relop;symset tmp=fsys;tmp.insert(EQL),tmp.insert(NEQ),tmp.insert(LSS),tmp.insert(LEQ),tmp.insert(GTR),tmp.insert(GEQ);

if(sym == ODDSYM){

getsym();

expression(fsys,tx,lev);

gen(OPR,0,6);} else {

expression(tmp,tx,lev);

if(tmp.find(sym)==tmp.end())

error(20);

else

{

relop= sym;

getsym();

expression(fsys,tx,lev);

switch(relop)

{

case EQL: gen(OPR,0,8);

break;

case NEQ: gen(OPR,0,9);

break;

case LSS: gen(OPR,0,10);

break;

case GEQ: gen(OPR,0,11);

break;

case GTR: gen(OPR,0,12);

break;

case LEQ: gen(OPR,0,13);

break;

}

} } }//condition end

// 對目標代碼的解釋執行程序

void PL0::interpret(){ int err1=errorString.size();if(err1>0){

cout<<”存在%d個錯誤:“<

cout<

t= t+1;

s[t]= i.a;

break;case OPR:

switch(i.a)//operator

{ case 0:// return t= b-1;

p= s[t+3];

b= s[t+2];break;case 1: s[t]=-s[t];break;case 2: t= t-1;s[t]= s[t]+s[t+1];break;case 3: t= t-1;s[t]= s[t]-s[t+1];break;case 4: t= t-1;s[t]= s[t]*s[t+1];break;case 5: t= t-1;s[t]= s[t] / s[t+1];break;case 6: if(s[t]%2)

s[t]=1;else

s[t]=0;break;case 8: t= t-1;if(s[t]==s[t+1])

s[t]=1;else

s[t]=0;break;case 9: t= t-1;if(s[t]==s[t+1])

s[t]=0;else

s[t]=1;break;

case 10: t= t-1;if(s[t]

s[t]=1;else

s[t]=0;break;case 11: t= t-1;if(s[t]>=s[t+1])

s[t]= 1;else

s[t]=0;break;case 12: t= t-1;if(s[t]>s[t+1])

s[t]= 1;else

s[t]=0;break;case 13: t= t-1;if(s[t]<=s[t+1])

s[t]= 1;else

s[t]=0;break;case 14: cout<<”“<>s[t];break;};break;case LOD:

t= t+1;

s[t]= s[base(i.l,b,s)+i.a];

break;

case STO:

s[base(i.l,b,s)+i.a]= s[t];

t= t-1;

break;

case CAL:// generate new block mark

s[t+1]= base(i.l,b,s);

s[t+2]= b;

s[t+3]= p;

b= t+1;

p=i.a;

break;

case INT:

t= t+i.a;

break;

case JMP:

p= i.a;

break;

case JPC:

if(s[t] == 0)

p= i.a;

t= t-1;

break;

}//switch end

}while(p!=0);

cout<<” End PL/0n“;} // interpret end

// 通過靜態鏈求出數據區的基地址

int PL0::base(int l,int b,int s[]){ int b1;b1= b;//find base l levels down while(l>0){

b1= s[b1];

l= l-1;} return b1;}

// 保存代碼

void PL0::SaveCode(){ if(fout)

for(int i=0;i

fprintf(fout,”%d %s %d %dn “,i,mnemonic[code[i].f],code[i].l,code[i].a);} TestPL0.cpp代碼： #include ”pl0.h“ void main(){ PL0 cp(”testPas2.txt“,”nasm.txt");

symset fsys;

fsys.insert(PERIOD);fsys.insert(CONSTSYM),fsys.insert(VARSYM),fsys.insert(PROCSYM);fsys.insert(BEGINSYM),fsys.insert(CALLSYM),fsys.insert(IFSYM),fsys.insert(WHILESYM);cp.getsym();

// 詞法分析，分析一個詞

cp.block(0,0,fsys);

// 分程序分析處理功能

cp.SaveCode();

// 保存代碼

cp.interpret();

// 對目標代碼的解釋執行程序

} 實驗運行結果：

運行的的文件見下圖右側：實驗中我是固定了文件名的，可以是改寫成動態輸入，由于在測試中我把所有的測試語句都放在同一個文件中了，沒有太多的必要。

六、心得體會

在編譯程序實現的過程中反復使用了遞歸調用的思想，且也使用了模塊化處理問題的思想，使用模塊化的思想關鍵是在抽象階段要抽象出對應的模塊，且模塊的層次必須是清晰的。

在實現此程序中，由于要實現關鍵字和符號表中字段的搜索，實現中就必須注意快速查找的方法，而在實現的過程中多次用到了二分搜索的方法，這是個比較快的搜索方法。

由于此程序的實現相對比較復雜，且不方便調試，改進時可以把此程序的詞法分析，語法分析和執行原代碼作為單獨的測試程序來測試，這樣也方便大家來調試。

通過本次的課設我知道了一個算法的設計是需要靜下心來仔細的研究的，且實現中必須先了解程序的整個流程，也就是說在編程中首先必須看懂那些對應的UML圖，只有在圖的指導下，編程中才不會盲目，也有一定的方向性。同樣在編程中必須注意代碼的規范，多寫一些對應的注釋是很必要的，要時刻想這代碼并不是給你自己看的，而是必須要給別人看，因此我覺得代碼的規范是相當重要的。