Step2Reader.c

/*
************************************************************
* COMPILERS COURSE - Algonquin College
* Code version: Fall, 2025
* Author: Alex Vu and Yassine Amraoui
* Professors: Paulo Sousa
************************************************************

		"\t=-------------------------------------------------------------------=\n",
		"\t|               COMPILERS - ALGONQUIN COLLEGE (S25)                 |\n",
		"\t=-------------------------------------------------------------------=\n",
		"\t    @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@    \n",
		"\t    @@                                                        @@    \n",
		"\t    @@           %&@@@@@@@@@@@         @@@@@@@@@@@@@@@@@@     @@    \n",
		"\t    @@       @%% (@@@@@@@@@  @                  @             @@    \n",
		"\t    @@      @& @   @ @       @                  @             @@    \n",
		"\t    @@     @ @ %  / /   @@@@@@                  @             @@    \n",
		"\t    @@      & @ @  @@                           @             @@    \n",
		"\t    @@       @/ @*@ @ @   @                     @             @@    \n",
		"\t    @@           @@@@  @@ @ @                   @             @@    \n",
		"\t    @@            /@@    @@@ @                  @             @@    \n",
		"\t    @@     @      / /     @@ @                  @             @@    \n",
		"\t    @@     @ @@   /@/   @@@ @                   @             @@    \n",
		"\t    @@     @@@@@@@@@@@@@@@                      @             @@    \n",
		"\t    @@                                                        @@    \n",
		"\t    @@                 S T R U C T U R A L                    @@    \n",
		"\t    @@           By Alex Vu and Yassine Amraoui               @@    \n",
		"\t    @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@    \n",
		"\t                                                                    \n",
		"\t[COMPILER SCRIPT ..................................................]\n",*/

/*
***********************************************************
* File name: Reader.c
* Compiler: MS Visual Studio 2022
* Course: CST 8152 – Compilers, Lab Section: [011, 012, 013]
* Assignment: A12.
* Date: Jan 01 2025
* Professor: Paulo Sousa
* Purpose: This file is the main code for Buffer/Reader (A12)
************************************************************
*/

/*
 *.............................................................................
 * MAIN ADVICE:
 * - Please check the "TODO" labels to develop your activity.
 * - Review the functions to use "Defensive Programming".
 *.............................................................................
 */

#include <ctype.h>
#include <string.h>

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

#ifndef CODER_H_
#include "Step1Coder.h"
#endif

#ifndef READER_H_
#include "Step2Reader.h"
#endif

/*
***********************************************************
* Function name: readerCreate
* Purpose: Creates the buffer reader according to capacity, increment
	factor and operational mode ('f', 'a', 'm')
* Author: Svillen Ranev / Paulo Sousa
* History/Versions: S22
* Called functions: calloc(), malloc()
* Parameters:
*   size = initial capacity
*   increment = increment factor
*   mode = operational mode
* Return value: bPointer (pointer to reader)
* Algorithm: Allocation of memory according to inicial (default) values.
* TODO ......................................................
*	- Adjust datatypes for your LANGUAGE.
*   - Use defensive programming
*	- Check boundary conditions
*	- Check flags.
*************************************************************
*/

/*
 * Function: readerCreate
 * Purpose : Allocates and initializes a new buffer for the Reader.
 * Params  : size   -> initial buffer size
 *           factor -> growth factor for buffer reallocation
 * Returns : BufferPointer -> pointer to the newly allocated buffer,
 *           NULL on failure.
 */
BufferPointer readerCreate(struct_int size, struct_real factor) {
	BufferPointer readerPointer = NULL;

	/* Defensive programming: check size */
	if (size <= 0 || size > READER_MAX_SIZE) {
		size = READER_DEFAULT_SIZE; /* fallback */
	}

	/* Defensive programming: check factor */
	if (factor < 0.0f || factor > 1.0f) {
		factor = READER_DEFAULT_FACTOR; /* fallback */
	}

	/* Allocate the buffer structure */
	readerPointer = (BufferPointer)calloc(1, sizeof(Buffer));
	if (readerPointer == NULL) {
		return NULL; /* allocation failed */
	}

	/* Allocate the content array */
	readerPointer->content = (struct_strg)malloc(size);
	if (readerPointer->content == NULL) {
		free(readerPointer);
		return NULL;
	}

	/* Initialize histogram */
	for (int i = 0; i < NCHAR; i++) {
		readerPointer->histogram[i] = 0;
	}

	/* Initialize errors */
	readerPointer->numReaderErrors = 0;
	readerPointer->checkSum = 0;

	/* Update properties */
	readerPointer->size = size;
	readerPointer->factor = factor;

	/* Initialize position offsets */
	readerPointer->position.wrte = STRUCT_FALSE;
	readerPointer->position.read = STRUCT_FALSE;
	readerPointer->position.mark = STRUCT_FALSE;

	/* Initialize flags */
	readerPointer->flags.isEmpty = STRUCT_TRUE;
	readerPointer->flags.isFull = STRUCT_FALSE;
	readerPointer->flags.isRead = STRUCT_FALSE;
	readerPointer->flags.isMoved = STRUCT_FALSE;

	/* The created flag must be signalized as EMP */
	// Equivalent to setting `isEmpty = 1`, which we already did.

	return readerPointer;
}



/*
***********************************************************
* Function name: readerAddChar
* Purpose: Adds a char to buffer reader
* Parameters:
*   readerPointer = pointer to Buffer Reader
*   ch = char to be added
* Return value:
*	readerPointer (pointer to Buffer Reader)
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/

struct_void readerSetPos(BufferPointer const readerPointer, struct_int pos) {
	if (!readerPointer || pos < 0 || pos > readerPointer->position.wrte) {
		return;
	}
	readerPointer->position.read = pos;
	readerPointer->flags.isRead = (pos >= readerPointer->position.wrte) ? STRUCT_TRUE : STRUCT_FALSE;
}

BufferPointer readerAddChar(BufferPointer const readerPointer, struct_char ch) {

	/* Defensive: reader must exist and content must exist */
	if (readerPointer == NULL) {
		errorPrint("Error: readerAddChar: invalid reader pointer.");
		return NULL;
	}
	if (readerPointer->content == NULL) {
		errorPrint("Error: readerAddChar: invalid reader content.");
		return NULL;
	}

	/* --- (optional) debug: log raw byte BEFORE any normalization --- */
#if DEBUG_SCANNER
	DBG("readerAddChar: ch=%d (0x%02X) wrte=%d size=%d\n",
		(int)(unsigned char)ch, (unsigned int)(unsigned char)ch,
		(int)readerPointer->position.wrte, (int)readerPointer->size);
#endif
	/* --- Minimal acceptance/normalization additions --- */

	/* 1) Skip CR: normalize CRLF -> LF by ignoring '\r' */
	if (ch == (struct_char)'\r') {
		return readerPointer; /* accept but don't store */
	}

	/* 2) Ignore UTF-8 BOM (EF BB BF) if it appears at the very start */
	if (readerPointer->position.wrte == 0) {
		unsigned char uch0 = (unsigned char)ch;
		if (uch0 == 0xEF || uch0 == 0xBB || uch0 == 0xBF) {
			return readerPointer; /* drop BOM bytes */
		}
	}
	/* --- End minimal additions (NO charset validation here) --- */

	/* Can we include without realloc? (assumes size is in bytes, struct_char is 1 byte) */
	if (readerPointer->position.wrte + (struct_int)sizeof(struct_char) < readerPointer->size) {
		readerPointer->flags.isFull = STRUCT_FALSE;
	}
	else { /* Buffer full -> grow */
		struct_real  ratio = (struct_real)(1.0 + readerPointer->factor);
		struct_size  oldSize = readerPointer->size;
		struct_char* oldAddr = readerPointer->content;

		struct_int newSize = (struct_int)(oldSize + (oldSize * ratio));

		/* must grow, must be positive, and result < READER_MAX_SIZE */
		if (newSize <= oldSize || newSize <= 0 || newSize >= READER_MAX_SIZE) {
			errorPrint("Error: readerAddChar: invalid growth ratio; cannot include char.");
			return NULL;
		}

		/* realloc via temp pointer */
		struct_char* newAddr = (struct_strg)realloc(oldAddr, (struct_size)newSize);
		if (!newAddr) {
			errorPrint("Error: readerAddChar: realloc failed.");
			/* DO NOT free(newAddr); it is NULL. Keep old block intact. */
			return NULL;
		}

		/* If address didn't change, isMoved must be False */
		if (newAddr == oldAddr) {
			readerPointer->flags.isMoved = STRUCT_FALSE;
		}

		readerPointer->content = newAddr;
		readerPointer->size = newSize;
		readerPointer->flags.isFull = STRUCT_FALSE;

		/* Sanity: ensure there is now space */
		if ((readerPointer->position.wrte * (struct_int)sizeof(struct_char)) >= readerPointer->size) {
			errorPrint("Error: readerAddChar: no space after growth.");
			return NULL;
		}
	}

	/* Include the char and advance write offset */
	readerPointer->content[readerPointer->position.wrte++] = ch;

	/* increment histogram — index safely */
	{
		unsigned char uch = (unsigned char)ch;
		size_t hcap = sizeof(readerPointer->histogram) / sizeof(readerPointer->histogram[0]);
		if ((size_t)uch < hcap) {
			readerPointer->histogram[(struct_int)uch]++;
		}
	}

	/* Set isEmpty to false */
	readerPointer->flags.isEmpty = STRUCT_FALSE;

	/* Update isFull if exactly filled */
	if ((readerPointer->position.wrte * (struct_int)sizeof(struct_char)) >= readerPointer->size) {
		readerPointer->flags.isFull = STRUCT_TRUE;
	}

	return readerPointer;
}

/*
***********************************************************
* Function name: readerClear
* Purpose: Clears the buffer reader
* Parameters:
*   readerPointer = pointer to Buffer Reader
* Return value:
*	Boolean value about operation success
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/

struct_boln readerClear(BufferPointer const readerPointer) {
	/* Defensive programming: check if buffer exists */
	if (readerPointer == NULL) {
		return STRUCT_FALSE;
	}

	/* Reset positions */
	readerPointer->position.wrte = 0;
	readerPointer->position.read = 0;
	readerPointer->position.mark = 0;

	/* Reset flags (as during creation) */
	readerPointer->flags.isEmpty = 1;
	readerPointer->flags.isFull = 0;
	readerPointer->flags.isRead = 0;
	readerPointer->flags.isMoved = 0;

	/* Reset errors and checksum */
	readerPointer->numReaderErrors = 0;
	readerPointer->checkSum = 0;


	return STRUCT_TRUE; 
}


/*
***********************************************************
* Function name: readerFree
* Purpose: Releases the buffer address
* Parameters:
*   readerPointer = pointer to Buffer Reader
* Return value:
*	Boolean value about operation success
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/
struct_boln readerFree(BufferPointer const readerPointer) {
	/* Defensive programming */
	if (readerPointer == NULL) {
		errorPrint("Error: readerFree: invalid buffer pointer");
		return STRUCT_FALSE;
	}
	if (readerPointer->content == NULL) {
		errorPrint("Error: readerFree: invalid buffer content");
		return STRUCT_FALSE;
	}

	/* Free memory (buffer/content) */
	if (readerPointer->content) {
		free(readerPointer->content);
	}

	free((void*)readerPointer);

	return STRUCT_TRUE;
}

