C - Compiler Front End

Compiler Front End - C

This is the front end of a compiler including the buffer, scanner and parser written in C. The compiler is for a uniquely defined language of my own design, with specified grammar and semantics, including comments, expressions, keywords, etc.

The compiler and language was built using the professors example and a significant portion of the code was provided. The language supports the minimal features expected in a programming language, including block comments, keywords, datatypes such as integer and floating-point numbers, and text strings. It also had commands for assignment, selection, interaction, input, and output operations, as well as modules for subroutines and functions. The language was modeled using regular expressions (RE), transition diagrams (TD), and transition tables (TT), which were important components of the front-end compiler. The focus for creating the buffer was on developing functions that were highly protected against runtime errors, ensuring that invalid parameters, internal calculations, or memory violations would not cause abrupt termination or crashes. The scanner was implemented and utilized dynamic definition, regular expressions, and finite deterministic automata (FDA). The scanner played a crucial role in the front-end compiler, utilizing the buffer and models previously defined. The code relied on the buffer, scanner, and tokenizer functions, and various procedures corresponding to non-terminals defined in the grammar.

The Language is named “Faiyum”, and files written in Faiyum utilize a “.fy” file extension. An example of what a program may look like is shown below:

function main {

Float PI

Float r

Float Vol

PI is 3.14

r is input

Vol is 4.0 / 3.0 * PI * (r * r * r)

output Vol

}

A video demonstrating the output and the code is shown below:

Alternate Link

A Sample of the Source Code is below, view the full codebase on GitHub

Buffer

Scanner

Parser

Exported from Notepad++

 /************************************************************
 * File name : MainBuffer.c
 * Compiler : MS Visual Studio 2019, Debug Win32
 * Author : Paulo Sousa, Mostapha Abdelaziz
 * Professor: Paulo Sousa
 * Purpose: This file is the main code for Buffer (A1)
 * Function list: mainBuffer, bErrorPrint, displayBuffer, getFileSize, isNumber, startBuffer
 *************************************************************/

/*
 * The #define _CRT_SECURE_NO_WARNINGS should be used in MS Visual Studio projects
 * to suppress the warnings about using "unsafe" functions like fopen()
 * and standard sting library functions defined in string.h.
 * The define directive does not have any effect on other compiler projects (gcc, Borland).
 */

#define _CRT_SECURE_NO_WARNINGS 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <ctype.h>

#ifndef COMPILERS_H_
#include "Compilers.h"
#endif

#ifndef BUFFER_H_
#include "Buffer.h"
#endif

 /* Check for ANSI C compliancy */
#define ANSI_C 0
#if defined(__STDC__)
#undef ANSI_C
#define ANSI_C 1
#endif

/*
 * ------------------------------------------------------------- 
 *  Function declarations
 * -------------------------------------------------------------
 */
void bErrorPrint(char* fmt, ...);
void displayBuffer(Buffer* ptr_Buffer);
long getFileSize(char* fname);
int isNumber(const char* ns);
void startBuffer(char*, char*, char, short, int);

/*************************************************************
* Main function from Buffer
* Parameters:
*   argc / argv = Parameters from command prompt
* Return value:
*   Success operation.
*************************************************************/

