The Template of the code is given below this. Using the coding outline template exactly shown and given $,$ write the code using the rules and test cases from the photos given all below:

#$1$ The user is prompted to enter a pseudo arithmetic command. The input must be verified to be grammatically correct.

$2.$ The string and character type library cannot be used under any circumstances. You are encouraged to develop your own functions to perform any similar operations that are needed. This includes $($ strlen$(),$ strcpy$(),$ strcmp$(),$ islower$())$

$3.$ No changes to the code in main. Your code must be placed in functions. Additional functions are encouraged

As well as the guidelines in the photos given while also confirming the test cases:

$//$ do not include any additional libraries

#include

$//$ do not change these constants

#define MAXLINE $80$

#define MAXOPER $13$

$//$ named constants and strings

enum operations $\{$NOOP$,$ ADD, MUL, DIV, POW$\}$;

const char $*$operation$\_$str$[]=\{"$Invalid$","+","*","/","^"\}$;

$//$ function prototypes

int process$\_$input$($const char $*$input$,$ char $*$op$\_$left, char $*$op$\_$right$)$;

void calc$\_$output$($const char $*$op$\_$l$,$ int op$,$ const char $*$op$\_$r$,$ char $*$result$)$;

$//$ do not change any code in main. We are grading based on the format

$//$ of the output as given in the printfs in main.

int main$()\{$

char input$\_$line$[$MAXLINE$]$;

char left$\_$operand$[$MAXOPER$]$;

char right$\_$operand$[$MAXOPER$]$;

char answer$[$MAXOPER$]$;

int operator;

printf$("$

PP$3$: Arithmetic on GF$(47)$ with $+*/^$ using letters

$")$;

printf$("$Commands:

$\backslash$tabc$+$bbc

$\backslash$tturtle$/$frog

$\backslash$ttiger$^$one"$)$;

printf$("\backslash$tOperands are no more than $12$ letters and no spaces

$")$;

printf$("\backslash$tCtrl$-$d to quit

$")$;

printf$(">")$;

$//$ each call to fgets collects one line of input and stores in input$\_$line

$//$ BEWARE: fgets includes the end$-$of$-$line character $\text{'}$

$\text{'}$ in input$\_$line

while $($fgets$($input$\_$line, sizeof input$\_$line, stdin$)!=$ NULL$)\{$

$//$ clear for next round

left$\_$operand$[0]=$ right$\_$operand$[0]=$ answer$[0]=\text{'}\backslash 0\text{'}$;

$//$ check for valid grammar

operator $=$ process$\_$input$($input$\_$line, left$\_$operand, right$\_$operand$)$;

if $($operator $==$ ADD $||$ operator $==$ MUL

$||$ operator $==$ DIV $||$ operator $==$ POW$)\{$

$//$ print parsed input

printf$("\text{'}\%$s$\text{'}",$ left$\_$operand$)$;

printf$("\%$s $",$ operation$\_$str$[$operator$])$;

printf$("\text{'}\%$s$\text{'}=>",$ right$\_$operand$)$;

$//$ perform pseudo arithmetic

calc$\_$output$($left$\_$operand, operator, right$\_$operand, answer$)$;

$//$ print result

printf$("\text{'}\%$s$\text{'}$

$",$ answer$)$;

$\}$ else $\{$

printf$("$# $\%$s$",$ input$\_$line$)$;

$\}$

printf$(">")$;

$\}$

printf$("$

Goodbye

$")$;

return $0$;

$\}$

$/*$ Parse input of the form SOS where S is a string $($i$.$e$.,$ the operand$)$

$*$ and O $($i$.$e$.,$ the operator$)$ is a character.

$*$

$*$ A string S must consist of up to $12$ valid symbols a$-$z and A$-$U$.$

$*$ The operator O must be one character from: $+*/^$

$*$ Any other characters found in the input, including spaces, are

$*$ grammatically incorrect and invalidate the input.

$*$

$*$ There must be NO spaces anywhere in the input, including between

$*$ either SO$,$ OS$,$ or leading or trailing spaces.

$*$

$*$ Input: The input string is collected using fgets. Recall the end$-$of$-$line

$*$ character is included in the input string and marks the end of

$*$ the input. This string must not be changed.

$*$

$*$ Output: There are three outputs from this function.

$*$

$*$ The return value is one of NOOP, ADD, MUL, DIV, POW which are

$*$ named constants. If the input is invalid for any reason

$*$ then the output must be NOOP. Otherwise the return value

$*$ corresponds to operand O$.$

$*$

$*$ If the input is grammatically correct, then two strings are also

$*$ returned, one for each of the left and right operands. If the input

$*$ in invalid the two output strings are undefined.

$*/$

int process$\_$input$($const char $*$input$,$ char $*$op$\_$left, char $*$op$\_$right$)\{$

$//$ REPLACE the following with your code

op$\_$left$[0]=\text{'}$A$\text{'}$;

op$\_$left$[1]=\text{'}\backslash 0\text{'}$;

op$\_$right$[0]=\text{'}$A$\text{'}$;

op$\_$right$[1]=\text{'}\backslash 0\text{'}$;

return ADD;

$\}$

$/*$ Pseudo mathematical opertions on the two operands work as follows.

$*$

$*$ Each character is converted to an integer in the range $1..\mathrm{.}46,$ where a is $0,$

$*$ b is $1,$ c is $2,...,$ z is $25.$ The operation is then performed using

$*$ math on a finite field with no carries.

$*$

$*$ If the two input strings are not the same length, then each output character

$*$ beyond the length of the shorter string should be a copy of the character

$*$ from the longer string but with the opposite case.

$*$

$*$ Input: The two operand strings and the operator are assumed to be valid $($and

$*$ are verified as valid in the parse$\_$input function$).$

$*$

$*$ Output: The final string generated by the above rules is stored in the

$*$ output string named result. The input strings must not be

$*$ changed.

$*/$

void calc$\_$output$($const char $*$l$\_$op$,$ int op$,$ const char $*$r$\_$op$,$ char $*$result$)\{$

$//$ REPLACE the following with your code

result$[0]=\text{'}!\text{'}$;

result$[1]=\text{'}\backslash 0\text{'}$;

$\}$