/*
***********************************************************
* Function name: readerIsFull
* Purpose: Checks if buffer reader is full
* Parameters:
*   readerPointer = pointer to Buffer Reader
* Return value:
*	Boolean value about operation success
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/

struct_boln readerIsFull(BufferPointer const readerPointer) {
	/* Defensive programming: check if buffer exists */
	if (readerPointer == NULL) {
		return STRUCT_FALSE; /* Buffer does not exist */
	}

	/* Check if reader is full */
	if (readerPointer->flags.isFull) {
		return STRUCT_TRUE;  /* Buffer is full */
	}

	return STRUCT_FALSE;     /* Buffer is not full */
}



/*
***********************************************************
* Function name: readerIsEmpty
* Purpose: Checks if buffer reader is empty.
* Parameters:
*   readerPointer = pointer to Buffer Reader
* Return value:
*	Boolean value about operation success
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/
struct_boln readerIsEmpty(BufferPointer const readerPointer) {
	/* Defensive programming */
	if (readerPointer == NULL) {
		return STRUCT_FALSE;
	}
	if (readerPointer->content == NULL) {
		errorPrint("Error: readerIsEmpty: invalid buffer content");
		return STRUCT_FALSE;
	}

	/* Check consistency between empty flag and write position */
	if (readerPointer->flags.isEmpty && readerPointer->position.wrte != 0) {
		errorPrint("Warning: readerIsEmpty: flag indicates empty buffer but write position indicates otherwise.");
	}

	/* Check flag if buffer is EMP */
	return readerPointer->flags.isEmpty ? STRUCT_TRUE : STRUCT_FALSE;
}

/*
***********************************************************
* Function name: readerSetMark
* Purpose: Adjust the position of mark in the buffer
* Parameters:
*   readerPointer = pointer to Buffer Reader
*   mark = mark position for char
* Return value:
*	Boolean value about operation success
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/

struct_boln readerSetMark(BufferPointer const readerPointer, struct_int mark) {
	/* Defensive programming: check if buffer exists */
	if (readerPointer == NULL) {
		return STRUCT_FALSE; /* invalid buffer */
	}

	/* Defensive programming: check if mark is valid */
	/* mark must be between 0 and the current write offset */
	if (mark < 0 || mark > readerPointer->position.wrte) {
		return STRUCT_FALSE; /* invalid mark */
	}

	/* Adjust the mark offset */
	readerPointer->position.mark = mark;

	return STRUCT_TRUE; /* success */
}

/*
***********************************************************
* Function name: readerPrint
* Purpose: Prints the string in the buffer.
* Parameters:
*   readerPointer = pointer to Buffer Reader
* Return value:
*	Number of chars printed.
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/
struct_int readerPrint(BufferPointer const readerPointer) {
	struct_int	count	= 0;
	struct_char ch		= 0;
	/* TO_DO: Defensive programming (including invalid chars) */
	if (!readerPointer || !readerPointer->content) {
		errorPrint("Error: readerPrint: invalid reader pointer/content.");
		return 0;
	}

	/* TO_DO: Print the buffer content */
	/* loop until end of buffer */
	while (STRUCT_TRUE) {
		ch = readerGetChar(readerPointer);

		/* Check end of buffer */
		if (readerPointer->flags.isRead) {
			break;
		}
		/* print valid chars */
		if ((struct_byte)ch < NCHAR) {
			printf("%c", ch);
			count++;
		} 
		else {
			/* Invalid char, increment reader errors */
			readerPointer->numReaderErrors++;
		}
	}

	return count;
}