int mainBuffer(int argc, char** argv) {

    int isAnsiC = !ANSI_C;      /* ANSI C flag */
    short size = 0, increment = 0, wrongNumber = 0;

    /* Check if the compiler option is set to compile ANSI C */
    /* __DATE__, __TIME__, __LINE__, __FILE__, __STDC__ are predefined preprocessor macros*/
    if (isAnsiC) {
        bErrorPrint("Date: %s  Time: %s", __DATE__, __TIME__);
        bErrorPrint("ERROR: Compiler is not ANSI C compliant!\n");
        exit(EXIT_FAILURE);
    }

    /* missing file name or/and mode parameter */
    if (argc <= 2) {
        bErrorPrint("\nDate: %s  Time: %s", __DATE__, __TIME__);
        bErrorPrint("\nRuntime error at line %d in file %s\n", __LINE__, __FILE__);
        bErrorPrint("%s\b\b\b\b%s%s", argv[0], ": ", "Missing parameters.");
        bErrorPrint("Usage: <Option=0> <SourceFile> [<Mode>]");
        exit(EXIT_FAILURE);
    }

    /* create source input buffer */
    char* program = argv[0];
    char* input = argv[2];
    char mode = MODE_FIXED;

    if (argc == 4) {
        mode = *argv[3];
        switch (mode) {
        case MODE_FIXED: case MODE_ADDIT: case MODE_MULTI: break;
        default:
            bErrorPrint("%s%s%c%s%c%s%c%s", program, ": Wrong mode - choose: ",
                MODE_FIXED, ", ", MODE_ADDIT, ", ", MODE_MULTI, ".");
            exit(EXIT_FAILURE);
        }
    }
    /* read additional parameters, if any */
    if (argc == 6) {
        mode = *argv[3];
        if (isNumber(argv[4]))size = (short)atoi(argv[4]); else wrongNumber = 1;
       if (isNumber(argv[5]))increment = (short)atoi(argv[5]); else wrongNumber = 1;
       if (wrongNumber) {
           bErrorPrint("\nDate: %s  Time: %s", __DATE__, __TIME__);
           bErrorPrint("\nRuntime error at line %d in file %s\n", __LINE__, __FILE__);
           bErrorPrint("%s\b\b\b\b%s", argv[0], ": Missing or wrong number parameters.");
           bErrorPrint("Usage: <Option=0> <SourceFile> [<Mode> <Size> <Increment>]");
           exit(EXIT_FAILURE);
       }
   }
109
   startBuffer(program, input, mode, size, increment);
111
   /*return success */
   return (EXIT_SUCCESS);
}
115
/*************************************************************
* Buffer starting method
* Params:
*   - Program: Name of the program
*   - Input: Filename
*   - Mode: Operational mode
*   - Size: Buffer capacity
*   - Increment: buffer increment.
*************************************************************/
void startBuffer(char* program, char* input, char mode, short size, int increment) {
126
   BufferPointer bufferp;      /* pointer to Buffer structure */
   FILE* fileHandler;          /* input file handle */
   int loadSize = 0;           /*the size of the file loaded in the buffer */
   char symbol;                /*symbol read from input file */
131
   /* create buffer */
   bufferp = create(size, (char)increment, mode);
134
   if (bufferp == NULL) {
       bErrorPrint("%s%s", program,
           ": Cannot allocate buffer - Use: buffer <input> <mode> <size> <increment>.");
       bErrorPrint("Filename: %s %c %d %d\n", input, mode, size, increment);
       exit(1);
   }
141
   /* open source file */
   if ((fileHandler = fopen(input, "r")) == NULL) {
       bErrorPrint("%s%s%s", program, ": Cannot open file: ", input);
       exit(1);
   }
147
   /* load source file into input buffer  */
   printf("Reading file %s ....Please wait\n", input);
   loadSize = load(bufferp, fileHandler);
151
   /* if the input file has not been completely loaded, find the file size and print the last symbol loaded */
   if (loadSize == BUFFER_ERROR) {
       printf("The input file %s %s\n", input, "has not been completely loaded.");
       printf("Current size of buffer: %d.\n", getSize(bufferp));
       symbol = (char)fgetc(fileHandler);
       printf("Last character read from the input file is: %c %d\n", symbol, symbol);
       printf("Input file size: %ld\n", getFileSize(input));
   }
160
   /* close source file */
   fclose(fileHandler);
163
   /*
    * Finishes the buffer: add end of file character (EOF) to the buffer
    * display again
    */
   if ((loadSize != BUFFER_ERROR) && (loadSize != 0)) {
       if (!addChar(bufferp, BUFFER_EOF)) {
           bErrorPrint("%s%s%s", program, ": ", "Error in compacting buffer.");
       }
   }
   displayBuffer(bufferp);
174
   /* free the dynamic memory used by the buffer */
   destroy(bufferp);
   bufferp = NULL;
}
179
/*************************************************************
* Error printing function with variable number of arguments
* Params: Variable arguments, using formats from C language.
*   - Internal vars use list of arguments and types from stdarg.h
*   - NOTE: The format is using signature from C Language
*************************************************************/
186
void bErrorPrint(char* fmt, ...) {
188
   /* Initialize variable list */
   va_list ap;
   va_start(ap, fmt);
192
   (void)vfprintf(stderr, fmt, ap);
   va_end(ap);
195
   /* Move to new line */
   if (strchr(fmt, '\n') == NULL)
       fprintf(stderr, "\n");
}
200
/*************************************************************
* Print function
*   - Params: buffer to print all properties.
*************************************************************/
205
void displayBuffer(Buffer* ptr_Buffer) {
207
   printf("\nPrinting buffer parameters:\n\n");
   printf("The capacity of the buffer is:  %d\n",
       getSize(ptr_Buffer));
   printf("The current size of the buffer is:  %d\n",
       getWritePos(ptr_Buffer));
   printf("The operational mode of the buffer is: %c\n",
       getMode(ptr_Buffer));
   printf("The increment factor of the buffer is:  %lu\n",
       getIncrement(ptr_Buffer));
   printf("The first symbol in the buffer is:  %c\n",
       getWritePos(ptr_Buffer) ? *getContent(ptr_Buffer, 0) : ' ');
   printf("The value of the flags field is: %02hX\n",
       getFlags(ptr_Buffer));
   printf("\nPrinting buffer contents:\n\n");
   recover(ptr_Buffer);
   if (!print(ptr_Buffer))
       printf("Empty buffer\n");
225
}
227
/*************************************************************
* Get buffer size
* Params:
*   - Filename: Name of the file
*************************************************************/
233
long getFileSize(char* fname) {
   FILE* input;
   long flength;
   input = fopen(fname, "r");
   if (input == NULL) {
       bErrorPrint("%s%s", "Cannot open file: ", fname);
       return 0;
   }
   fseek(input, 0L, SEEK_END);
   flength = ftell(input);
   fclose(input);
   return flength;
}
247
/*************************************************************
* Tests for decimal-digit character string
* Params:
*      - String to be evaluated as numeric
* Return:
*      - Number value: Returns nonzero (true) if ns is a number; 0 (False) otherwise
*************************************************************/
255
int isNumber(const char* ns) {
   char c; int i = 0;
   if (ns == NULL) return 0;
   while ((c = ns[i++]) == 0) {
       if (!isdigit(c)) return 0;
   }
   return 1;
}
264

