Simulation of Compiler Design Gaming Project in C++

Projects Inventory

3 months ago

#include <iostream>
#include <vector>
#include <string>
#include <cctype>

// Token types
enum class TokenType {
    Number,
    Plus,
    Minus,
    Multiply,
    Divide,
    End,
    Invalid
};

// Token class
class Token {
public:
    Token(TokenType type, std::string value) : type(type), value(value) {}

    TokenType getType() const {
        return type;
    }

    std::string getValue() const {
        return value;
    }

private:
    TokenType type;
    std::string value;
};

// Lexer class
class Lexer {
public:
    Lexer(const std::string& input) : input(input), index(0) {}

    Token nextToken() {
        while (index < input.size() && std::isspace(input[index])) {
            ++index;
        }

        if (index >= input.size()) {
            return Token(TokenType::End, "");
        }

        char current = input[index];

        if (std::isdigit(current)) {
            std::string number;
            while (index < input.size() && std::isdigit(input[index])) {
                number += input[index++];
            }
            return Token(TokenType::Number, number);
        }

        switch (current) {
            case '+': ++index; return Token(TokenType::Plus, "+");
            case '-': ++index; return Token(TokenType::Minus, "-");
            case '*': ++index; return Token(TokenType::Multiply, "*");
            case '/': ++index; return Token(TokenType::Divide, "/");
            default: return Token(TokenType::Invalid, std::string(1, current));
        }
    }

private:
    std::string input;
    size_t index;
};

// Parser class
class Parser {
public:
    Parser(Lexer& lexer) : lexer(lexer), currentToken(lexer.nextToken()) {}

    void parse() {
        while (currentToken.getType() != TokenType::End) {
            if (currentToken.getType() == TokenType::Number) {
                std::cout << "Number: " << currentToken.getValue() << std::endl;
            } else {
                std::cout << "Operator: " << currentToken.getValue() << std::endl;
            }
            currentToken = lexer.nextToken();
        }
    }

private:
    Lexer& lexer;
    Token currentToken;
};

// Main function
int main() {
    std::string input = "10 + 20 * 30 - 40 / 2";
    Lexer lexer(input);
    Parser parser(lexer);

    std::cout << "Parsing input: " << input << std::endl;
    parser.parse();

    return 0;
}

100

101

102

103

104

#include <iostream>

#include <vector>

#include <string>

#include <cctype>

// Token types

enum class TokenType {

Number,

Plus,

Minus,

Multiply,

Divide,

End,

Invalid

};

// Token class

class Token {

public:

Token(TokenType type, std::string value) : type(type), value(value) {}

TokenType getType() const {

return type;

}

std::string getValue() const {

return value;

}

private:

TokenType type;

std::string value;

};

// Lexer class

class Lexer {

public:

Lexer(const std::string& input) : input(input), index(0) {}

Token nextToken() {

while (index < input.size() && std::isspace(input[index])) {

++index;

}

if (index >= input.size()) {

return Token(TokenType::End, "");

}

char current = input[index];

if (std::isdigit(current)) {

std::string number;

while (index < input.size() && std::isdigit(input[index])) {

number += input[index++];

}

return Token(TokenType::Number, number);

}

switch (current) {

case '+': ++index; return Token(TokenType::Plus, "+");

case '-': ++index; return Token(TokenType::Minus, "-");

case '*': ++index; return Token(TokenType::Multiply, "*");

case '/': ++index; return Token(TokenType::Divide, "/");

default: return Token(TokenType::Invalid, std::string(1, current));

}

private:

std::string input;

size_t index;

};

// Parser class

class Parser {

public:

Parser(Lexer& lexer) : lexer(lexer), currentToken(lexer.nextToken()) {}

void parse() {

while (currentToken.getType() != TokenType::End) {

if (currentToken.getType() == TokenType::Number) {

std::cout << "Number: " << currentToken.getValue() << std::endl;

} else {

std::cout << "Operator: " << currentToken.getValue() << std::endl;

}

currentToken = lexer.nextToken();

}

private:

Lexer& lexer;

Token currentToken;

};

// Main function

int main() {

std::string input = "10 + 20 * 30 - 40 / 2";

Lexer lexer(input);

Parser parser(lexer);

std::cout << "Parsing input: " << input << std::endl;

parser.parse();

return 0;

}

Explanation:

TokenType Enum:
- Defines various token types like Number, Plus, Minus, etc.
Token Class:
- Represents a token with a type and value.
- Token(TokenType type, std::string value): Constructor to initialize the token.
- getType() const: Returns the type of the token.
- getValue() const: Returns the value of the token.
Lexer Class:
- Lexer(const std::string& input): Constructor to initialize the lexer with input.
- nextToken(): Processes the input to generate the next token. It handles numbers and operators, skipping whitespace.
Parser Class:
- Parser(Lexer& lexer): Constructor to initialize the parser with a lexer.
- parse(): Processes tokens from the lexer and prints out whether they are numbers or operators.
Main Function:
- Initializes a Lexer with a sample input string.
- Creates a Parser using the lexer.
- Calls the parse() method to process the input and print the results.

Explanation:

Related Posts: