Question

For part one of this assignment, write a program (parse.c) that contains a function to parse a single line of input and and prints out the individual tokens.

Part 1 - Single Line Parser

For part one of this assignment, you will need to learn how to do some parsing (or more accurately--lexing a line, you do not have to check for correctness). You have previously done some parsing with the cycle count tool perhaps using functions such as strcmp. The little parser we are building now would be similar to the first part of building a compiler or interpeter for a programming language. For our next assignment, we are going to need to use our parser to parse commands users enter into their terminal (i.e. shell). A shell like we have been using can be thought of as an interactive interpreter of a command-line language performing the following:

1. It takes in a line of code (READ)
2. Parses the command (EVALUATES)
3. Then executes the command and its arguments (PRINT output)
4. Loops and then prints out any output. (LOOP)

We call this a REPL interpreter

For the first part of this assignment, we are going to break a string into individual tokens (or lexemes).

• The first token will be the command
• The second through N number of tokens (i.e. lexemes) will be any number of arguments.
• (Optionally) The N+1 tokens through M tokens will be another command with arguments.

For those who like a more formal definition, a grammar describing how to break each string into individual lexemes looks like the following:

command [args]* [ | commmand [args]* ]*

• command is what you type in (e.g. 'ls')
• args are any number of arguments (e.g. -l)
• And there may be a pipe ('|') sending our output elsewhere.
  • The pipe ('|') command means that we are taking the previous commands output as using that as input into our next command.
• The star(asterisk) means that any number of arguments(zero to as infinite) could follow (See Kleene star).

For part one of this assignment, write a program (parse.c) that contains a function to parse a single line of input and and prints out the individual tokens. You may re-use as much as parse.c as you like for implementing your shell for future assignments.

Example Input and Output

For example (See the line of input and the associated tokens separated onto a new line):

• ./parse "cd ."

  • cd
    .
    

• ./parse "ls -l"

  • ls
    -l
    

• ./parse "cat compile | head 2"

  • cat
    compile.py
    |
    head
    2
    

  Note: Your program will read in from the command-line the arguments to parse (e.g. ./parse "cat compile | head 2")

  Hint: Wrapping the command in quotes makes the first argument a string-- and you need to parse a single string.

Additional Hints for Part 1

• The function strtok may be useful for splitting up a line of input.
  • strtok works by splitting up an input based on a delimeter that indicates a new token is starting(in our example a space).
  • strtok is part of the string.h library, so be sure to include it.
• You may use other strategies outside of strtok however--there are many ways to parse your input.
• My expectation is Part 1 of this assignment should be relatively short and you may reused the functions for implementing the mini-shell in the next assignment!

parse.c

// Implement a working parser in this file that splits text into individual tokens.

Answer 1

contents of the file parse.c

#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// Checking for Delimiters.
bool isDelim(char ch)
{
   if (ch == ' ' || ch == '+' || ch == '-' || ch == '*' ||
       ch == '/' || ch == ',' || ch == ';' || ch == '>' ||
       ch == '<' || ch == '=' || ch == '(' || ch == ')' ||
       ch == '[' || ch == ']' || ch == '{' || ch == '}')
       return (true);
   return (false);
}

// Checking for Operators
bool isOp(char ch)
{
   if (ch == '+' || ch == '-' || ch == '*' ||
       ch == '/' || ch == '>' || ch == '<' ||
       ch == '=')
       return (true);
   return (false);
}

// Checking Valid Identifiers.
bool isValidId(char* str) // here the function name is 'isValidId'
{
   if (str[0] == '0' || str[0] == '1' || str[0] == '2' ||
       str[0] == '3' || str[0] == '4' || str[0] == '5' ||
       str[0] == '6' || str[0] == '7' || str[0] == '8' ||
       str[0] == '9' || isDelim(str[0]) == true)
       return (false);
   return (true);
}

// Checking for keywords.
bool isKey(char* str)
{
   if (!strcmp(str, "if") || !strcmp(str, "else") ||
       !strcmp(str, "while") || !strcmp(str, "do") ||
       !strcmp(str, "break") ||
       !strcmp(str, "continue") || !strcmp(str, "int")
       || !strcmp(str, "double") || !strcmp(str, "float")
       || !strcmp(str, "return") || !strcmp(str, "char")
       || !strcmp(str, "case") || !strcmp(str, "char")
       || !strcmp(str, "sizeof") || !strcmp(str, "long")
       || !strcmp(str, "short") || !strcmp(str, "typedef")
       || !strcmp(str, "switch") || !strcmp(str, "unsigned")
       || !strcmp(str, "void") || !strcmp(str, "static")
       || !strcmp(str, "struct") || !strcmp(str, "goto"))
       return (true);
   return (false);
}

// Checking for Integers..
bool isInt(char* str)
{
   int i, len = strlen(str);

   if (len == 0)
       return (false);
   for (i = 0; i < len; i++)

{
       if (str[i] != '0' && str[i] != '1' && str[i] != '2'
           && str[i] != '3' && str[i] != '4' && str[i] != '5'
           && str[i] != '6' && str[i] != '7' && str[i] != '8'
           && str[i] != '9' || (str[i] == '-' && i > 0))
           return (false);
   }
   return (true);
}

// Extracts the substring from the main string
char* subStr(char* str, int left, int right)
{
   int i;
   char* subStr = (char*)malloc(sizeof(char) * (right - left + 2));

   for (i = left; i <= right; i++)
       subStr[i - left] = str[i];
   subStr[right - left + 1] = '\0';
   return (subStr);
}

// Function for Parsing the Input String.
void parse(char* str)
{
   int left = 0, right = 0;
   int len = strlen(str);

   while (right <= len && left <= right) {
       if (isDelim(str[right]) == false)
           right++;

       if (isDelim(str[right]) == true && left == right) {
           if (isOp(str[right]) == true)
               printf("'%c' Is an operator \n", str[right]);

           right++;
           left = right;
       } else if (isDelim(str[right]) == true && left != right
               || (right == len && left != right)) {
           char* subStr = subStr(str, left, right - 1);

           if (isKey(subStr) == true)
               printf("'%s' Is a keyword \n", subStr);

           else if (isInt(subStr) == true)
               printf("'%s' Is an integer \n", subStr);

           else if (isValidId(subStr) == true
                   && isDelim(str[right - 1]) == false)
               printf("'%s' Is valid identifier\n", subStr);

           else if (isValidId(subStr) == false
                   && isDelim(str[right - 1]) == false)
               printf("'%s' Ii not a valid Identifier\n", subStr);
           left = right;
       }
   }
   return;
}

// Main Function
int main()
{
   // maximum legth of string is 100 here
   char str[100] = "int a = b + 1c; ";

   parse(str); // calling the parse function

   return (0);
}

The above program prints all individual tokens from an input stream. It is a bit lengthy but a basic one.

The subStr() function, can also be written using strtok() method, where delimiters and keywords need to be passed as argurment.

Hope this helps.

Do leave positive rating.