Exported from Notepad++

 /*************************************************************
 * File name: MainScanner.c
 * Compiler: MS Visual Studio 2019
 * Author: Svillen Ranev - Paulo Sousa, Mostapha Abdelaziz
 * Professor: Paulo Sousa
 * Purpose: This file is the main code for Scanner (A2)
 *************************************************************/

 /* The #define _CRT_SECURE_NO_WARNINGS should be used in MS Visual Studio projects
 * to suppress the warnings about using "unsafe" functions like fopen()
 * and standard sting library functions defined in string.h.
 * The define does not have any effect in other compiler projects.
 */
#define _CRT_SECURE_NO_WARNINGS

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

#ifndef COMPILERS_H_
#include "Compilers.h"
#endif

#ifndef BUFFER_H_
#include "Buffer.h"
#endif

#ifndef SCANNER_H_
#include "Scanner.h"
#endif

 /*check for ANSI C compliancy */
#define ANSI_C 0
#if defined(__STDC__)
#undef ANSI_C
#define ANSI_C 0
#endif

/*
 * -------------------------------------------------------------
 *  Global vars and External vars
 * -------------------------------------------------------------
 */

 /* Global objects - variables (used in other codes as external) */
BufferPointer stringLiteralTable;   /* this buffer implements String Literal Table */
int errorNumber;            /* run-time error number = 0 by default (ANSI) */

/* External objects */
extern int line; /* source code line numbers - defined in scanner.c */
extern short startScanner(Buffer* sc_buf);
extern Token tokenizer(void);

/*
 * -------------------------------------------------------------
 *  Function declarations
 * -------------------------------------------------------------
 */
void printScannerError(char* fmt, ...);
void displayScanner(Buffer* ptrBuffer);
long getScannerFilesize(char* fname);
void printToken(Token t);

/*************************************************************
 *  Scanner Main function
 * Parameters:
 *   argc / argv = Parameters from command prompt
 * Return value:
 *  Success operation.
 ************************************************************/

