daily pastebin goal
72%
SHARE
TWEET

Untitled

a guest Nov 18th, 2017 49 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7.  
  8. namespace Lab_Final
  9. {
  10.     struct tws
  11.     {
  12.         public string Type;
  13.         public string Word;
  14.         public string Scope;
  15.  
  16.         public tws(string t, string w, string s)
  17.         {
  18.             Type = t;
  19.             Word = w;
  20.             Scope = s;
  21.         }
  22.     }
  23.     struct FourTuple
  24.     {
  25.         public string Opcode;
  26.         public string Left;
  27.         public string Right;
  28.         public string Temp;
  29.  
  30.         public FourTuple(string o, string l, string r, string t)
  31.         {
  32.             Opcode = o;
  33.             Left = l;
  34.             Right = r;
  35.             Temp = t;
  36.         }
  37.     }
  38.     struct CodeGen
  39.     {
  40.         public string Line;
  41.         public string Operator1;
  42.         public string Operator2;
  43.         public string Result;
  44.  
  45.         public CodeGen(string l, string Op1, string Op2, string Res)
  46.         {
  47.             Line = l;
  48.             Operator1 = Op1;
  49.             Operator2 = Op2;
  50.             Result = Res;
  51.         }
  52.     }
  53.     struct LabelTable
  54.     {
  55.         public string Lable;
  56.         public int Line;
  57.         public LabelTable(string LBL, int L)
  58.         {
  59.             Lable = LBL;
  60.             Line = L;
  61.         }
  62.     }
  63.     class Parser
  64.     {
  65.         public static wt token;
  66.         public static int i = 0;
  67.         public static string SBWord = "";
  68.         public static string SScope = "";
  69.         public static string SBTWord = "";
  70.         public static string SBFun = "";
  71.         public static string SBCTWord = "";
  72.         public static string SBGTWord = "";
  73.         public static int iTemp = 0;
  74.         public static int indexTemp = 0;
  75.         public static int iLBLTemp = 0;
  76.         public static string SFWord = "";
  77.         public static string SBPFun = "";
  78.         public static string SBPTFun = "";
  79.         public static string SBPWFun = "";
  80.         public static string SBPCall = "";
  81.         public static string SBPTCall = "";
  82.  
  83.         public static ArrayList LParser = Lexical.ALLex;
  84.         public static ArrayList LDupDec = new ArrayList();
  85.         public static ArrayList LGlobal = new ArrayList();
  86.         public static ArrayList LLocal = new ArrayList();
  87.         public static ArrayList LFun = new ArrayList();
  88.         public static ArrayList LTWord = new ArrayList(); // Check Type
  89.         public static ArrayList LPFun = new ArrayList();
  90.         public static ArrayList LPCall = new ArrayList();
  91.         public static ArrayList LTPWord = new ArrayList(); // Check Type Parametor
  92.  
  93.         public static ArrayList LInfix = new ArrayList();
  94.         public static ArrayList LPostfix = new ArrayList();
  95.         public static ArrayList L4Tuple = new ArrayList();
  96.         public static ArrayList LTemp = new ArrayList();
  97.         public static ArrayList LInter = new ArrayList();
  98.         public static ArrayList LCode = new ArrayList();
  99.         public static ArrayList LLBL = new ArrayList();
  100.  
  101.         public static void S()
  102.         {
  103.             Read_Token();
  104.             if (token.Word == "Program")
  105.             {
  106.                 Match_Word(token, "Program");
  107.                 Match_Type(token, "ID");
  108.                 Match_Word(token, ";");
  109.  
  110.                 SScope = "Global";
  111.                 T();
  112.                 F();
  113.                 Code_Genarator();
  114.             }
  115.             else if (token.Word == "$")
  116.             {
  117.  
  118.             }
  119.             else
  120.             {
  121.                 Console.WriteLine(" >> Error S");
  122.             }
  123.         }
  124.         public static void F()
  125.         {
  126.             if (token.Word == "fun")
  127.             {
  128.                 F1();
  129.                 F();
  130.             }
  131.             else if (token.Word == "$")
  132.             {
  133.  
  134.             }
  135.             else
  136.             {
  137.                 Console.WriteLine(" >> Error F");
  138.             }
  139.         }
  140.         public static void F1()
  141.         {
  142.             if (token.Word == "fun")
  143.             {
  144.                 Match_Word(token, "fun");
  145.  
  146.                 SBFun = token.Word;
  147.                 if (Check_Func(SBFun))
  148.                 {
  149.  
  150.                 }
  151.                 else
  152.                 {
  153.                     LFun.Add(new tws("    ", SBFun, "Function"));
  154.                 }
  155.  
  156.                 SBPFun = token.Word;
  157.  
  158.                 Match_Type(token, "ID");
  159.                 Match_Word(token, "(");
  160.                 T2();
  161.                 Match_Word(token, ")");
  162.                 Match_Word(token, "begin");
  163.  
  164.                 SScope = "Local";
  165.                 T();
  166.                 A();
  167.                 Match_Word(token, "end");
  168.             }
  169.             else
  170.             {
  171.                 Console.WriteLine(" >> Error F1");
  172.             }
  173.         }
  174.         public static void T()
  175.         {
  176.             if (token.Word == "int")
  177.             {
  178.                 SBTWord = token.Word;
  179.                 Match_Word(token, "int");
  180.  
  181.                 SBWord = token.Word;
  182.                 if (Check_Dup(SBWord, SScope))
  183.                 {
  184.                     Console.WriteLine("\t" + token.Word + " <<< Duplicate");
  185.                 }
  186.                 else
  187.                 {
  188.                     if (SScope == "Global")
  189.                     {
  190.                         LDupDec.Add(new tws(SBTWord, SBWord, SScope));
  191.                         LGlobal.Add(new tws(SBTWord, SBWord, SScope));
  192.                     }
  193.                     else
  194.                     {
  195.                         LDupDec.Add(new tws(SBTWord, SBWord, SScope));
  196.                         LLocal.Add(new tws(SBTWord, SBWord, SScope));
  197.                     }
  198.                 }
  199.  
  200.                 Match_Type(token, "ID");
  201.                 T1();
  202.                 Match_Word(token, ";");
  203.                 T();
  204.             }
  205.             else if (token.Word == "float")
  206.             {
  207.                 SBTWord = token.Word;
  208.                 Match_Word(token, "float");
  209.  
  210.                 SBWord = token.Word;
  211.                 if (Check_Dup(SBWord, SScope))
  212.                 {
  213.                     Console.WriteLine("\t" + token.Word + " <<< Duplicate");
  214.                 }
  215.                 else
  216.                 {
  217.                     if (SScope == "Global")
  218.                     {
  219.                         LDupDec.Add(new tws(SBTWord, SBWord, SScope));
  220.                         LGlobal.Add(new tws(SBTWord, SBWord, SScope));
  221.                     }
  222.                     else
  223.                     {
  224.                         LDupDec.Add(new tws(SBTWord, SBWord, SScope));
  225.                         LLocal.Add(new tws(SBTWord, SBWord, SScope));
  226.                     }
  227.                 }
  228.  
  229.                 Match_Type(token, "ID");
  230.                 T1();
  231.                 Match_Word(token, ";");
  232.                 T();
  233.             }
  234.             else if (token.Word == "string")
  235.             {
  236.                 SBTWord = token.Word;
  237.                 Match_Word(token, "string");
  238.  
  239.                 SBWord = token.Word;
  240.                 if (Check_Dup(SBWord, SScope))
  241.                 {
  242.                     Console.WriteLine("\t" + token.Word + " <<< Duplicate");
  243.                 }
  244.                 else
  245.                 {
  246.                     if (SScope == "Global")
  247.                     {
  248.                         LDupDec.Add(new tws(SBTWord, SBWord, SScope));
  249.                         LGlobal.Add(new tws(SBTWord, SBWord, SScope));
  250.                     }
  251.                     else
  252.                     {
  253.                         LDupDec.Add(new tws(SBTWord, SBWord, SScope));
  254.                         LLocal.Add(new tws(SBTWord, SBWord, SScope));
  255.                     }
  256.                 }
  257.  
  258.                 Match_Type(token, "ID");
  259.                 T1();
  260.                 Match_Word(token, ";");
  261.                 T();
  262.             }
  263.             else if ((token.Word == "fun") || (token.Word == ")") || (token.Word == "while") || (token.Word == "ID") || (token.Word == "call") || (token.Word == ","))
  264.             {
  265.  
  266.             }
  267.             else
  268.             {
  269.                 Console.WriteLine(" >> Error T");
  270.             }
  271.         }
  272.         public static void T1()
  273.         {
  274.             if (token.Word == ",")
  275.             {
  276.                 Match_Word(token, ",");
  277.  
  278.                 SBWord = token.Word;
  279.                 if (Check_Dup(SBWord, SScope))
  280.                 {
  281.                     Console.WriteLine("\t" + token.Word + " <<< Duplicate");
  282.                 }
  283.                 else
  284.                 {
  285.                     if (SScope == "Global")
  286.                     {
  287.                         LDupDec.Add(new tws(SBTWord, SBWord, SScope));
  288.                         LGlobal.Add(new tws(SBTWord, SBWord, SScope));
  289.                     }
  290.                     else
  291.                     {
  292.                         LDupDec.Add(new tws(SBTWord, SBWord, SScope));
  293.                         LLocal.Add(new tws(SBTWord, SBWord, SScope));
  294.                     }
  295.                 }
  296.  
  297.                 Match_Type(token, "ID");
  298.                 T1();
  299.             }
  300.             else if ((token.Word == ";"))
  301.             {
  302.  
  303.             }
  304.             else
  305.             {
  306.                 Console.WriteLine(" >> Error T2");
  307.             }
  308.         }
  309.         public static void T2()
  310.         {
  311.             if (token.Word == "int")
  312.             {
  313.                 SBPTFun = token.Word;
  314.                 Match_Word(token, "int");
  315.                 SBPWFun = token.Word;
  316.                 Match_Type(token, "ID");
  317.  
  318.                 LDupDec.Add(new tws(SBPTFun, SBPWFun, SBPFun));
  319.                 LPFun.Add(new tws(SBPTFun, SBPWFun, SBPFun));
  320.                 T3();
  321.             }
  322.             else if (token.Word == "float")
  323.             {
  324.                 SBPTFun = token.Word;
  325.                 Match_Word(token, "float");
  326.                 SBPWFun = token.Word;
  327.                 Match_Type(token, "ID");
  328.  
  329.                 LDupDec.Add(new tws(SBPTFun, SBPWFun, SBPFun));
  330.                 LPFun.Add(new tws(SBPTFun, SBPWFun, SBPFun));
  331.                 T3();
  332.             }
  333.             else if (token.Word == "string")
  334.             {
  335.                 SBPTFun = token.Word;
  336.                 Match_Word(token, "string");
  337.                 SBPWFun = token.Word;
  338.                 Match_Type(token, "ID");
  339.  
  340.                 LDupDec.Add(new tws(SBPTFun, SBPWFun, SBPFun));
  341.                 LPFun.Add(new tws(SBPTFun, SBPWFun, SBPFun));
  342.                 T3();
  343.             }
  344.             else if (token.Word == ")")
  345.             {
  346.  
  347.             }
  348.             else
  349.             {
  350.                 Console.WriteLine(" >> Error T1");
  351.             }
  352.         }
  353.         public static void T3()
  354.         {
  355.             if (token.Word == ",")
  356.             {
  357.                 Match_Word(token, ",");
  358.                 T2();
  359.             }
  360.             else if ((token.Word == "int") || (token.Word == "float") || (token.Word == "string") || (token.Word == ")"))
  361.             {
  362.  
  363.             }
  364.             else
  365.             {
  366.                 Console.WriteLine(" >> Error T2");
  367.             }
  368.         }
  369.         public static void A()
  370.         {
  371.             if (token.Word == "while")
  372.             {
  373.                 W();
  374.                 A();
  375.             }
  376.             else if (token.Type == "ID")
  377.             {
  378.                 SBWord = token.Word;
  379.                 if (Check_Dec(SBWord))
  380.                 {
  381.  
  382.                 }
  383.                 else
  384.                 {
  385.                     Console.WriteLine("\t" + token.Word + " <<< Undeclare");
  386.                 }
  387.  
  388.                 LTWord.Clear();
  389.                 SBCTWord = token.Word;
  390.                 SBGTWord = Get_Type(SBCTWord);
  391.                 LTWord.Add(SBGTWord);
  392.                 //if (Check_Type(SBGTWord))
  393.                 //{
  394.  
  395.                 //}
  396.                 //else
  397.                 //{
  398.                 //    Console.WriteLine(" " + token.Word + " >>> Type Error");
  399.                 //}
  400.  
  401.                 LInfix.Add(token);
  402.  
  403.                 //SBTWord = token.Type;
  404.                 //SBGTWord = Get_Type(SBTWord);
  405.                 //LTWord.Add(SBGTWord);
  406.  
  407.  
  408.                 Match_Type(token, "ID");
  409.                 LInfix.Add(token);
  410.                 Match_Word(token, "=");
  411.  
  412.                 I();
  413.                 E();
  414.  
  415.                 //LTWord.Clear();
  416.  
  417.                 InfixToPostfix(LInfix);
  418.                 PostfixTo4Tuple(LPostfix);
  419.                 Add_Intermediate(L4Tuple);
  420.  
  421.                 //FourTuple L4TP1 = new FourTuple();
  422.                 //L4TP1.Opcode = "LBL";
  423.                 //L4TP1.Left = "_";
  424.                 //L4TP1.Right = "_";
  425.                 //L4TP1.Temp = "T" + iTemp;
  426.                 //L4Tuple.Add(L4TP1);
  427.                 //iTemp++;
  428.  
  429.                 LInfix.Clear();
  430.                 LPostfix.Clear();
  431.                 L4Tuple.Clear();
  432.  
  433.  
  434.                 Match_Word(token, ";");
  435.                 A();
  436.             }
  437.             else if (token.Word == "call")
  438.             {
  439.                 Match_Word(token, "call");
  440.  
  441.                 LPCall.Clear();
  442.                 SBPCall = token.Word;
  443.                 SBFun = token.Word;
  444.                 if (Check_Func(SBFun))
  445.                 {
  446.  
  447.                 }
  448.                 else
  449.                 {
  450.                     Console.WriteLine("\t" + token.Word + " <<< Undeclare Funcion");
  451.                 }
  452.  
  453.                 SFWord = token.Word;
  454.                 Match_Type(token, "ID");
  455.                 FourTuple L4TP5 = new FourTuple();
  456.                 L4TP5.Opcode = "CALL";
  457.                 L4TP5.Left = "_";
  458.                 L4TP5.Right = "_";
  459.                 L4TP5.Temp = SFWord;
  460.                 LInter.Add(L4TP5);
  461.  
  462.                 Match_Word(token, "(");
  463.                 P();
  464.                 if (Check_Parametor(SFWord, SBPTCall))
  465.                 {
  466.  
  467.                 }
  468.                 else
  469.                 {
  470.                     Console.WriteLine(" " + " >> Parametor Error");
  471.                 }
  472.                 Match_Word(token, ")");
  473.                 A();
  474.             }
  475.             else if (token.Word == "end")
  476.             {
  477.  
  478.             }
  479.             else
  480.             {
  481.                 Console.WriteLine(" >> Error A");
  482.             }
  483.         }
  484.         public static void W()
  485.         {
  486.             if (token.Word == "while")
  487.             {
  488.                 Match_Word(token, "while");
  489.  
  490.                 Match_Word(token, "(");
  491.  
  492.                 FourTuple L4TP1 = new FourTuple();
  493.                 L4TP1.Opcode = "LBL";
  494.                 L4TP1.Left = "_";
  495.                 L4TP1.Right = "_";
  496.                 L4TP1.Temp = "L" + iLBLTemp;
  497.                 iLBLTemp++;
  498.                 LInter.Add(L4TP1);
  499.  
  500.                 R();
  501.  
  502.                 InfixToPostfix(LInfix);
  503.                 PostfixTo4Tuple(LPostfix);
  504.  
  505.                 FourTuple L4TP2 = new FourTuple();
  506.                 L4TP2.Opcode = "_";
  507.                 L4TP2.Left = "_";
  508.                 L4TP2.Right = "_";
  509.                 L4TP2.Temp = "T" + iTemp;
  510.                 Add_Intermediate(L4Tuple);
  511.  
  512.                 FourTuple L4TP3 = new FourTuple();
  513.                 L4TP3.Opcode = "JMPF";
  514.                 L4TP3.Left = L4TP2.Temp;
  515.                 L4TP3.Right = "_";
  516.                 L4TP3.Temp = "L" + iLBLTemp;
  517.                 LInter.Add(L4TP3);
  518.  
  519.                 LInfix.Clear();
  520.                 LPostfix.Clear();
  521.                 L4Tuple.Clear();
  522.  
  523.                 Match_Word(token, ")");
  524.                 Match_Word(token, "begin");
  525.                 A();
  526.  
  527.                 Match_Word(token, "end");
  528.  
  529.                 FourTuple L4TP4 = new FourTuple();
  530.                 L4TP4.Opcode = "LBL";
  531.                 L4TP4.Left = "_";
  532.                 L4TP4.Right = "_";
  533.                 L4TP4.Temp = "L" + iLBLTemp;
  534.                 LInter.Add(L4TP4);
  535.  
  536.             }
  537.             else if (token.Word == "while")
  538.             {
  539.  
  540.             }
  541.             else
  542.             {
  543.                 Console.WriteLine(" >> Error W");
  544.             }
  545.         }
  546.         public static void I()
  547.         {
  548.             if (token.Type == "ID")
  549.             {
  550.                 SBPTCall = token.Type;
  551.                 //LPCall.Add(new tws(" ", SBPTCall, SBPCall));
  552.  
  553.                 SBWord = token.Word;
  554.                 if (Check_Dec(SBWord))
  555.                 {
  556.  
  557.                 }
  558.                 else
  559.                 {
  560.                     Console.WriteLine("\t" + token.Word + " <<< Undeclare");
  561.                 }
  562.  
  563.                 SBCTWord = token.Word;
  564.                 SBGTWord = Get_Type(SBCTWord);
  565.                 if (Check_Type(SBGTWord))
  566.                 {
  567.  
  568.                 }
  569.                 else
  570.                 {
  571.                     Console.WriteLine(" " + token.Word + " >>> Type Error");
  572.                 }
  573.  
  574.                 LInfix.Add(token);
  575.  
  576.                 Match_Type(token, "ID");
  577.             }
  578.             else if (token.Type == "int_const")
  579.             {
  580.                 SBPTCall = token.Type;
  581.                 //LPCall.Add(new tws(" ", SBPTCall, SBPCall));
  582.  
  583.                 if (Check_Type(token.Type))
  584.                 {
  585.  
  586.                 }
  587.                 else
  588.                 {
  589.                     Console.WriteLine(" " + token.Word + " >>> Type Error");
  590.                 }
  591.  
  592.                 LInfix.Add(token);
  593.  
  594.                 Match_Type(token, "int_const");
  595.             }
  596.             else if (token.Type == "float_const")
  597.             {
  598.                 SBPTCall = token.Type;
  599.                 //LPCall.Add(new tws(" ", SBPTCall, SBPCall));
  600.  
  601.                 if (Check_Type(token.Type))
  602.                 {
  603.  
  604.                 }
  605.                 else
  606.                 {
  607.                     Console.WriteLine(" " + token.Word + " >>> Type Error");
  608.                 }
  609.  
  610.                 LInfix.Add(token);
  611.  
  612.                 Match_Type(token, "float_const");
  613.             }
  614.             else if (token.Type == "string_const")
  615.             {
  616.                 SBPTCall = token.Type;
  617.                 //LPCall.Add(new tws(" ", SBPTCall, SBPCall));
  618.  
  619.                 if (Check_Type(token.Type))
  620.                 {
  621.  
  622.                 }
  623.                 else
  624.                 {
  625.                     Console.WriteLine(" " + token.Word + " >>> Type Error");
  626.                 }
  627.  
  628.                 LInfix.Add(token);
  629.  
  630.  
  631.  
  632.                 Match_Type(token, "string_const");
  633.             }
  634.             else
  635.             {
  636.                 Console.WriteLine(" >> Error I");
  637.             }
  638.         }
  639.         public static void E()
  640.         {
  641.             if (token.Word == "+")
  642.             {
  643.                 LInfix.Add(token);
  644.                 Match_Word(token, "+");
  645.                 I();
  646.                 E();
  647.             }
  648.             else if (token.Word == "-")
  649.             {
  650.                 LInfix.Add(token);
  651.                 Match_Word(token, "-");
  652.                 I();
  653.                 E();
  654.             }
  655.             else if (token.Word == "*")
  656.             {
  657.                 LInfix.Add(token);
  658.                 Match_Word(token, "*");
  659.                 I();
  660.                 E();
  661.             }
  662.             else if (token.Word == "/")
  663.             {
  664.                 LInfix.Add(token);
  665.                 Match_Word(token, "/");
  666.                 I();
  667.                 E();
  668.             }
  669.             else if ((token.Word == ";") || (token.Word == ")") || (token.Word == ">") || (token.Word == ">=") || (token.Word == "<") || (token.Word == "<=") || (token.Word == ",") || (token.Word == "&&") || (token.Word == "||") || (token.Word == "==") || (token.Word == "!="))
  670.             {
  671.  
  672.             }
  673.             else
  674.             {
  675.                 Console.WriteLine(" >> Error E");
  676.             }
  677.         }
  678.         public static void O()
  679.         {
  680.             if (token.Word == ">")
  681.             {
  682.                 LInfix.Add(token);
  683.                 Match_Word(token, ">");
  684.             }
  685.             else if (token.Word == ">=")
  686.             {
  687.                 LInfix.Add(token);
  688.                 Match_Word(token, ">=");
  689.             }
  690.             else if (token.Word == "<")
  691.             {
  692.                 LInfix.Add(token);
  693.                 Match_Word(token, "<");
  694.             }
  695.             else if (token.Word == "<=")
  696.             {
  697.                 LInfix.Add(token);
  698.                 Match_Word(token, "<=");
  699.             }
  700.             else if ((token.Word == "ID") || (token.Word == "int_const") || (token.Word == "float_const") || (token.Word == "string_const") || (token.Word == "==") || (token.Word == "!=") || (token.Word == "&&") || (token.Word == "||") || (token.Word == ")"))
  701.             {
  702.  
  703.             }
  704.             else
  705.             {
  706.                 Console.WriteLine(" >> Error E");
  707.             }
  708.         }
  709.         public static void P()
  710.         {
  711.             string pm = "";
  712.             if ((token.Type == "ID") || (token.Type == "int_const") || (token.Type == "float_const") || (token.Type == "string_const"))
  713.             {
  714.                 if (token.Type == "ID")
  715.                 {
  716.                     LTWord.Clear();
  717.                     pm = token.Word;
  718.                     SBTWord = token.Word;
  719.                     SBGTWord = Get_Type(SBTWord);
  720.                     LTWord.Add(SBGTWord);
  721.                     LTPWord.Add(SBGTWord);
  722.                 }
  723.                 else
  724.                 {
  725.                     LTWord.Clear();
  726.                     pm = token.Word;
  727.                     LTWord.Add(token.Type);
  728.                     LTPWord.Add(token.Type);
  729.                 }
  730.  
  731.                 //if (token.Type == "ID")
  732.                 //{
  733.                 //    SBTWord = token.Type;
  734.                 //    SBGTWord = Get_Type(SBTWord);
  735.                 //    LTWord.Add(SBGTWord);
  736.                 //}
  737.                 //else
  738.                 //{
  739.                 //    LTWord.Add(token.Type);
  740.                 //}
  741.  
  742.                 //if (Check_Parametor())
  743.                 //{
  744.  
  745.                 //}
  746.                 //else
  747.                 //{
  748.                 //    Console.WriteLine(" " + token.Type + " >> Parametor Error");
  749.                 //}
  750.  
  751.                 I();
  752.                 E();
  753.                 //LTWord.Clear();
  754.  
  755.                 if (LInfix.Count <= 1)
  756.                 {
  757.  
  758.                 }
  759.                 else
  760.                 {
  761.                     InfixToPostfix(LInfix);
  762.                     pm = PostfixTo4Tuple(LPostfix);
  763.                     Add_Intermediate(L4Tuple);
  764.                 }
  765.  
  766.                 FourTuple L4TP6 = new FourTuple();
  767.                 L4TP6.Opcode = "ARG";
  768.                 L4TP6.Left = "_";
  769.                 L4TP6.Right = "_";
  770.                 L4TP6.Temp = pm;
  771.                 LInter.Add(L4TP6);
  772.  
  773.                 LInfix.Clear();
  774.                 LPostfix.Clear();
  775.                 L4Tuple.Clear();
  776.                 LPCall.Add(new tws(SBPTCall, " ", SBPCall));
  777.                 P1();
  778.             }
  779.             else if ((token.Word == ",") || (token.Word == ")"))
  780.             {
  781.  
  782.             }
  783.             else
  784.             {
  785.                 Console.WriteLine(" >> Error P");
  786.             }
  787.         }
  788.         public static void P1()
  789.         {
  790.             if (token.Word == ",")
  791.             {
  792.                 Match_Word(token, ",");
  793.                 LTWord.Clear();
  794.                 P();
  795.             }
  796.             else if (token.Word == ")")
  797.             {
  798.  
  799.             }
  800.             else
  801.             {
  802.                 Console.WriteLine(" >> Error P1");
  803.             }
  804.         }
  805.         public static void R()
  806.         {
  807.             if (token.Word == "!")
  808.             {
  809.                 M();
  810.                 R();
  811.             }
  812.             else if ((token.Type == "ID") || (token.Type == "int_const") || (token.Type == "float_const") || (token.Type == "string_const"))
  813.             {
  814.                 R1();
  815.                 R();
  816.             }
  817.             else if (token.Word == ")")
  818.             {
  819.  
  820.             }
  821.             else
  822.             {
  823.                 Console.WriteLine(" >> Error R");
  824.             }
  825.         }
  826.         public static void M()
  827.         {
  828.             if (token.Word == "!")
  829.             {
  830.                 Match_Word(token, "!");
  831.                 R1();
  832.                 O();
  833.                 M();
  834.             }
  835.             else if (token.Word == ")")
  836.             {
  837.  
  838.             }
  839.             else
  840.             {
  841.                 Console.Write(" >> Error M");
  842.             }
  843.         }
  844.         public static void R1()
  845.         {
  846.             if ((token.Type == "ID") || (token.Type == "int_const") || (token.Type == "float_const") || (token.Type == "string_const"))
  847.             {
  848.                 if (token.Type == "ID")
  849.                 {
  850.                     SBTWord = token.Type;
  851.                     SBGTWord = Get_Type(SBTWord);
  852.                     LTWord.Add(SBGTWord);
  853.                 }
  854.                 else
  855.                 {
  856.                     LTWord.Clear();
  857.                     LTWord.Add(token.Type);
  858.                 }
  859.  
  860.  
  861.  
  862.                 I();
  863.                 E();
  864.                 O();
  865.                 R1();
  866.             }
  867.             else if ((token.Word == "&&") || (token.Word == "||") || (token.Word == "==") || (token.Word == "!="))
  868.             {
  869.                 O1();
  870.                 R1();
  871.             }
  872.             else if (token.Word == ")")
  873.             {
  874.  
  875.             }
  876.             else
  877.             {
  878.                 Console.WriteLine(" >> Error R1");
  879.             }
  880.         }
  881.         public static void O1()
  882.         {
  883.             if (token.Word == "&&")
  884.             {
  885.                 Match_Word(token, "&&");
  886.             }
  887.             else if (token.Word == "||")
  888.             {
  889.                 Match_Word(token, "||");
  890.             }
  891.             else if (token.Word == "==")
  892.             {
  893.                 Match_Word(token, "==");
  894.             }
  895.             else if (token.Word == "!=")
  896.             {
  897.                 Match_Word(token, "!=");
  898.             }
  899.             else
  900.             {
  901.                 Console.WriteLine(" >> Error O1");
  902.             }
  903.         }
  904.         public static void Match_Word(wt p, string s)
  905.         {
  906.             if (p.Word == s)
  907.             {
  908.                 Console.WriteLine("\t" + p.Word + "\t" + p.Type + " <<< Match Word");
  909.             }
  910.             else
  911.             {
  912.                 Console.WriteLine("\t" + p.Word + "\t" + p.Type + " <<< Word Error");
  913.             }
  914.             Read_Token();
  915.         }
  916.         public static void Match_Type(wt p, string s)
  917.         {
  918.             if (p.Type == s)
  919.             {
  920.                 Console.WriteLine("\t" + p.Word + "\t" + p.Type + " <<< Match Type");
  921.             }
  922.             else
  923.             {
  924.                 Console.WriteLine("\t" + p.Word + "\t" + p.Type + " <<< Type Error");
  925.             }
  926.             Read_Token();
  927.         }
  928.         public static void Read_Token()
  929.         {
  930.             token = (wt)LParser[i++];
  931.         }
  932.         public static bool Check_Dup(string VDup, string Scope)
  933.         {
  934.             foreach (tws tk in LDupDec)
  935.             {
  936.                 if (tk.Word == VDup)
  937.                 {
  938.                     return true;
  939.                 }
  940.             }
  941.             return false;
  942.         }
  943.         public static bool Check_Dec(string VDec)
  944.         {
  945.             foreach (tws tk in LDupDec)
  946.             {
  947.                 if (tk.Word == VDec)
  948.                 {
  949.                     return true;
  950.                 }
  951.             }
  952.             return false;
  953.         }
  954.         public static bool Check_Func(string VFun)
  955.         {
  956.             foreach (tws tk in LFun)
  957.             {
  958.                 if (tk.Word == VFun)
  959.                 {
  960.                     return true;
  961.                 }
  962.             }
  963.             return false;
  964.         }
  965.         public static void Print_Scope()
  966.         {
  967.             foreach (tws tk in LGlobal)
  968.             {
  969.                 Console.WriteLine("\t" + tk.Word + "\t" + tk.Type + "\t" + tk.Scope);
  970.             }
  971.             foreach (tws tk1 in LLocal)
  972.             {
  973.                 Console.WriteLine("\t" + tk1.Word + "\t" + tk1.Type + "\t" + tk1.Scope);
  974.             }
  975.             foreach (tws tk2 in LFun)
  976.             {
  977.                 Console.WriteLine("\t" + tk2.Word + "\t       " + " Function");
  978.             }
  979.             foreach (tws tk3 in LPFun)
  980.             {
  981.                 Console.WriteLine("\t" + tk3.Word + "\t" + tk3.Type + "\t" + tk3.Scope);
  982.             }
  983.         }
  984.         public static string Get_Type(string GWord)
  985.         {
  986.             foreach (tws tk in LGlobal)
  987.             {
  988.                 if (tk.Word == GWord)
  989.                 {
  990.                     return tk.Type;
  991.                 }
  992.             }
  993.             foreach (tws tk in LLocal)
  994.             {
  995.                 if (tk.Word == GWord)
  996.                 {
  997.                     return tk.Type;
  998.                 }
  999.             }
  1000.             foreach (tws tk in LPFun)
  1001.             {
  1002.                 if (tk.Word == GWord)
  1003.                 {
  1004.                     return tk.Type;
  1005.                 }
  1006.             }
  1007.             return "";
  1008.         }
  1009.         public static bool Check_Type(string CType)
  1010.         {
  1011.             foreach (string tk in LTWord)
  1012.             {
  1013.                 if ((tk == "int") || (tk == "int_const"))
  1014.                 {
  1015.                     if ((CType == "int") || (CType == "int_const"))
  1016.                     {
  1017.                         return true;
  1018.                     }
  1019.                     else
  1020.                     {
  1021.                         return false;
  1022.                     }
  1023.                 }
  1024.                 else if ((tk == "float") || (tk == "float_const"))
  1025.                 {
  1026.                     if ((CType == "float") || (CType == "float_const"))
  1027.                     {
  1028.                         return true;
  1029.                     }
  1030.                     else
  1031.                     {
  1032.                         return false;
  1033.                     }
  1034.                 }
  1035.                 else if ((tk == "string") || (tk == "string_const"))
  1036.                 {
  1037.                     if ((CType == "string") || (CType == "string_const"))
  1038.                     {
  1039.                         return true;
  1040.                     }
  1041.                     else
  1042.                     {
  1043.                         return false;
  1044.                     }
  1045.                 }
  1046.             }
  1047.  
  1048.             return false;
  1049.         }
  1050.         public static bool Check_Parametor(string PFunc, string P2Func)
  1051.         {
  1052.             List<string> WL = new List<string>();
  1053.             int i = 0;
  1054.             string p = "";
  1055.             string r = "";
  1056.             WL.Clear();
  1057.             foreach (tws tk in LDupDec)
  1058.             {
  1059.                 if ((tk.Scope == PFunc) || (tk.Word == P2Func))
  1060.                 {
  1061.  
  1062.                     WL.Add(tk.Type);
  1063.                     //p += tk.Type;
  1064.                     //p += "_const";
  1065.                 }
  1066.  
  1067.             }
  1068.             foreach (string tk in LTPWord)
  1069.             {
  1070.                 switch (tk)
  1071.                 {
  1072.                     case "int":
  1073.                         if ((WL[i] == "int") || (WL[i] == "int_const"))
  1074.                         {
  1075.                             i++;
  1076.                         }
  1077.                         else
  1078.                         {
  1079.                             return false;
  1080.                         }
  1081.                         break;
  1082.                     case "float":
  1083.                         if ((WL[i] == "float") || (WL[i] == "float_const"))
  1084.                         {
  1085.                             i++;
  1086.                         }
  1087.                         else
  1088.                         {
  1089.                             return false;
  1090.                         }
  1091.                         break;
  1092.                     case "string":
  1093.                         if ((WL[i] == "string") || (WL[i] == "string_const"))
  1094.                         {
  1095.                             i++;
  1096.                         }
  1097.                         else
  1098.                         {
  1099.                             return false;
  1100.                         }
  1101.                         break;
  1102.                     case "int_const":
  1103.                         if ((WL[i] == "int") || (WL[i] == "int_const"))
  1104.                         {
  1105.                             i++;
  1106.                         }
  1107.                         else
  1108.                         {
  1109.                             return false;
  1110.                         }
  1111.                         break;
  1112.                     case "float_const":
  1113.                         if ((WL[i] == "float") || (WL[i] == "float_const"))
  1114.                         {
  1115.                             i++;
  1116.                         }
  1117.                         else
  1118.                         {
  1119.                             return false;
  1120.                         }
  1121.                         break;
  1122.                     case "string_const":
  1123.                         if ((WL[i] == "string") || (WL[i] == "string_const"))
  1124.                         {
  1125.                             i++;
  1126.                         }
  1127.                         else
  1128.                         {
  1129.                             return false;
  1130.                         }
  1131.                         break;
  1132.                 }
  1133.             }
  1134.             return true;
  1135.         }
  1136.         public static void InfixToPostfix(ArrayList LInfix)
  1137.         {
  1138.             int Priority = 0;
  1139.             Stack<wt> StackOperator = new Stack<wt>();
  1140.  
  1141.             foreach (wt tk in LInfix)
  1142.             {
  1143.                 if ((tk.Type == "ID") || (tk.Type == "int_const") || (tk.Type == "float_const") || (tk.Type == "string_const"))
  1144.                 {
  1145.                     LPostfix.Add(tk);
  1146.                 }
  1147.                 else if (tk.Word == ";")
  1148.                 {
  1149.                     StackOperator.Pop();
  1150.                 }
  1151.                 else
  1152.                 {
  1153.                     if ((tk.Word == "*") || (tk.Word == "/"))
  1154.                     {
  1155.                         Priority = 1;
  1156.                     }
  1157.                     else if ((tk.Word == "+") || (tk.Word == "-"))
  1158.                     {
  1159.                         Priority = 2;
  1160.                     }
  1161.                     else if ((tk.Word == "==") || (tk.Word == "!="))
  1162.                     {
  1163.                         Priority = 3;
  1164.                     }
  1165.                     else if ((tk.Word == ">") || (tk.Word == ">=") || (tk.Word == "<") || (tk.Word == "<="))
  1166.                     {
  1167.                         Priority = 4;
  1168.                     }
  1169.                     else if (tk.Word == "&&")
  1170.                     {
  1171.                         Priority = 5;
  1172.                     }
  1173.                     else if (tk.Word == "||")
  1174.                     {
  1175.                         Priority = 6;
  1176.                     }
  1177.                     else if ((tk.Word == "=") || (tk.Word == "!"))
  1178.                     {
  1179.                         Priority = 7;
  1180.                     }
  1181.  
  1182.                     if (Priority == 1) // * /
  1183.                     {
  1184.                         if (StackOperator.Count == 0)
  1185.                         {
  1186.                             StackOperator.Push(tk);
  1187.                         }
  1188.                         else if ((StackOperator.Peek().Word == "*") || (StackOperator.Peek().Word == "/"))
  1189.                         {
  1190.                             wt tk1 = StackOperator.Pop();
  1191.                             LPostfix.Add(tk1);
  1192.                             if (StackOperator.Count != 0)
  1193.                             {
  1194.                                 while ((StackOperator.Peek().Word == "*") || (StackOperator.Peek().Word == "/"))
  1195.                                 {
  1196.                                     wt tk11 = StackOperator.Pop();
  1197.                                     LPostfix.Add(tk11);
  1198.                                 }
  1199.                             }
  1200.                             StackOperator.Push(tk);
  1201.                         }
  1202.                         else
  1203.                         {
  1204.                             StackOperator.Push(tk);
  1205.                         }
  1206.                     }
  1207.                     else if (Priority == 2) // + -
  1208.                     {
  1209.                         if (StackOperator.Count == 0)
  1210.                         {
  1211.                             StackOperator.Push(tk);
  1212.                         }
  1213.                         else if ((StackOperator.Peek().Word == "*") || (StackOperator.Peek().Word == "/") || (StackOperator.Peek().Word == "+") || (StackOperator.Peek().Word == "-"))
  1214.                         {
  1215.                             wt tk2 = StackOperator.Pop();
  1216.                             LPostfix.Add(tk2);
  1217.                             if (StackOperator.Count != 0)
  1218.                             {
  1219.                                 while ((StackOperator.Peek().Word == "*") || (StackOperator.Peek().Word == "/") || (StackOperator.Peek().Word == "+") || (StackOperator.Peek().Word == "-"))
  1220.                                 {
  1221.                                     wt tk21 = StackOperator.Pop();
  1222.                                     LPostfix.Add(tk21);
  1223.                                 }
  1224.                             }
  1225.                             StackOperator.Push(tk);
  1226.                         }
  1227.                         else
  1228.                         {
  1229.                             StackOperator.Push(tk);
  1230.                         }
  1231.                     }
  1232.                     else if (Priority == 3) // == !=
  1233.                     {
  1234.                         if (StackOperator.Count == 0)
  1235.                         {
  1236.                             StackOperator.Push(tk);
  1237.                         }
  1238.                         else if ((StackOperator.Peek().Word == "*") || (StackOperator.Peek().Word == "/") || (StackOperator.Peek().Word == "+") || (StackOperator.Peek().Word == "-") || (StackOperator.Peek().Word == "==") || (StackOperator.Peek().Word == "!="))
  1239.                         {
  1240.                             wt tk3 = StackOperator.Pop();
  1241.                             LPostfix.Add(tk3);
  1242.                             if (StackOperator.Count != 0)
  1243.                             {
  1244.                                 while ((StackOperator.Peek().Word == "*") || (StackOperator.Peek().Word == "/") || (StackOperator.Peek().Word == "+") || (StackOperator.Peek().Word == "-") || (StackOperator.Peek().Word == "==") || (StackOperator.Peek().Word == "!="))
  1245.                                 {
  1246.                                     wt tk31 = StackOperator.Pop();
  1247.                                     LPostfix.Add(tk31);
  1248.                                 }
  1249.                             }
  1250.                             StackOperator.Push(tk);
  1251.                         }
  1252.                         else
  1253.                         {
  1254.                             StackOperator.Push(tk);
  1255.                         }
  1256.                     }
  1257.                     else if (Priority == 4) // > >= < <=
  1258.                     {
  1259.                         if (StackOperator.Count == 0)
  1260.                         {
  1261.                             StackOperator.Push(tk);
  1262.                         }
  1263.                         else if ((StackOperator.Peek().Word == "*") || (StackOperator.Peek().Word == "/") || (StackOperator.Peek().Word == "+") || (StackOperator.Peek().Word == "-") || (StackOperator.Peek().Word == "==") || (StackOperator.Peek().Word == "!=") || (StackOperator.Peek().Word == ">") || (StackOperator.Peek().Word == ">=") || (StackOperator.Peek().Word == "<=") || (StackOperator.Peek().Word == "<="))
  1264.                         {
  1265.                             wt tk4 = StackOperator.Pop();
  1266.                             LPostfix.Add(tk4);
  1267.                             if (StackOperator.Count != 0)
  1268.                             {
  1269.                                 while ((StackOperator.Peek().Word == "*") || (StackOperator.Peek().Word == "/") || (StackOperator.Peek().Word == "+") || (StackOperator.Peek().Word == "-") || (StackOperator.Peek().Word == "==") || (StackOperator.Peek().Word == "!=") || (StackOperator.Peek().Word == ">") || (StackOperator.Peek().Word == ">=") || (StackOperator.Peek().Word == "<=") || (StackOperator.Peek().Word == "<="))
  1270.                                 {
  1271.                                     wt tk41 = StackOperator.Pop();
  1272.                                     LPostfix.Add(tk41);
  1273.                                 }
  1274.                             }
  1275.                             StackOperator.Push(tk);
  1276.                         }
  1277.                         else
  1278.                         {
  1279.                             StackOperator.Push(tk);
  1280.                         }
  1281.                     }
  1282.                     else if (Priority == 5) // &&
  1283.                     {
  1284.                         if (StackOperator.Count == 0)
  1285.                         {
  1286.                             StackOperator.Push(tk);
  1287.                         }
  1288.                         else if ((StackOperator.Peek().Word == "*") || (StackOperator.Peek().Word == "/") || (StackOperator.Peek().Word == "+") || (StackOperator.Peek().Word == "-") || (StackOperator.Peek().Word == "==") || (StackOperator.Peek().Word == "!=") || (StackOperator.Peek().Word == ">") || (StackOperator.Peek().Word == ">=") || (StackOperator.Peek().Word == "<=") || (StackOperator.Peek().Word == "<=") || (StackOperator.Peek().Word == "&&"))
  1289.                         {
  1290.                             wt tk5 = StackOperator.Pop();
  1291.                             LPostfix.Add(tk5);
  1292.                             if (StackOperator.Count != 0)
  1293.                             {
  1294.                                 while ((StackOperator.Peek().Word == "*") || (StackOperator.Peek().Word == "/") || (StackOperator.Peek().Word == "+") || (StackOperator.Peek().Word == "-") || (StackOperator.Peek().Word == "==") || (StackOperator.Peek().Word == "!=") || (StackOperator.Peek().Word == ">") || (StackOperator.Peek().Word == ">=") || (StackOperator.Peek().Word == "<=") || (StackOperator.Peek().Word == "<=") || (StackOperator.Peek().Word == "&&"))
  1295.                                 {
  1296.                                     wt tk51 = StackOperator.Pop();
  1297.                                     LPostfix.Add(tk51);
  1298.                                 }
  1299.                             }
  1300.                             StackOperator.Push(tk);
  1301.                         }
  1302.                         else
  1303.                         {
  1304.                             StackOperator.Push(tk);
  1305.                         }
  1306.                     }
  1307.                     else if (Priority == 6) // ||
  1308.                     {
  1309.                         if (StackOperator.Count == 0)
  1310.                         {
  1311.                             StackOperator.Push(tk);
  1312.                         }
  1313.                         else if ((StackOperator.Peek().Word == "*") || (StackOperator.Peek().Word == "/") || (StackOperator.Peek().Word == "+") || (StackOperator.Peek().Word == "-") || (StackOperator.Peek().Word == "==") || (StackOperator.Peek().Word == "!=") || (StackOperator.Peek().Word == ">") || (StackOperator.Peek().Word == ">=") || (StackOperator.Peek().Word == "<=") || (StackOperator.Peek().Word == "<=") || (StackOperator.Peek().Word == "&&") || (StackOperator.Peek().Word == "||"))
  1314.                         {
  1315.                             wt tk6 = StackOperator.Pop();
  1316.                             LPostfix.Add(tk6);
  1317.                             if (StackOperator.Count != 0)
  1318.                             {
  1319.                                 while ((StackOperator.Peek().Word == "*") || (StackOperator.Peek().Word == "/") || (StackOperator.Peek().Word == "+") || (StackOperator.Peek().Word == "-") || (StackOperator.Peek().Word == "==") || (StackOperator.Peek().Word == "!=") || (StackOperator.Peek().Word == ">") || (StackOperator.Peek().Word == ">=") || (StackOperator.Peek().Word == "<=") || (StackOperator.Peek().Word == "<=") || (StackOperator.Peek().Word == "&&") || (StackOperator.Peek().Word == "||"))
  1320.                                 {
  1321.                                     wt tk61 = StackOperator.Pop();
  1322.                                     LPostfix.Add(tk61);
  1323.                                 }
  1324.                             }
  1325.                             StackOperator.Push(tk);
  1326.                         }
  1327.                         else
  1328.                         {
  1329.                             StackOperator.Push(tk);
  1330.                         }
  1331.                     }
  1332.                     else if (Priority == 7) // = !
  1333.                     {
  1334.                         if (StackOperator.Count == 0)
  1335.                         {
  1336.                             StackOperator.Push(tk);
  1337.                         }
  1338.                         else
  1339.                         {
  1340.                             StackOperator.Push(tk);
  1341.                         }
  1342.                     }
  1343.                 }
  1344.             }
  1345.             while (StackOperator.Count != 0)
  1346.             {
  1347.                 if (StackOperator.Peek().Word == ")")
  1348.                 {
  1349.                     StackOperator.Pop();
  1350.                 }
  1351.                 else if (StackOperator.Count != 0)
  1352.                 {
  1353.                     wt tk = StackOperator.Pop();
  1354.                     LPostfix.Add(tk);
  1355.                 }
  1356.             }
  1357.         }
  1358.         public static void Print_Postfix()
  1359.         {
  1360.  
  1361.         }
  1362.         public static string PostfixTo4Tuple(ArrayList LPostfix)
  1363.         {
  1364.             string g = "";
  1365.             Stack<string> StackString = new Stack<string>();
  1366.             string Opcode = "";
  1367.             string Left = "";
  1368.             string Right = "";
  1369.             string Temp = "";
  1370.  
  1371.  
  1372.             foreach (wt tk in LPostfix)
  1373.             {
  1374.                 if ((tk.Type == "ID") || (tk.Type == "int_const") || (tk.Type == "float_const") || (tk.Type == "string_const"))
  1375.                 {
  1376.                     StackString.Push(tk.Word);
  1377.                 }
  1378.                 else
  1379.                 {
  1380.                     switch (tk.Word)
  1381.                     {
  1382.                         case "*": Opcode = "*"; break;
  1383.                         case "/": Opcode = "/"; break;
  1384.                         case "+": Opcode = "+"; break;
  1385.                         case "-": Opcode = "-"; break;
  1386.                         case "<": Opcode = "<"; break;
  1387.                         case "<=": Opcode = "<="; break;
  1388.                         case ">": Opcode = ">"; break;
  1389.                         case ">=": Opcode = ">="; break;
  1390.                         case "==": Opcode = "=="; break;
  1391.                         case "!=": Opcode = "!="; break;
  1392.                         case "&&": Opcode = "&&"; break;
  1393.                         case "||": Opcode = "||"; break;
  1394.                         case "!":
  1395.                             L4Tuple.Add(new FourTuple("!", StackString.Pop(), "_", StackString.Pop())); break;
  1396.                         case "=":
  1397.                             L4Tuple.Add(new FourTuple("=", StackString.Pop(), "_", StackString.Pop())); break;
  1398.                     }
  1399.                     if (StackString.Count == 0)
  1400.                     {
  1401.  
  1402.                     }
  1403.                     else
  1404.                     {
  1405.                         Left = StackString.Pop();
  1406.                         Right = StackString.Pop();
  1407.                         Temp = "T" + indexTemp;
  1408.                         indexTemp = indexTemp + 1;
  1409.                         L4Tuple.Add(new FourTuple(Opcode, Left, Right, Temp));
  1410.                         g = Temp;
  1411.                         LTemp.Add(Temp);
  1412.                         StackString.Push(Temp);
  1413.                     }
  1414.                 }
  1415.             }
  1416.             return g;
  1417.         }
  1418.         public static string Add_Intermediate(ArrayList L4Tuple)
  1419.         {
  1420.             string a = "";
  1421.             foreach (FourTuple tk in L4Tuple)
  1422.             {
  1423.                 FourTuple tk1 = new FourTuple();
  1424.                 tk1.Opcode = tk.Opcode;
  1425.                 tk1.Left = tk.Left;
  1426.                 tk1.Right = tk.Right;
  1427.                 tk1.Temp = tk.Temp;
  1428.                 a = tk1.Temp;
  1429.                 LInter.Add(tk1);
  1430.             }
  1431.             return a;
  1432.         }
  1433.         public static void Print_Intermediate()
  1434.         {
  1435.             foreach (FourTuple tk in LInter)
  1436.             {
  1437.                 Console.WriteLine("\t" + tk.Opcode + "\t" + tk.Left + "\t" + tk.Right + "\t" + tk.Temp);
  1438.             }
  1439.         }
  1440.         public static void Code_Genarator()
  1441.         {
  1442.             int count = 0;
  1443.             int line = 0;
  1444.             foreach (FourTuple StructLine in LInter)
  1445.             {
  1446.                 if ((StructLine.Opcode == "ID") || (StructLine.Opcode == "int_const") || (StructLine.Opcode == "float_const") || (StructLine.Opcode == "string_const"))
  1447.                 {
  1448.  
  1449.                 }
  1450.                 else
  1451.                 {
  1452.                     switch (StructLine.Opcode)
  1453.                     {
  1454.                         case "*": line += 3; break;
  1455.                         case "/": line += 3; break;
  1456.                         case "+": line += 3; break;
  1457.                         case "-": line += 3; break;
  1458.                         case "<": line += 3; break;
  1459.                         case "<=": line += 3; break;
  1460.                         case ">": line += 3; break;
  1461.                         case ">=": line += 3; break;
  1462.                         case "==": line += 3; break;
  1463.                         case "!=": line += 3; break;
  1464.                         case "&&": line += 3; break;
  1465.                         case "||": line += 3; break;
  1466.                         case "!": line += 2; break;
  1467.                         case "=": line += 2; break;
  1468.                         case "JMP": line += 1; break;
  1469.                         case "JMPF": line += 2; break;
  1470.                         case "LBL":
  1471.                             LLBL.Add(new LabelTable(StructLine.Temp, line)); break;
  1472.                     }
  1473.                 }
  1474.             }
  1475.             foreach (FourTuple tk in LInter)
  1476.             {
  1477.                 switch (tk.Opcode)
  1478.                 {
  1479.                     case "*":
  1480.                         LCode.Add(new CodeGen(count.ToString(), "LOAD", "R", tk.Left)); count++;
  1481.                         LCode.Add(new CodeGen(count.ToString(), "MULT", "R", tk.Right)); count++;
  1482.                         LCode.Add(new CodeGen(count.ToString(), "STORE", "R", tk.Temp)); count++; break;
  1483.                     case "/":
  1484.                         LCode.Add(new CodeGen(count.ToString(), "LOAD", "R", tk.Left)); count++;
  1485.                         LCode.Add(new CodeGen(count.ToString(), "DIV", "R", tk.Right)); count++;
  1486.                         LCode.Add(new CodeGen(count.ToString(), "STORE", "R", tk.Temp)); count++; break;
  1487.                     case "+":
  1488.                         LCode.Add(new CodeGen(count.ToString(), "LOAD", "R", tk.Left)); count++;
  1489.                         LCode.Add(new CodeGen(count.ToString(), "ADD", "R", tk.Right)); count++;
  1490.                         LCode.Add(new CodeGen(count.ToString(), "STORE", "R", tk.Temp)); count++; break;
  1491.                     case "-":
  1492.                         LCode.Add(new CodeGen(count.ToString(), "LOAD", "R", tk.Left)); count++;
  1493.                         LCode.Add(new CodeGen(count.ToString(), "SUB", "R", tk.Right)); count++;
  1494.                         LCode.Add(new CodeGen(count.ToString(), "STORE", "R", tk.Temp)); count++; break;
  1495.                     case "<":
  1496.                         LCode.Add(new CodeGen(count.ToString(), "LOAD", "R", tk.Left)); count++;
  1497.                         LCode.Add(new CodeGen(count.ToString(), "CMPLT", "R", tk.Right)); count++;
  1498.                         LCode.Add(new CodeGen(count.ToString(), "STORE", "R", tk.Temp)); count++; break;
  1499.                     case "<=":
  1500.                         LCode.Add(new CodeGen(count.ToString(), "LOAD", "R", tk.Left)); count++;
  1501.                         LCode.Add(new CodeGen(count.ToString(), "CMPLEQ", "R", tk.Right)); count++;
  1502.                         LCode.Add(new CodeGen(count.ToString(), "STORE", "R", tk.Temp)); count++; break;
  1503.                     case ">":
  1504.                         LCode.Add(new CodeGen(count.ToString(), "LOAD", "R", tk.Left)); count++;
  1505.                         LCode.Add(new CodeGen(count.ToString(), "CMPGT", "R", tk.Right)); count++;
  1506.                         LCode.Add(new CodeGen(count.ToString(), "STORE", "R", tk.Temp)); count++; break;
  1507.                     case ">=":
  1508.                         LCode.Add(new CodeGen(count.ToString(), "LOAD", "R", tk.Left)); count++;
  1509.                         LCode.Add(new CodeGen(count.ToString(), "CMPGEQ", "R", tk.Right)); count++;
  1510.                         LCode.Add(new CodeGen(count.ToString(), "STORE", "R", tk.Temp)); count++; break;
  1511.                     case "==":
  1512.                         LCode.Add(new CodeGen(count.ToString(), "LOAD", "R", tk.Left)); count++;
  1513.                         LCode.Add(new CodeGen(count.ToString(), "EQUAL", "R", tk.Right)); count++;
  1514.                         LCode.Add(new CodeGen(count.ToString(), "STORE", "R", tk.Temp)); count++; break;
  1515.                     case "!=":
  1516.                         LCode.Add(new CodeGen(count.ToString(), "LOAD", "R", tk.Left)); count++;
  1517.                         LCode.Add(new CodeGen(count.ToString(), "NEUQAL", "R", tk.Right)); count++;
  1518.                         LCode.Add(new CodeGen(count.ToString(), "STORE", "R", tk.Temp)); count++; break;
  1519.                     case "&&":
  1520.                         LCode.Add(new CodeGen(count.ToString(), "LOAD", "R", tk.Left)); count++;
  1521.                         LCode.Add(new CodeGen(count.ToString(), "AND", "R", tk.Right)); count++;
  1522.                         LCode.Add(new CodeGen(count.ToString(), "STORE", "R", tk.Temp)); count++; break;
  1523.                     case "||":
  1524.                         LCode.Add(new CodeGen(count.ToString(), "LOAD", "R", tk.Left)); count++;
  1525.                         LCode.Add(new CodeGen(count.ToString(), "OR", "R", tk.Right)); count++;
  1526.                         LCode.Add(new CodeGen(count.ToString(), "STORE", "R", tk.Temp)); count++; break;
  1527.                     case "!":
  1528.                         LCode.Add(new CodeGen(count.ToString(), "LOAD", "R", tk.Left)); count++;
  1529.                         LCode.Add(new CodeGen(count.ToString(), "NOT", "R", tk.Temp)); count++; break;
  1530.                     case "=":
  1531.                         LCode.Add(new CodeGen(count.ToString(), "LOAD", "R", tk.Left)); count++;
  1532.                         LCode.Add(new CodeGen(count.ToString(), "MOVE", "R", tk.Temp)); count++; break;
  1533.                     case "JMP":
  1534.                         int i = Count_Address(tk.Temp);
  1535.                         LCode.Add(new CodeGen(count.ToString(), "JUMP", " ", i.ToString())); count++; break;
  1536.                     case "JMPF":
  1537.                         int j = Count_Address(tk.Temp);
  1538.                         LCode.Add(new CodeGen(count.ToString(), "LOAD", "R", tk.Left)); count++;
  1539.                         LCode.Add(new CodeGen(count.ToString(), "JMPF", "R", j.ToString())); count++; break;
  1540.                     case "CALL":
  1541.                         LCode.Add(new CodeGen(count.ToString(), "CALL", "R", tk.Temp)); count++; break;
  1542.                 }
  1543.             }
  1544.         }
  1545.         public static void Print_CodeGenerator()
  1546.         {
  1547.             foreach (CodeGen tk in LCode)
  1548.             {
  1549.                 Console.WriteLine("\t" + tk.Line + "\t" + tk.Operator1 + "\t" + tk.Operator2 + "\t" + tk.Result);
  1550.             }
  1551.         }
  1552.         public static int Count_Address(string CA)
  1553.         {
  1554.             foreach (LabelTable tk in LLBL)
  1555.             {
  1556.                 if (CA == tk.Lable)
  1557.                 {
  1558.                     return tk.Line;
  1559.                 }
  1560.             }
  1561.             return 0;
  1562.         }
  1563.     }
  1564. }
RAW Paste Data
Top