/// <summary>
        /// Inserts a procedure with all necessary information
        /// </summary>
        private void insertProcedure()
        {
            token = getNextToken(); // proc
            token = getNextToken(); // proc name

            SymTab.entry ptr = st.lookUp(token.Trim(' '));

            emit(token + "\t PROC");
            emit("\tpush bp ");                               //push bp
            mov("bp", "sp");                                  // mov bp, sp
            SymTab.entry.function fptr = ptr as SymTab.entry.function;
            emit("\tsub sp, " + fptr.sizeOfLocal.ToString()); // sub sp, size of locals from symtab

            //TRANSLATED CODE
            emit("");
            if (token != "endp")
            {
                token = getNextToken(); // get L
            }
            transCode();

            //Last part of template
            emit("\tadd sp, " + fptr.sizeOfLocal.ToString());
            emit("\tpop bp");
            emit("\tret " + fptr.sizeOfParams);

            token = getNextToken(); // proc name
            emit(token + "\t endp");
        }
Exemple #2
0
        /// <summary>
        /// Writes the contents of the table. Skips empty lists. For assignment grading purposes.
        /// </summary>
        ///
        public void writeTable(int depth)
        {
            if (rdp.error == true)
            {
                return;
            }
            string output = "";
            //string vOutput = String.Format("| {0,-10}  {1,-10} {2, -10} {3, -5} {4, -20}  {5, -20} \t\t\t  |", "Entrytype ", "Token", "Type", "Depth", "Size", "Offset");
            string fOutput = String.Format("| {0,-10}  {1,-10} {2, -10} {3, -15} {4, -20}  {5, -26} |", "Token", "Lexeme", "Depth", "Number of parameters", "Size of Locals", "Size of parameters");

            // Console.WriteLine("Following symbols are at depth " + depth);
            Console.WriteLine("|---------------------------------------------------------------------------------------------------------|");
            Console.WriteLine("|-------------------------------" + " Depth: " + depth + " ----------------------------------------------------------------|");
            Console.WriteLine("|---------------------------------------------------------------------------------------------------------|");

            for (int i = 0; i < hashTable.Length; i++)
            {
                try
                {
                    entry temp = hashTable[i].ElementAt(0);
                    while (temp.Next != null)
                    {
                        if (temp.Next.depth == depth)
                        {
                            switch (temp.Next.typeOfEntry)
                            {
                            case (SymTab.entryType.functionEntry):
                                SymTab.entry.function t1 = temp.Next as SymTab.entry.function;
                                Console.WriteLine("| Procedure: \t\t\t\t\t\t\t\t\t\t\t\t\t  |");
                                output = string.Format("| {0,-10}  {1,-10} {2, -10} {3, -20} {4, -20}  {5, -26} |",
                                                       t1.token, t1.lexeme, t1.depth, t1.numberOfParams, t1.sizeOfLocal, t1.sizeOfParams);
                                Console.WriteLine(fOutput);
                                Console.WriteLine(output);
                                Console.Write("| Parameters: ");

                                if (t1.numberOfParams > 0)
                                {
                                    for (int j = 1; j <= t1.paramList.Count; j++)
                                    {
                                        Console.Write(t1.paramList.ElementAt(j - 1).mode + " " + t1.paramList.ElementAt(j - 1).typeVar + "  ");
                                    }
                                }
                                else
                                {
                                    Console.WriteLine(" none");
                                }
                                Console.WriteLine();
                                break;

                            case (SymTab.entryType.constEntry):
                                Console.WriteLine();
                                SymTab.entry.constant t2 = temp.Next as SymTab.entry.constant;
                                switch (t2.typeOfConstant)
                                {
                                case (SymTab.varType.floatType):
                                    SymTab.entry.constant.floatConstant f1 = temp.Next as SymTab.entry.constant.floatConstant;

                                    Console.WriteLine("Constant: " + f1.lexeme + " With the following data: ");
                                    Console.WriteLine("Token: " + f1.token);
                                    Console.WriteLine("Type: " + f1.typeOfConstant);
                                    Console.WriteLine("Depth: " + f1.depth);
                                    Console.WriteLine("Size: " + f1.size);
                                    Console.WriteLine("Offset: " + f1.offset);
                                    break;

                                case (SymTab.varType.intType):
                                    SymTab.entry.constant.intConstant i1 = temp.Next as SymTab.entry.constant.intConstant;
                                    Console.WriteLine("Constant: " + i1.lexeme + " With the following data: ");
                                    Console.WriteLine("Token: " + i1.token);
                                    Console.WriteLine("Type: " + i1.typeOfConstant);
                                    Console.WriteLine("Depth: " + i1.depth);
                                    Console.WriteLine("Size: " + i1.size);
                                    Console.WriteLine("Offset: " + i1.offset);
                                    break;
                                }
                                Console.WriteLine();
                                break;

                            case (SymTab.entryType.varEntry):
                                SymTab.entry.var t3 = temp.Next as SymTab.entry.var;

                                Console.WriteLine();
                                Console.WriteLine("Variable: " + t3.lexeme + " With the following data: ");
                                Console.WriteLine("Token: " + t3.token);
                                Console.WriteLine("Type: " + t3.typeOfVar);
                                Console.WriteLine("Depth: " + t3.depth);
                                Console.WriteLine("Size: " + t3.size);
                                Console.WriteLine("Offset: " + t3.offset);
                                Console.WriteLine();
                                break;
                            }
                        }
                        //Console.WriteLine(temp.Next.lexeme);
                        //Console.WriteLine(temp.Next.typeOfEntry);
                        if (temp.Next != null)
                        {
                            temp = temp.Next;
                        }
                    }
                }
                catch (NullReferenceException)
                {
                    //Console.WriteLine("NULL REFERENCE!");
                    //Empty entry
                }
            }
        }