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

What is Lexical Analyzer?

Lexical analysis, also known as scanning, is a crucial phase in the compilation process of programming languages. It involves breaking down the input program into a sequence of tokens. In this article, we will explore how to detect operators using lexical analysis in JavaScript.

What is Operators?

Operators are symbols that instruct the compiler or interpreter to perform specific mathematical, relational, or logical operations.

For example, + is an operator used for addition, while - is an operator used for subtraction and many more. 

Types of Operators in Programming Languages with Examples:

There are several types of operators commonly used in programming languages. They include:

1) Arithmetic operators: Used for mathematical operations such as addition (+), subtraction (-), multiplication (*), division (/), and modulo (%).

2) Relational operators: Used to compare values, such as greater than (>), lesser than (<), equal to (==), not equal to (!=), greater than or equal to (>=), and lesser than or equal to (<=).

3) Logical operators: Used for logical operations, such as logical AND (&&), logical OR (||), and logical NOT (!).

4) Bitwise operators: Used for bit-level operations on binary numbers, such as bitwise AND (&), bitwise OR (|), and bitwise XOR (^).

5) Assignment operators: Used to assign values, such as simple assignment (=), addition assignment (+=), subtraction assignment (-=), multiplication assignment (*=), and division assignment (/=).

6) Type Information Operators: Special operators that provide information about the type of a value, such as typeof and instanceof.

Detecting Operators in JavaScript:

To detect operators in JavaScript, we can use a lexical analyzer. Here is an example implementation in JavaScript:

let operators = {
    '+' :'addition',
    '-' :'subtraction',
    '*' :'multiplication',
    '/' :'division',
    '%' :'modulo',
    '>' :'greater than',
    '<' :'lesser than',
    '=' :'assignment',
    '++':'increment',
    '--':'decrement',
    '<=':'less or equal',
    '>=':'greater or equal',
    '==':'equal',
    '!=':'not equal',
    '&&':'logical AND',
    '||':'logical OR',
    '!':'logical NOT',
    '^':'logical XOR',
    '?:':'ternary operator',
    '+=': 'assignment addition',
    '-=': 'assignment subtraction',
    '/=': 'assignment division',
    '*=': 'assignment multiplication',
    '**': 'exponential'
};

function detectOperator(expression, operators) {
    console.log(`The given expression:\n${expression}\n`);

    // Handle double operators
    let double = ['!=','--','++','<=','>=','==','&&','||','+=','-=','/=','*=','**'];
    for(let dup of double) {
        if(expression.includes(dup)) {
            expression = expression.replace(`${dup}`,'');
            console.log(`${dup} is ${operators[dup]} operator`);
        }
    }

    // Handle ternary operator
    if(expression.includes('?' && ':')){
        expression = expression.replace('?', '').replace(':', '');
        console.log(`?: is a ternary operator`);
    }

    // Handle other operators
    for(let operator in operators) {
        let hasOperator = expression.includes(operator);
        if(hasOperator) {
            console.log(`${operator} is ${operators[operator]} operator`);
        }
    }
}

//takes input and runs only in browser console
let expression = prompt("Enter the expression:");
detectOperator(expression, operators); 

Input/Output:

Let's break down the code and explain how it detects operators using lexical analysis:

1) The code begins by defining an object called operators, which maps various operators to their corresponding descriptions. Each operator is represented as a key-value pair.

2) The detectOperator function takes two parameters: the expression to be analyzed and the operators object.

3) Within the detectOperator function, the given expression is logged to the console for reference.

4) The code defines an array called double which contains operators that consist of two characters. These operators require special handling since they cannot be directly matched using a simple string comparison.

5) The code checks if any double operators are present in the expression by iterating through the double array. If a double operator is found, it is removed from the expression using the replace method, and the corresponding operator and its description are logged to the console.

6) Next, the code checks if the ternary operator ?: is present in the expression. If found, it is removed from the expression using the replace method, and a message indicating it is a ternary operator is logged to the console.

7) Finally, the code iterates through each operator in the operators object. It checks if each operator is present in the expression using the includes method. If an operator is found, its corresponding description is logged to the console.

8) The detectOperator function is called with the user-provided expression and the operators object.

9) In the browser environment, the user is prompted to enter an expression. The provided expression is then passed to the detectOperator function, initiating the analysis.

10) The function logs the expression and proceeds to identify and log any operators found in the expression, along with their descriptions.

By executing this code, you can easily detect and categorize operators within a given JavaScript expression using lexical analysis techniques.

Conclusion:

Lexical analysis plays a vital role in the compilation process of programming languages. Detecting operators using a lexical analyzer allows us to identify and categorize different types of operators in a given expression. By understanding and utilizing this technique, developers can gain deeper insights into the structure and behavior of their code. So, the next time you encounter a complex expression, remember to leverage lexical analysis to identify and understand the operators involved. 

Happy coding!

Next Article:

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

Previous Article: Write a Program to Check The Given String is Comment or Not Using JavaScript | Compiler Design

 

Ashraf Compiler Design