/*
***********************************************************
* Function name: readerLoad
* Purpose: Loads the string in the buffer with the content of
	an specific file.
* Parameters:
*   readerPointer = pointer to Buffer Reader
*   fileDescriptor = pointer to file descriptor
* Return value:
*	Number of chars read and put in buffer.
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/
struct_int readerLoad(BufferPointer const readerPointer, struct_strg fileName) {
	struct_int i = 0;

	/* Defensive programming */
	if (readerPointer == NULL || fileName == NULL) {
		errorPrint("readerLoad: invalid parameters.");
		return READER_ERROR;
	}

	/* decode the input file and store it in a string */
	struct_strg decoded = vigenereMem(fileName, STR_LANGNAME, DECYPHER);
	/*
	char decoded[500], c;
	FILE* file = fopen(fileName, "r");
	while ((c = fgetc(file)) != EOF && i < 500 - 1) {
		decoded[i++] = (char)c;
	}
	decoded[i] = '\0';
	*/
	if (decoded == NULL) {
		errorPrint("Error: vigenereMem: decode failed.");
		return READER_ERROR;
	}

	/* read each character of the file into the buffer */
	struct_int numChars = 0;
	struct_strg p = NULL;
	for (p = decoded; *p != READER_TERMINATOR; ++p) {
		if (readerAddChar(readerPointer, (char)*p) == NULL) {
			errorPrint("Error: readerAddChar: add char failed");
			return READER_ERROR;
		}
		++numChars;
	}
	/* If vigenereMem mallocs, free it here */
	// free(decoded);

	return numChars; /* number of chars successfully loaded */
}

/*
***********************************************************
* Function name: readerRecover
* Purpose: Rewinds the buffer.
* Parameters:
*   readerPointer = pointer to Buffer Reader
* Return value
*	Boolean value about operation success
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/
struct_boln readerRecover(BufferPointer const readerPointer) {
	/* Defensive programming */
	if (!readerPointer) {
		errorPrint("Error: readerRecover: invalid reader pointer/content.");
		return STRUCT_FALSE;
	}
	if (!readerPointer->content) {
		errorPrint("Error: readerRecover: invalid buffer content.");
		return STRUCT_FALSE;
	}
	if (readerPointer->size < 0) {
		errorPrint("Error: readerRecover: invalid buffer size.");
		return STRUCT_FALSE;
	}

	/* Adjust read and mark to zero */
	readerPointer->position.read = 0;
	readerPointer->position.mark = 0;

	/* clear isRead flag */
	readerPointer->flags.isRead = 0;

	return STRUCT_TRUE;
}


/*
***********************************************************
* Function name: readerRetract
* Purpose: Retracts the buffer to put back the char in buffer.
* Parameters:
*   readerPointer = pointer to Buffer Reader
* Return value:
*	Boolean value about operation success
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/
struct_boln readerRetract(BufferPointer const readerPointer) {
	/* TO_DO: Defensive programming */
	/* TO_DO: Retract (return 1 pos read) */
	if (readerPointer == NULL) {
		errorPrint("Error: readerRetract: invalid reader buffer pointer");
		return STRUCT_FALSE;
	}

	/* Retract read position by one */
	readerPointer->position.read--;

	return STRUCT_TRUE;
}

/*
***********************************************************
* Function name: readerRestore
* Purpose: Resets the buffer.
* Parameters:
*   readerPointer = pointer to Buffer Reader
* Return value:
*	Boolean value about operation success
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/
struct_boln readerRestore(BufferPointer const readerPointer) {
	/* Defensive programming */
	if (!readerPointer) {
		errorPrint("Error: readerRestore: invalid reader pointer/content.");
		return STRUCT_FALSE;
	}

	/* Check boundary conditions */
	if (readerPointer->position.mark < 0 ||
		readerPointer->position.mark > readerPointer->position.wrte) {
		errorPrint("Error: readerRestore: invalid mark position");
		readerPointer->numReaderErrors++;
		return STRUCT_FALSE;
	}

	/* Restore read to mark */
	readerPointer->position.read = readerPointer->position.mark;

	return STRUCT_TRUE;
}



/*
***********************************************************
* Function name: readerGetChar
* Purpose: Returns the char in the getC position.
* Parameters:
*   readerPointer = pointer to Buffer Reader
* Return value:
*	Char in the getC position.
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/
struct_char readerGetChar(BufferPointer const readerPointer) {
	/* Defensive programming */
	if (!readerPointer || !readerPointer->content) {
		errorPrint("Error: readerGetChar: invalid reader pointer/content.");
		return READER_ERROR;
	}

	/* End-of-buffer condition */
	if (readerPointer->position.read >= readerPointer->position.wrte) {
		readerPointer->flags.isRead = STRUCT_TRUE;  /* set END flag */
		return READER_TERMINATOR; /* '\0' */
	}

	/* Not at end yet */
	readerPointer->flags.isRead = STRUCT_FALSE;

	/* Get current char and advance read */
	struct_char c = readerPointer->content[readerPointer->position.read];
	readerPointer->position.read++;

	return c;
}


