need coding help on this, make sure test cases work.

$//$ 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{'}$;

$\}$