I have this code for parsing and cleaning a MIPS assembly code Now write a report on it…
- User
I have this code for parsing and cleaning a MIPS assembly code Now write a report on it
#include <bits/stdc++.h> using namespace std;
//////// This section is completely done now /// Some Assumption Instruction will always come in format add 2, t1 ---->>>> Because this is also valid according to MARS. // But I can make some changes to include this also -- Done
vector splitString(string& str, char delimiter) { vector result; stringstream ss(str); string item; while (getline(ss, item, delimiter)) { if(item != "")result.push_back(item); } return result; }
void removeSpaces(string &str){ while(str.size() && (str.back() == ' ' || str.back() == 9)){ //// Here 9 represent "Tab" str.pop_back(); } for(int i=0; i<str.size(); i++){ if(str[i] != ' ' && str[i] != 9){ str.erase(str.begin(), str.begin() + i); break; } } }
vector splitString(string& str) { vector result; // stringstream ss(str); removeSpaces(str); string temp1, temp2; // one store .--- and other store it's value int i = 0; for(; i<str.size(); i++){ if(str[i] == ' ' || str[i] == '"'){ break; } } temp1 = str.substr(0, i); temp2 = str.substr(i); removeSpaces(temp1); removeSpaces(temp2); return {temp1, temp2}; }
int doesLabelExist(string &str, char check){ for(int i=0; i<str.size(); i++){ if(str[i] == check) return i; } return -1; }
string clearString(string temp){ if(temp.size() == 0) return ""; if(temp.back() == '\n') temp.pop_back(); int it = doesLabelExist(temp, '#'); /// To remove any comment from code if(it != -1) temp.erase(temp.begin() + it, temp.end()); // cout<<temp<<endl; removeSpaces(temp); return temp; }
pair<string, string> instructionAndFirstRegister(string &str){ stringstream s(str); string instr, regi; s >> instr; s >> regi; return {instr, regi}; }
vector <vector> readDataSection(int start, int end, vector &data){ vector <vector > ans; for(int i = start; i<end; i++){ string cleaned_string = clearString(data[i]); // cout<<cleaned_string<<endl; if(cleaned_string.size()){ vector temp; int doesLabExist = doesLabelExist(cleaned_string, ':'); if(doesLabExist == -1) {//throw "Error"; /// Throw error because some sentence exist without any data type cout<<"In .data section Label exist without any Type : "<<data[i]<<endl; exit(0); } string label = cleaned_string.substr(0 , doesLabExist); cleaned_string = cleaned_string.substr(doesLabExist + 1);
// We cannot just directly use this say .asciiz "Input an string to check whether it is pali or not : " // It will try to split at all ' ', which is not what we want vector <string> splited = splitString(cleaned_string); if(splited.size() != 2) {//throw "Error"; cout<<"Something extra is there : "<<data[i]<<endl; exit(0); } temp.push_back(clearString(label)); for(auto &x : splited){ temp.push_back(clearString(x)); } ans.push_back(temp); } } return ans;}
vector <vector> readTextSection(int start, int end, vector &data){ vector <vector > new_code; for(int i = start; i<end; i++){ string cleaned_string = clearString(data[i]); if(cleaned_string.size()){ //// To check if it contain any instruction But why 1 so '\n' does not get included not needed more // No it was not due to that it was due to "Tab" // cout<<cleaned_string<<endl; // flush(cout); int doesLabExist = doesLabelExist(cleaned_string, ':'); /// just checking if label and instruction are in same line // cout<<doesLabExist<<endl; if(doesLabExist != -1){ string label = cleaned_string.substr(0 , doesLabExist); /// If label exist create a new line new_code.push_back({label}); cleaned_string = cleaned_string.substr(doesLabExist + 1); } if(cleaned_string.size()){ vector part_of_instruction = splitString(cleaned_string, ','); if(part_of_instruction.size() > 3 || part_of_instruction.size() < 1){ //// throw error cout<<"Instruction error : "<<data[i]<<endl; exit(0); } vector one_instruction; auto partone = instructionAndFirstRegister(part_of_instruction[0]); if(partone.first.size()) one_instruction.push_back(partone.first); if(partone.second.size()) one_instruction.push_back(partone.second); /// For somethig like add, 2, $3 for(int i=1; i<part_of_instruction.size(); i++){ string copy = part_of_instruction[i]; removeSpaces(copy); one_instruction.push_back(copy); } new_code.push_back(one_instruction); } } } return new_code; }
pair<vector <vector>,vector <vector>> readAndClearCode2(string filename){ fstream newfile; newfile.open(filename,ios::in); vector <vector > new_code; string str; vector file; while(getline(newfile, str)){ // if(str.back() == '\n') str.pop_back(); /// Handling it in clearString() file.push_back(str); } if(file.size() == 0) return{{{""}},{{""}}};
vector <vector <string> > text_section, data_section; for(int i=0; i<file.size(); i++){ string temp = clearString(file[i]); if(temp == ".data"){ int j = i; while(j<file.size() && clearString(file[j++]) != ".text"); j--; // Because it will increment one even if we don't want data_section = readDataSection(i+1, j, file); break; } } for(int i=0; i<file.size(); i++){ string temp = clearString(file[i]); if(temp == ".text"){ text_section = readTextSection(i+1, file.size(), file); break; } } return {data_section, text_section}; // for(auto &x : text_section){ // for(auto &y : x){ // cout<<y<<" "; // } // cout<<endl; // } // for(auto &x : data_section){ // for(auto &y : x){ // cout<<y<<" "; // } // cout<<endl; // }}
- Assistant
Parsing and Cleaning MIPS Assembly Code in C++
Introduction
This report provides an analysis of a C++ program designed to parse and clean MIPS assembly code. The program reads a MIPS assembly file, removes comments and unnecessary whitespace, and extracts structured data from the
.dataand.textsections. This structured data includes labels, instructions, and operands, which can be used for further processing, such as assembling, simulation, or analysis.
Overview of the Program
The primary objective of the program is to process a MIPS assembly file and convert it into a structured format. The code handles various complexities of assembly language, such as labels, instructions with varying numbers of operands, and comments.
The program consists of several functions, each responsible for a specific task:
-
String Manipulation Functions
splitString(overloaded)removeSpacesclearStringdoesLabelExist
-
Parsing Functions
instructionAndFirstRegisterreadDataSectionreadTextSection
-
Main Parsing Function
readAndClearCode2
Detailed Explanation of Functions
1. String Manipulation Functions
a.
splitString(string& str, char delimiter)Purpose: Splits a string into a vector of substrings separated by a specified delimiter.
Implementation:
- Uses a
stringstreamto read the input string. - Splits the string at each occurrence of the delimiter.
- Ignores empty substrings resulting from consecutive delimiters.
Usage:
- Used to split instruction operands separated by commas.
Example:
string s = "add $t1, $t2, $t3"; vector<string> operands = splitString(s, ','); // operands = ["add $t1", " $t2", " $t3"]
b.
removeSpaces(string &str)Purpose: Removes leading and trailing whitespace and tab characters from a string.
Implementation:
- Removes spaces and tabs from the end of the string using
str.pop_back(). - Finds the first non-space character from the beginning and erases all characters before it.
Usage:
- Used to clean up strings before further processing.
Example:
string s = " \t add $t1, $t2, $t3 \t "; removeSpaces(s); // s = "add $t1, $t2, $t3"
c.
splitString(string& str)Purpose: Splits a string into two parts: before and after the first space or double quote.
Implementation:
- Searches for the first occurrence of a space or double quote.
- Splits the string at that position.
- Calls
removeSpaceson both substrings to clean them.
Usage:
- Used to separate directives and their arguments in the
.datasection.
Example:
string s = ".asciiz \"Hello, World!\""; vector<string> parts = splitString(s); // parts = [".asciiz", "\"Hello, World!\""]
d.
doesLabelExist(string &str, char check)Purpose: Checks if a specific character exists in a string and returns its index.
Implementation:
- Iterates through the string to find the character.
- Returns the index if found, or
-1if not found.
Usage:
- Used to determine if a label or comment exists in a line.
Example:
string s = "start_loop:"; int index = doesLabelExist(s, ':'); // index = 10
e.
clearString(string temp)Purpose: Cleans a string by removing comments and leading/trailing whitespace.
Implementation:
- Removes any content after a comment character
#. - Calls
removeSpacesto trim whitespace.
Usage:
- Applied to each line read from the assembly file.
Example:
string s = " add $t1, $t2, $t3 # This is a comment"; string cleaned = clearString(s); // cleaned = "add $t1, $t2, $t3"
2. Parsing Functions
a.
instructionAndFirstRegister(string &str)Purpose: Extracts the instruction and the first operand from a string.
Implementation:
- Uses
stringstreamto read the first two tokens. - Returns them as a pair.
Usage:
- Used to separate the instruction and its first operand when they are not separated by a comma.
Example:
string s = "add $t1"; pair<string, string> instr_reg = instructionAndFirstRegister(s); // instr_reg.first = "add" // instr_reg.second = "$t1"
b.
readDataSection(int start, int end, vector<string> &data)Purpose: Parses the
.datasection of the assembly code.Implementation:
- Iterates over the lines in the specified range.
- Uses
clearStringto clean each line. - Checks for labels (lines containing
:) and separates them. - Splits the rest of the line using
splitStringto separate directives and their arguments. - Stores the label, directive, and data in a vector.
Usage:
- Called by
readAndClearCode2to parse the.datasection.
Example:
// Given the line: "msg: .asciiz "Hello, World!"" vector<vector<string>> data_section = readDataSection(...); // data_section = [["msg", ".asciiz", "\"Hello, World!\""]]
c.
readTextSection(int start, int end, vector<string> &data)Purpose: Parses the
.textsection of the assembly code.Implementation:
- Iterates over the lines in the specified range.
- Uses
clearStringto clean each line. - Checks for labels and separates them.
- Splits instruction lines into operands using
splitStringwith a comma delimiter. - Handles instructions with varying numbers of operands.
Usage:
- Called by
readAndClearCode2to parse the.textsection.
Example:
// Given the line: "start_loop: add $t1, $t2, $t3" vector<vector<string>> text_section = readTextSection(...); // text_section = [["start_loop"], ["add", "$t1", "$t2", "$t3"]]
3. Main Parsing Function
readAndClearCode2(string filename)Purpose: Reads an assembly file, identifies
.dataand.textsections, and parses them.Implementation:
- Opens the file and reads all lines into a vector.
- Searches for
.dataand.textsection markers. - Calls
readDataSectionandreadTextSectionto parse the respective sections. - Returns a pair of vectors containing parsed data from both sections.
Usage:
- Main function to be called for parsing an assembly file.
Example:
pair<vector<vector<string>>, vector<vector<string>>> parsed_code = readAndClearCode2("program.asm"); // parsed_code.first contains the data section // parsed_code.second contains the text section
Program Workflow
-
File Reading:
- The program reads an assembly file line by line and stores each line in a vector.
-
Section Identification:
- It searches for the
.dataand.textdirectives to identify the respective sections.
- It searches for the
-
Data Section Parsing:
- Calls
readDataSectionto parse the.datasection. - For each line, it extracts labels, directives, and data.
- Calls
-
Text Section Parsing:
- Calls
readTextSectionto parse the.textsection. - For each line, it handles labels and instructions with their operands.
- Calls
-
Error Handling:
- If unexpected formats are encountered, the program prints an error message and exits.
-
Output:
- The parsed data and text sections are returned as structured data for further processing.
Assumptions and Notes
-
Instruction Format: The program assumes that instructions follow a specific format, such as
add $1, $2, $3. However, it is adaptable to variations likeadd $t1. -
Labels: Labels are identified by the presence of a colon
:. The program expects labels to be correctly formatted. -
Comments: Anything following a
#character is considered a comment and is removed. -
Whitespace Handling: The program carefully removes extra spaces and tabs to accurately parse the code.
-
Error Messages: The program provides specific error messages when it encounters unexpected formats, which aids in debugging.
Example Walkthrough
Given the following MIPS assembly code snippet:
.data msg: .asciiz "Enter a number: " .text main: li $v0, 4 la $a0, msg syscallParsing Steps:
-
Data Section:
- Line:
msg: .asciiz "Enter a number: " - After
clearString:msg: .asciiz "Enter a number: " - Split into label and rest:
label = "msg",rest = ".asciiz "Enter a number: "" - Using
splitString:directive = ".asciiz",data = "\"Enter a number: \"" - Parsed Data:
["msg", ".asciiz", "\"Enter a number: \""]
- Line:
-
Text Section:
- Line:
main:- Contains a label:
label = "main" - Parsed Text:
["main"]
- Contains a label:
- Line:
li $v0, 4- After
clearString:li $v0, 4 - Split at commas:
["li $v0", "4"] - Using
instructionAndFirstRegister:instruction = "li",first_reg = "$v0" - Parsed Instruction:
["li", "$v0", "4"]
- After
- Line:
la $a0, msg- After
clearString:la $a0, msg - Split at commas:
["la $a0", "msg"] - Using
instructionAndFirstRegister:instruction = "la",first_reg = "$a0" - Parsed Instruction:
["la", "$a0", "msg"]
- After
- Line:
syscall- After
clearString:syscall - No operands.
- Parsed Instruction:
["syscall"]
- After
- Line:
Potential Improvements
-
Enhanced Error Handling:
- Introduce exceptions instead of exiting the program.
- Provide line numbers in error messages for easier debugging.
-
Support for Additional Directives:
- Extend parsing capabilities to handle more assembly directives and pseudo-instructions.
-
Flexible Instruction Parsing:
- Modify the parser to handle variable numbers of operands without strict limits.
-
Optimization:
- Enhance performance by optimizing string operations, especially in large files.
-
User Feedback:
- Implement verbose mode to allow users to see parsing progress and warnings.
-
Unit Testing:
- Develop unit tests for each function to ensure reliability and facilitate maintenance.
Conclusion
The C++ program effectively parses and cleans MIPS assembly code by handling labels, instructions, and comments. It provides a structured representation of the assembly code, which can be utilized for various purposes such as assembling, simulation, or further analysis. With some enhancements, particularly in error handling and flexibility, the program can serve as a robust tool for processing MIPS assembly code.
Appendix: Code Structure
The program's code is structured for clarity and modularity, with each function performing a specific task. This design facilitates understanding and potential modifications.
-
Main Function:
readAndClearCode2- Reads the assembly file and coordinates the parsing of
.dataand.textsections.
- Reads the assembly file and coordinates the parsing of
-
Helper Functions:
- String manipulation (
splitString,removeSpaces,clearString). - Parsing functions (
instructionAndFirstRegister,doesLabelExist). - Section readers (
readDataSection,readTextSection).
- String manipulation (
Usage Instructions
To use the program:
-
Compile the code using a C++ compiler that supports C++11 or higher (due to the use of
autoand range-based loops).g++ -std=c++11 -o parser parser.cpp -
Run the program, providing the assembly file name as an argument.
./parser program.asm -
Output:
- The program will parse the assembly file and can be modified to display or utilize the parsed data as needed.
Final Notes
Parsing assembly code requires careful handling of various language constructs and conventions. This program demonstrates a practical approach to processing MIPS assembly files, accommodating common scenarios encountered in assembly programming. By building upon this foundation, more sophisticated features can be added to handle complex assembly codebases.
-