/*
***********************************************************
* Function name: readerGetContent
* Purpose: Returns the pointer to String.
* Parameters:
*   readerPointer = pointer to Buffer Reader
*   pos = position to get the pointer
* Return value:
*	Position of string char.
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/
struct_strg readerGetContent(BufferPointer const readerPointer, struct_int pos) {
	/* Defensive programming */
	if (readerPointer == NULL || readerPointer->content == NULL) {
		errorPrint("Error: readerGetContent: invalid reader pointer/content.");
		return NULL;
	}

	/* Boundary conditions: pos must be valid */
	if (pos < 0 || pos >= readerPointer->position.wrte) {
		errorPrint("Error: readerGetContent: position out of bounds.");
		readerPointer->numReaderErrors++;
		return NULL;
	}

	/* Return pointer to content at given position */
	return readerPointer->content + pos;
}

/*
***********************************************************
* Function name: readerGetPosRead
* Purpose: Returns the value of getCPosition.
* Parameters:
*   readerPointer = pointer to Buffer Reader
* Return value:
*	The read position offset.
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/
struct_int readerGetPosRead(BufferPointer const readerPointer) {
	/* Defensive programming: check if buffer exists */
	if (readerPointer == NULL) {
		errorPrint("readerGetPosRead: invalid buffer pointer.");
		return READER_ERROR;
	}

	/* Return the current read position */
	return readerPointer->position.read;
}

/*
***********************************************************
* Function name: readerGetPosWrte
* Purpose: Returns the position of char to be added
* Parameters:
*   readerPointer = pointer to Buffer Reader
* Return value:
*	Write position
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/
struct_int readerGetPosWrte(BufferPointer const readerPointer) {
	/* Defensive programming */
	if (readerPointer == NULL) {
		errorPrint("Error: readerGetPosWrte: invalid reader pointer.");
		return READER_ERROR;
	}

	/* Boundary condition: wrte must not exceed buffer size in chars */
	if (readerPointer->position.wrte < 0 || readerPointer->position.wrte > readerPointer->size) {
		errorPrint("Error: readerGetPosWrte: wrte out of bounds.");
		readerPointer->numReaderErrors++;
		return READER_ERROR;
	}

	/* Return current write position */
	return readerPointer->position.wrte;
}


/*
***********************************************************
* Function name: readerGetPosMark
* Purpose: Returns the position of mark in the buffer
* Parameters:
*   readerPointer = pointer to Buffer Reader
* Return value:
*	Mark position.
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/
struct_int readerGetPosMark(BufferPointer const readerPointer) {
	if (readerPointer == NULL) {
		errorPrint("readerGetPosMark: invalid buffer pointer.");
		return READER_ERROR;
	}

	/* Return the current read position */
	return readerPointer->position.mark;
}


/*
***********************************************************
* Function name: readerGetSize
* Purpose: Returns the current buffer capacity
* Parameters:
*   readerPointer = pointer to Buffer Reader
* Return value:
*	Size of buffer.
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/
struct_int readerGetSize(BufferPointer const readerPointer) {
	/* Defensive programming */
	if (readerPointer == NULL) {
		errorPrint("Error: readerGetSize: invalid reader pointer.");
		return READER_ERROR;
	}

	/* Boundary condition: size must be valid */
	if (readerPointer->size <= 0 || readerPointer->size > READER_MAX_SIZE) {
		errorPrint("Error: readerGetSize: size out of valid range.");
		readerPointer->numReaderErrors++;
		return READER_ERROR;
	}

	return readerPointer->size;
}