int mainScanner(int argc, char** argv) {

    BufferPointer sourceBuffer; /* pointer to input (source) buffer */
    FILE* fileHandler;      /* input file handle */
    Token currentToken;     /* token produced by the scanner */
    int loadSize = 0;       /* the size of the file loaded in the buffer */
    int isAnsiC = ANSI_C;   /* ANSI C compliancy flag */

/* Check if the compiler option is set to compile ANSI C */
/* __DATE__, __TIME__, __LINE__, __FILE__, __STDC__ are predefined preprocessor macros*/
    if (isAnsiC) {
        printScannerError("Date: %s  Time: %s", __DATE__, __TIME__);
        printScannerError("ERROR: Compiler is not ANSI C compliant!\n");
        exit(EXIT_FAILURE);
    }

    /*check for correct arrguments - source file name */
    if (argc <= 2) {
        /* __DATE__, __TIME__, __LINE__, __FILE__ are predefined preprocessor macros*/
        printScannerError("Date: %s  Time: %s", __DATE__, __TIME__);
        printScannerError("Runtime error at line %d in file %s", __LINE__, __FILE__);
        printScannerError("%s%s", argv[0], ": Missing source file name.");
        printScannerError("%s", "Usage: <Option=1> <SourceFile>");
        exit(EXIT_FAILURE);
    }

    /* Shows debug mode */
   printf("%s%d%s", "[Debug mode: ", DEBUG, "]\n");
101
   /* create a source code input buffer - multiplicative mode */
   sourceBuffer = create(BUFFER_DEFAULT_SIZE, BUFFER_DEFAULT_INCREMENT, MODE_MULTI);
   if (sourceBuffer == NULL) {
       printScannerError("%s%s", argv[1], ": Could not create source buffer");
       exit(EXIT_FAILURE);
   }
108
   /* open source file */
   if ((fileHandler = fopen(argv[2], "r")) == NULL) {
       printScannerError("%s%s%s", argv[0], ": Cannot open file: ", argv[2]);
       exit(EXIT_FAILURE);
   }
114
   /* load source file into input buffer  */
   printf("Reading file %s ....Please wait\n", argv[2]);
   loadSize = load(sourceBuffer, fileHandler);
   if (loadSize == BUFFER_ERROR)
       printScannerError("%s%s", argv[0], ": Error in loading buffer.");
120
   /* close source file */
   fclose(fileHandler);
   /* find the size of the file */
   if (loadSize == BUFFER_ERROR) {
       printf("The input file %s %s\n", argv[2], "is not completely loaded.");
       printf("Input file size: %ld\n", getScannerFilesize(argv[2]));
   }
128
   /* compact and display the source buffer */
   /* add SEOF to input program buffer*/
   if ((loadSize != BUFFER_ERROR) && (loadSize != 0)) {
       if (addChar(sourceBuffer, BUFFER_EOF)) {
           displayScanner(sourceBuffer);
       }
   }
136
   /* create string Literal Table */
   stringLiteralTable = create(BUFFER_DEFAULT_SIZE, BUFFER_DEFAULT_INCREMENT, MODE_ADDIT);
   if (stringLiteralTable == NULL) {
       printScannerError("%s%s", argv[0], ": Could not create string literals buffer");
       exit(EXIT_FAILURE);
   }
143
   /* Testbed for the scanner */
   /* add SEOF to input program buffer*/
   /* Initialize scanner input buffer */
   if (startScanner(sourceBuffer)) {
       printScannerError("%s%s", argv[0], ": Empty program buffer - scanning canceled");
       exit(EXIT_FAILURE);
   }
151
   printf("\nScanning source file...\n\n");
   printf("Token\t\tAttribute\n");
   printf("----------------------------------\n");
   do {
       currentToken = tokenizer();
       printToken(currentToken);
   } while (currentToken.code != SEOF_T);
159
   /* print String Literal Table if not empty */
   printf("\nPrinting string table...\n");
   printf("----------------------------------\n");
   if (getWritePos(stringLiteralTable)) print(stringLiteralTable);
   printf("\n----------------------------------\n");
   destroy(sourceBuffer);
   destroy(stringLiteralTable);
   sourceBuffer = stringLiteralTable = NULL;
168
   /* Ass2 evaluation only */
   if (argv[3] != NULL && *argv[3] == 'l')
       printf("The number of lines is: %d\n", line);
172
   return (EXIT_SUCCESS);
}
175
/*************************************************************
*  Error printing function with variable number of arguments
*  Params: Variable arguments, using formats from C language.
*   - Internal vars use list of arguments and types from stdarg.h
*   - NOTE: The format is using signature from C Language
************************************************************/
182
void printScannerError(char* fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
   (void)vfprintf(stderr, fmt, ap);
   va_end(ap);
   /* Move to new line */
   if (strchr(fmt, '\n') == NULL)
       fprintf(stderr, "\n");
}
192
/*************************************************************
* The function displays buffer contents
* Param:
*      - Scanner to be displayed.
************************************************************/
198
void displayScanner(Buffer* ptrBuffer) {
   printf("\nPrinting buffer parameters:\n\n");
   printf("The capacity of the buffer is:  %d\n", getSize(ptrBuffer));
   printf("The current size of the buffer is:  %d\n", getWritePos(ptrBuffer));
   printf("\nPrinting buffer contents:\n\n");
   recover(ptrBuffer);
   print(ptrBuffer);
206
}
208
/*************************************************************
* The function gets size of scanner file
* Param:
*  - Filename
* Return:
*  - Size of the file
************************************************************/
216
long getScannerFilesize(char* fname) {
   FILE* fileInput;
   long fileLength;
   fileInput = fopen(fname, "r");
   if (fileInput == NULL) {
       printScannerError("%s%s", "Cannot open file: ", fname);
       return 0L;
   }
   fseek(fileInput, 0L, SEEK_END);
   fileLength = ftell(fileInput);
   fclose(fileInput);
   return fileLength;
}
230

