Write a Program to Detect Keyword and Identifier using JavaScript in Compiler Design

Write a Program to Check Keyword and Identifier using JavaScript in Compiler Design

What is Keyword and Identifiers?

Keywords and identifiers play crucial roles in programming languages. Keywords are predefined reserved words with special meanings to the compiler, while identifiers are names given to entities like variables, functions, and structures. In this article, we will explore how to detect keywords and identifiers in a given program using JavaScript.

Detecting Keywords and Identifiers in JavaScript:

To detect keywords and identifiers, we can use a combination of techniques such as string manipulation, comparison, and regular expressions. Let's dive into the code example:

let keywords = ["auto", "double", "int", "struct", "break", "else", "long",
    "switch", "case", "enum", "register", "typedef", "char",
    "extern", "return", "union", "const", "float", "short",
    "unsigned", "continue", "for", "signed", "void", "default",
    "goto", "sizeof", "voltile", "do", "if", "static", "while"
];

let expression = "int 9int = float(b) + double(c) + $text = char(ABC)";
let separators = ["=", ",", "+", "-", "*", "/", "%", "{", "}", "(", ")"];

function hasSeparators(separators) {
    for (let separator of separators) {
        if (expression.includes(separator)) {
            expression = expression.replaceAll(`${separator}`, ' ');
        }
    }
    return expression;
}

function detectKeyword(keywords, newExpression) {
    let resultKeywords = [];
    for (let expression of newExpression) {
        for (let keyword of keywords) {
            if (keyword == expression) {
                console.log(`${keyword} is a keyword`);
                resultKeywords.push(keyword);
            }
        }
    }
    return resultKeywords;
}

function detectIdentifier(keywordList, newExpression) {
    let resultIdentifiers = newExpression.filter(keyword => {
        let regex = "^([a-zA-Z_$][a-zA-Z\\d_$]*)$";
        return !keywordList.includes(keyword) && keyword.match(regex);
    });

    console.log(`\n`);
    resultIdentifiers.forEach(element => {
        console.log(`${element} is an identifier`);
    });
}

function detectKeywordIdentifier() {
    console.log(`The given expression:\n ${expression}\n`);
    let newExpression = hasSeparators(separators).split(" ")
        .filter(e => e != "");

    let keywordList = detectKeyword(keywords, newExpression);
    detectIdentifier(keywordList, newExpression);
}

detectKeywordIdentifier();

Input/Output:

Let's go through the code step by step to understand how it detects keywords and identifiers:

1. The code starts by defining an array called `keywords` which contains a list of reserved keywords in the programming language. These keywords have special meanings to the compiler.

2. The `expression` variable holds the input expression that we want to analyze for keywords and identifiers. This expression can contain a mix of keywords, identifiers, and separators.

3. The `separators` array contains a list of characters that act as separators in the expression. These separators are used to split the expression into individual elements for analysis.

4. The `hasSeparators` function takes the `separators` array as input and replaces each separator found in the `expression` with a space. This step is necessary to separate the keywords and identifiers later.

5. The `detectKeyword` function takes the `keywords` array and the modified `newExpression` as input. It iterates over each element in the `newExpression` and compares it with the keywords in the `keywords` array. If a match is found, the keyword is logged to the console as a keyword, and it is added to the `resultKeywords` array.

6. The `detectIdentifier` function takes the `keywordList` (the list of detected keywords) and the `newExpression` as input. It uses a regular expression to filter out elements from the `newExpression` that are not present in the `keywordList` and match the pattern of a valid identifier. These filtered elements are considered identifiers and are logged to the console.

7. The `detectKeywordIdentifier` function serves as the main entry point for the program. It logs the given expression to the console and then performs the keyword and identifier detection by calling the `hasSeparators`, `detectKeyword`, and `detectIdentifier` functions.

8. Finally, the `detectKeywordIdentifier` function is invoked to execute the program and display the results.

By running this code, you can detect and differentiate between keywords and identifiers in a given expression. The separators are used to split the expression into individual elements, and then each element is compared with the list of keywords to identify keywords. The remaining elements that match the pattern of a valid identifier are considered identifiers. The program logs the detected keywords and identifiers to the console, providing valuable information about the lexical elements present in the expression. 

Happy coding!

Next Article:

Write a Program to Detect Integer and Real Number using JavaScript in Compiler Design

Previous Article: Write a Program to Detect Operators using Lexical Analyzer in JavaScript | Compiler Design

 

Ashraf Compiler Design