/*
***********************************************************
* Function name: readerGetFlags
* Purpose: Returns the entire flags of Buffer.
* Parameters:
*   readerPointer = pointer to Buffer Reader
* Return value:
*	Flags from Buffer.
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/
#define FLAGS_
#undef FLAGS_
#ifndef FLAGS_
struct_void readerPrintFlags(BufferPointer const readerPointer) {
	/* Defensive programming */
	if (!readerPointer) {
		errorPrint("Error: readerPrintFlags: invalid reader pointer.");
		return;
	}

	/* Print flags */
	printf("Reader Flags:\n");
	printf("  EMP (isEmpty):   %s\n", readerPointer->flags.isEmpty ? "1" : "0");
	printf("  FUL (isFull):    %s\n", readerPointer->flags.isFull ? "1" : "0");
	printf("  END (isRead):    %s\n", readerPointer->flags.isRead ? "1" : "0");
	printf("  REL (isMoved):   %s\n", readerPointer->flags.isMoved ? "1" : "0");
}
#else
#define bGetFlags(readerPointer) ((readerPointer)?(readerPointer->flags):(RT_FAIL_1))
#endif

/*
***********************************************************
* Function name: readerShowStat
* Purpose: Shows the char statistic.
* Parameters:
*   readerPointer = pointer to Buffer Reader
* Return value: (Void)
* TO_DO:
*   - Use defensive programming
*	- Adjust for your LANGUAGE.
*************************************************************
*/
struct_void readerPrintStat(BufferPointer const readerPointer) {
	struct_int i;

	/* Defensive programming */
	if (!readerPointer) {
		errorPrint("Error: readerPrintStat: invalid reader pointer/content.");
		return;
	}

	/* Print statistics for all chars with non-zero counts */
	for (i = 0; i < NCHAR; i++) {
		if (readerPointer->histogram[i] > 0) {
			printf("B[%c]=%d, ", (char)i, readerPointer->histogram[i]);
		}
	}

	printf("\n");
}

/*
***********************************************************
* Function name: readerNumErrors
* Purpose: Returns the number of errors found.
* Parameters:
*   readerPointer = pointer to Buffer Reader
* Return value:
*	Number of errors.
* TO_DO:
*   - Use defensive programming
*	- Adjust for your LANGUAGE.
*************************************************************
*/
struct_int readerNumErrors(BufferPointer const readerPointer) {
	if (readerPointer == NULL) {
		errorPrint("readerNumErrors: invalid buffer pointer.");
		return READER_ERROR;
	}

	return readerPointer->numReaderErrors;
}

/*
***********************************************************
* Function name: readerChecksum
* Purpose: Sets the checksum of the reader (4 bits).
* Parameters:
*   readerPointer = pointer to Buffer Reader
* Return value:
*	[None]
* TO_DO:
*   - Use defensive programming
*	- Check boundary conditions
*	- Adjust for your LANGUAGE.
*************************************************************
*/
struct_int readerChecksum(BufferPointer readerPointer) {
	struct_int sum = 0;
	struct_int i;

	/* Defensive programming */
	if (!readerPointer || !readerPointer->content) {
		errorPrint("Error: readerChecksum: invalid reader pointer/content.");
		return READER_ERROR; /* failure */
	}

	/* Boundary condition: wrte must be within buffer size */
	if (readerPointer->position.wrte < 0 ||
		(readerPointer->position.wrte * (struct_int)sizeof(struct_char)) > readerPointer->size) {
		errorPrint("Error: readerChecksum: wrte out of bounds.");
		return READER_ERROR; /* failure */
	}

	/* Sum all characters up to wrte */
	for (i = 0; i < readerPointer->position.wrte; i++) {
		sum += (struct_byte)readerPointer->content[i];
	}

	/* Apply 8-bit mask (mod 256) */
	readerPointer->checkSum = (sum & 0xFF);

	return readerPointer->checkSum;
}