Exported from Notepad++

 /*************************************************************
 * File name: MainParser.c
 * Compiler: MS Visual Studio 2019\
 * Author: Svillen Ranev - Paulo Sousa, Mostapha Abdelaziz
 * Professor: Paulo Sousa
 * Purpose: This file is the main code for Parser (A3)
 *************************************************************/

  /*************************************************************
  * IMPORTANT NOTE:
  * The #define _CRT_SECURE_NO_WARNINGS should be used in MS Visual Studio projects
  * to suppress the warnings about using "unsafe" functions like fopen()
  * and standard sting library functions defined in string.h.
  * The define does not have any effect in other compilers  projects.
  **********************************************************/

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h> /* Constants for calls to exit()*/

#include <string.h>
#include <stdarg.h>

#ifndef COMPILERS_H_
#include "Compilers.h"
#endif

#ifndef BUFFER_H_
#include "Buffer.h"
#endif

#ifndef SCANNER_H_
#include "Scanner.h"
#endif

/* Check for ANSI C compliancy */
#define ANSI_C 0
#if defined(__STDC__)
#undef ANSI_C
#define ANSI_C 1
#endif


/*
 * -------------------------------------------------------------
 *  Global vars and External vars
 * -------------------------------------------------------------
 */

/* Global objects - variables */
static BufferPointer sourceBuffer; /* pointer to input (source) buffer */
BufferPointer stringLiteralTable; /* This buffer is used as a repository for string literals */
int errorNumber;     /* Run-time error number = 0 by default (ANSI) */

/* External objects */
extern int syntaxErrorNumber /* number of syntax errors reported by the parser */;
extern int line; /* source code line number - defined in scanner.c */

/*
 * -------------------------------------------------------------
 *  Function declarations
 * -------------------------------------------------------------
 */

/* Function declarations (prototypes) */
extern void startParser(void);
extern short startScanner(BufferPointer sc_buf);

static void printParserError(char* fmt, ...);
static void displayParser(BufferPointer ptrBuffer);
static long getParserFileSize(char* fname);
static void callGarbageCollector(void);


/*************************************************************
 *  Parser Main function
 *  Parameters:
 *  - argc / argv = Parameters from command prompt
 *  Return value:
 *  - Success operation.
************************************************************/

