$//$ PROBLEM $2$: Uses print$\_$fontified$\_$oneline$()$ with find$\_$linebreaks$()$ to

$//$ correctly print $\text{'}$msg$\text{'}$ with 'font' even if there are linebreaks in

$//\text{'}$msg$\text{'}.$ Uses find$\_$linebreaks$()$ to find the end of each line in

$//\text{'}$msg$\text{'}$ and then iterates over lines printing each. Uses pointer

$//$ arithmetic to pass the starting position of each line into calls of

$//$ print$\_$fontified$\_$oneline$().$ Frees memory allocated $($such as through

$//$ use of count$\_$linebreaks$())$ before returning.

$//$

$//$ EXAMPLE:

$//$ print$\_$fontified$("$apple

B@N@N@

Carr$0^",$ &font$\_$standard$)$;

$//$ Shows the following on standard output:

$//,-,$

$//\_\_\_,\_\_\_.,\_\_\_.||\_\_\_$

$///\_`||\text{'}\_\backslash |\text{'}\_\backslash ||/\text{'}\_`\backslash$

$//|(\_||||\_)|||\_)||||\_\_/$

$//\backslash \_\_,\_||.\_\_/|.\_\_/|\_|\backslash \_\_\_|$

$//|\_||\_|$

$//,\_\_\_\_\_\_\_\_.\_.\_.\_\_\_\_.\_.\_.\_\_\_\_$

$//|==)/\_\_\backslash |\backslash ||/\_\_\backslash |\backslash ||/\_\_\backslash$

$//|\_\backslash //\_`||\backslash ||//\_`||\backslash ||//\_`|$

$//||\_)|||(\_||||\backslash |||(\_||||\backslash |||(\_||$

$//|\_\_\_\_/\backslash \backslash \_\_,.||\_|\backslash \_|\backslash \backslash \_\_,.||\_|\backslash \_|\backslash \backslash \_\_,.|$

$//\backslash \_\_\_\_/\backslash \_\_\_\_/\backslash \_\_\_\_/$

$//\_\_\_\_.\_\_\_/\backslash$

$///\_\_\_|\_\_\_.\_\_\_..\_\_\_./\_\backslash |/\backslash |$

$//||/\_`||`\_\_||`\_\_|||||$

$//||\_\_\_.|(\_||||||||\_||$

$//\backslash \_\_\_\_|\backslash \_\_,\_||\_||\_|\backslash \_\_\_/$

void print$\_$fontified$($char $*$msg$,$ font$\_$t $*$font$)\{$

$//$ PROVIDED: Initializes a glyph to mostly X$\text{'}$s except for its

$//$ codepoint on the first line.

void glyph$\_$init$($glyph$\_$t $*$glyph$,$ int codepoint$)\{$

glyph$->$codepoint $=$ codepoint;

glyph$->$width $=6$;

for$($int i$=0$; iwidth$)\{$

glyph$->$data$[$i$][$j$]=\text{'}\backslash 0\text{'}$; $//$ null terminate

$\}$

else$\{$

glyph$->$data$[$i$][$j$]=\text{'}$X$\text{'}$;

$\}$

$\}$

$\}$

int len $=$ sprintf$(($char $*)$glyph$->$data, $"\%$d$",$codepoint$)$; $//$ add codepoint # to glyph

glyph$->$data$[0][$len$]=\text{'}$X$\text{'}$; $//$ remove null termination char

$\}$

$//$ PROBLEM $2$: Loads a banner font from 'filename'. The format of font

$//$ files is documented more thoroughly in the project specification

$//$ but is generally comprised of a first line that indicate the height

$//$ of each glyph in the font followed by a sequence of each glyph

$//$ starting with its codepoint $($ASCII index$)$ and a grid of characters

$//$ in it$.$ To make parsing easier, the $?$ character is used to represent

$//$ blank spaces in glyph shapes.

$//$

$//$ EXAMPLE:

$//$ height: $4$

$//42$

$//???$

$//\backslash |/$

$///|\backslash$

$//???$

$//43$

$//???$

$//\_|\_$

$//?|?$

$//???$

$//$

$//$ The two characters above are the codepoint $42\text{'}*\text{'}$ and codepoint $43$

$//\text{'}+\text{'}$ with the $?$ symbols eventually being replaced by spaces during

$//$ loading.

$//$

$//$ If 'filename' cannot be opened for reading, returns NULL.

$//$

$//$ Memory allocation happens in two steps: $(1)$ allocates memory for a

$//$ font$\_$t struct then $(2)$ allocates memory for an array of glyph$\_$t

$//$ structs of length NUM$\_$ASCII$\_$GLYPHS $($a constant defined in

$//$ banlet.h$).$ Sets the font$->$glyphs field to be the allocated array of

$//$ glyphs$.$ Reads the font$->$height field from teh first line of the

$//$ file. Iterates over each element of the glyphs array and calls the

$//$ glyph$\_$init$()$ function on it to populate it with default data. Then

$//$ proceeds to read glyphs from the file. Glyphs are read by reading

$//$ the integer codepoint first which determins which element of the

$//$ glyph array to read into. Then a loop over the height of the font

$//$ is used to read each row of the glyph into the

$//$ glyph$[$codepoint$]->$data$[$row$]$; fscanf$()$ with $\text{'}\%$s$\text{'}$ specifier is used

$//$ for this. Finally, the string$\_$replace$\_$char$()$ function is used to

$//$ replace all $\text{'}?\text{'}$ characters with $\text{'}\text{'}($space$)$ characters in the glyph

$//$ data. Sets the width of each glyph using the strlen$()$ function on

$//$ any balid row of the glyph data.

$//$

$//$ Glyphs are read from 'filename' until an attempt to read a glyph$\text{'}$s

$//$ codepoint with fscanf$()$ returns EOF $($end of file$).$ This causes the

$//$ routine to return the allocated font$\_$t data for use elsewhere.

font$\_$t $*$font$\_$load$($char $*$filename$)\{$

$//$ WRITE ME

return NULL;

$\}$

$//$ PROBLEM $2$: Frees the memory associated with 'font'. First frees

$//$ the glyph array, then frees the font itself. Hint: this funciton

$//$ should be $2$ lines long.

void font$\_$free$($font$\_$t $*$font$)\{$

$//$ WRITE ME

$\}$

$//$ PROBLEM $2$: Read all characters from the file 'filename' into a

$//$ dynamcally allocated array. Terminates the array with the $\text{'}\backslash 0\text{'}$

$//$ character to form a valid C string and return that string. If the

$//$ file cannot be opened, return NULL.

$//$

$//$ CONSTRAINT: Does not use any functions that determine the size of a

$//$ file a priori such as fstat$()$ or fseek$()$ or their kin.

$//$

$//$ BASELINE: Uses a $"2-$Pass" solution. Counts the characters in file

$//$ via calls to fscanf$()$ or fgetc$(),$ then returns to beginning of the

$//$ file with rewind$(),$ allocates an appropriately sized block of

$//$ memory, then reads all characters into it in a second pass.

$//$