प्रतीक तालिका कैसे बनाएं

Question

हमारे पास एक कंपाइलर बनाने के लिए असाइनमेंट के रूप में है। हमने पहले से ही व्याख्यात्मक और वाक्यविन्यास विश्लेषण किया है लेकिन हम मध्यवर्ती कोड की पीढ़ी पर फंस गए हैं। हमने महसूस किया कि हमें इंटरमीडिएट कोड पीढ़ी के लिए आगे बढ़ने के लिए एक प्रतीक तालिका लागू करनी है और हम नहीं जानते कि यह कैसे करें और इसमें क्या शामिल है।

नीचे दिए गए कोड को देखते हुए, प्रतीक तालिका में क्या होना चाहिए? (कोड एक शैक्षिक भाषा में लिखा गया है जो नीचे वर्णित है)

इसके अलावा हम अपनी प्रतीक तालिका में स्कॉप्स कैसे कार्यान्वित कर सकते हैं?

<PROGRAM> ::= PROGRAM ID <BLOCK> ENDPROGRAM 
<BLOCK> ::= {<DECLARATIONS> <SUBPROGRAMS> <SEQUENCE>} 
<DECLARATIONS> ::= ε | DECLARE <VARLIST> ENDDECLARE 
<VARLIST> ::= ε | ID (, ID)* 
<SUBPROGRAMS> ::= (<PROCORFUNC>) * 
<PROCORFUNC> ::= PROCEDURE ID <PROCORFUNCBODY> ENDPROCEDURE | 
FUNCTION ID <PROCORFUNCBODY> ENDFUNCTION 
<PROCORFUNCBODY> ::= <FORMALPARS> <BLOCK> 
<FORMALPARS> ::= ε | (<FORMALPARLIST>) 
<FORMALPARLIST> ::= <FORMALPARITEM> (, <FORMALPARITEM>)* 
<FORMALPARITEM> ::= IN ID | INOUT ID 
<SEQUENCE> ::= <STATEMENT> (; <STATEMENT>)* 
<STATEMENT> ::= ε | <ASSIGNMENT-STAT> | 
<IF-STAT> | 
<WHILE-STAT> | 
<FOR-STAT> | 
<EXIT-STAT> | 
<CALL-STAT> | 
<RETURN-STAT> 
<ASSIGNMENT-STAT> ::= ID := <EXPRESSION> 
<IF-STAT> ::= IF <CONDITION> THEN <SEQUENCE> <ELSEPART> ENDIF 
<ELSEPART> ::= ε | ELSE <SEQUENCE> 
<WHILE-STAT> ::= DO {<SEQUENCE>} WHILE (<CONDITION>) 
<FOR-STAT> ::= (<ASSIGNMENT-STAT>; <CONDITION>;<ASSIGNMENT-STAT>;) 
{<SEQUENCE>} 
<EXIT-STAT> ::= EXIT 
<CALL-STAT> ::= CALL ID <ACTUALPARS> 
<ACTUALPARS> ::= (<ACTUALPARLIST>) | ε 
<ACTUALPARLIST> ::= <ACTUALPARITEM> (, <ACTUALPARITEM>)* 
<ACTUALPARITEM> ::= IN <EXPRESSION> | INOUT ID 
<RETURN-STAT> ::= RETURN <EXPRESSION> 
<CONDITION> ::= <BOOLTERM> (OR <BOOLTERM>)* 
<BOOLTERM> ::= <BOOLFACTOR> (AND <BOOLFACTOR>)* 
<BOOLFACTOR> ::= NOT [<CONDITION>] | [<CONDITION>] | 
<EXPRESSION> <RELATIONAL-OPER> <EXPRESSION> | 
TRUE | FALSE 
<EXPRESSION> ::= <OPTIONAL-SIGN> <TERM> (<ADD-OPER> <TERM>)* 
<TERM> ::= <FACTOR> (<MUL-OPER> <FACTOR>)* 
<FACTOR> ::= CONSTANT | (<EXPRESSION>) | ID <IDTAIL> 
<IDTAIL> ::= ε | <ACTUALPARS> 
<RELATIONAL-OPER> ::= = | < (ε | = | >) | > (ε | =) 
<ADD-OPER> ::= + | - 
<MUL-OPER> ::= * |/
<OPTIONAL-SIGN> ::= ε | <ADD-OPER> 

PROGRAM MULTIPLY 
    { 
    DECLARE 
    A, B, C 
    ENDDECLARE 
    PROCEDURE Aop(INOUT A) 
    { 
     A=A+1; 
    } 
    ENDPROCEDURE 
    FUNCTION Bop(IN B){ 
     IF [NOT[[TRUE AND FALSE]OR[TRUE]]] THEN B := 100/2; 
     ELSE B := 100; 
     ENDIF; 
     RETURN B; 
     } 
    ENDFUNCTION 
    CALL Aop(INOUT A); 
    CALL Bop(IN B); 
    A := 40; 
    C := A * B; 
    } 
ENDPROGRAM 

Answer 1

एक प्रतीक तालिका में इस तरह के अपने प्रतीक प्रकार (स्थानीय चर/पैरामीटर/समारोह/वर्ग आदि) के रूप में उस पहचानकर्ता, के बारे में जानकारी के लिए पहचानकर्ता (आम तौर पर एक गुंजाइश नाम दिया) नक्शे , डेटा प्रकार, एक ही दायरे में अन्य पहचानकर्ताओं के सापेक्ष इसका ऑर्डर, इसकी स्रोत कोड लाइन इत्यादि। प्रतीक तालिका को सारणी वाक्यविन्यास पेड़ को घुमाने के द्वारा उत्पन्न किया जा सकता है, हमेशा ट्रैक करके कि आप किस क्षेत्र में हैं और जानकारी जोड़ रहे हैं जब भी आप एक परिवर्तनीय घोषणा मारा जाता है तो प्रतीक तालिका में। अपने उदाहरण में, प्रतीक तालिका का एक हिस्सा इस (प्रतीक प्रकार, डेटा प्रकार, स्थिति, और स्रोत कोड लाइन के लिए मैपिंग) दिखाई देंगे:

MULTIPLY.A -> {"LOCAL", "INT", 0, 4} 
MULTIPLY.B -> {"LOCAL", "INT", 1, 4} 
MULTIPLY.C -> {"LOCAL", "INT", 2, 4} 
MULTIPLY.Aop -> {"FUNCTION", "INT", 3, 4} 
MULTIPLY.Aop.A -> {"INOUTPARAM", "INT", 0, 6} 

अब, आप सभी वैरिएबल संदर्भ को हल कर सकते हैं। उदाहरण के लिए, A := A + 1 अभिव्यक्ति में, यदि आप जानते हैं कि आपका वर्तमान दायरा MULTIPLY.Aop है, तो symnbol तालिका आपको यह बताएगी कि यह AINT प्रकार का इनपुट/आउटपुट पैरामीटर है, और यह पहला पैरामीटर है (यह जानकारी होगी आपको एक स्टैक पता ऑफ़सेट उत्पन्न करने दें ताकि आप चर को लोड/स्टोर कर सकें)।