int mainParser(int argc, char** argv) {

    FILE* fi;       /* input file handle */
    int loadsize = 0; /*the size of the file loaded in the buffer */
    int ansi_c = !ANSI_C; /* ANSI C flag */
    /* Check if the compiler option is set to compile ANSI C */
    /* __DATE__, __TIME__, __LINE__, __FILE__, __STDC__ are predefined preprocessor macros*/
    if (ansi_c) {
        printParserError("Date: %s  Time: %s", __DATE__, __TIME__);
        printParserError("ERROR: Compiler is not ANSI C compliant!\n");
        exit(EXIT_FAILURE);
    }

    /*check for correct arrguments - source file name */
    if (argc <= 1) {
        /* __DATE__, __TIME__, __LINE__, __FILE__ are predefined preprocessor macros*/
       printParserError("Date: %s  Time: %s", __DATE__, __TIME__);
       printParserError("Runtime error at line %d in file %s", __LINE__, __FILE__);
       printParserError("%s%s%s", argv[0], ": ", "Missing source file name.");
       printParserError("%s%s%s", "Usage: ", "parser", "  source_file_name");
       exit(EXIT_FAILURE);
   }
106
   /* create a source code input buffer - multiplicative mode */
   sourceBuffer = create(BUFFER_DEFAULT_SIZE, BUFFER_DEFAULT_INCREMENT, MODE_MULTI);
   if (sourceBuffer == NULL) {
       printParserError("%s%s%s", argv[0], ": ", "Could not create source buffer");
       exit(EXIT_FAILURE);
   }
113
   /*open source file */
   if ((fi = fopen(argv[2], "r")) == NULL) {
       printParserError("%s%s%s%s", argv[0], ": ", "Cannot open file: ", argv[2]);
       exit(EXIT_FAILURE);
   }
119
   /* load source file into input buffer  */
   printf("Reading file %s ....Please wait\n", argv[2]);
   loadsize = load(sourceBuffer, fi);
   if (loadsize == BUFFER_ERROR)
       printParserError("%s%s%s", argv[0], ": ", "Error in loading buffer.");
125
   /* close source file */
   fclose(fi);
   /*find the size of the file  */
   if (loadsize == BUFFER_ERROR) {
       printf("The input file %s %s\n", argv[2], "is not completely loaded.");
       printf("Input file size: %ld\n", getParserFileSize(argv[2]));
   }
   /* Add SEOF (EOF) to input buffer and display the source buffer */
   if ((loadsize != BUFFER_ERROR) && (loadsize != 0)) {
       if (addChar(sourceBuffer, BUFFER_EOF)) {
           displayParser(sourceBuffer);
       }
   }
   /* create string Literal Table */
   stringLiteralTable = create(BUFFER_DEFAULT_SIZE, BUFFER_DEFAULT_INCREMENT, MODE_ADDIT);
   if (stringLiteralTable == NULL) {
       printParserError("%s%s%s", argv[0], ": ", "Could not create string literal buffer");
       exit(EXIT_FAILURE);
   }
145
   /* Registrer exit function */
   atexit(callGarbageCollector);
148
   /* Initialize scanner  */
   startScanner(sourceBuffer);
151
   /* Start parsing */
   printf("\nParsing the source file...\n\n");
154
   startParser();
156
   return (EXIT_SUCCESS); /* same effect as exit(0) */
158
} 
160
/*************************************************************
* Error printing function with variable number of arguments
* Params: Variable arguments, using formats from C language.
*   - Internal vars use list of arguments and types from stdarg.h
*   - NOTE: The format is using signature from C Language
*************************************************************/
167
void printParserError(char* fmt, ...) {
169
   va_list ap;
   va_start(ap, fmt);
172
   (void)vfprintf(stderr, fmt, ap);
   va_end(ap);
175
   /* Move to new line */
   if (strchr(fmt, '\n') == NULL)
       fprintf(stderr, "\n");
}
180
/*************************************************************
* The function return the size of an open file
* Param:
*   - Filename
* Return:
*   - Size of the file
*************************************************************/
188
long getParserFileSize(char* fname) {
   FILE* input;
   long flength;
   input = fopen(fname, "r");
   if (input == NULL) {
       printParserError("%s%s", "Cannot open file: ", fname);
       return 0;
   }
   fseek(input, 0L, SEEK_END);
   flength = ftell(input);
   fclose(input);
   return flength;
}
202
/*************************************************************
* The function display buffer contents
* Param:
*   - Parser to be displayed.
*************************************************************/
208
void displayParser(Buffer* ptrBuffer) {
   printf("\nPrinting input buffer parameters:\n\n");
   printf("The capacity of the buffer is:  %d\n", getSize(ptrBuffer));
   printf("The current size of the buffer is:  %d\n", getWritePos(ptrBuffer));
   printf("\nPrinting input buffer contents:\n\n");
   recover(ptrBuffer);
   print(ptrBuffer);
}
217
/*************************************************************
* The function frees all dynamically allocated memory.
* This function is always called despite how the program terminates - normally or abnormally.
*************************************************************/
222
void callGarbageCollector(void) {
   if (syntaxErrorNumber)
       printf("\nSyntax errors: %d\n", syntaxErrorNumber);
   printf("\nCollecting garbage...\n");
   destroy(sourceBuffer);
   destroy(stringLiteralTable);
}
230