output formatted text using width and margin - c

Question

I am trying to write a program that will take the following input and will format it and output it to a text file.
Here is a picture of how it should work
?mrgn left: Each line following the command will be indented left spaces from
the left-­­hand margin. Note that this indentation must be included in the page
width. If this command does not appear in the input file, then the value of left
is 0 (zero).
I did the following so far:
while (fgets(line, MAX_LINE_LEN-1, infile) != NULL){/*Read the first line if it is not empty*/
char last[MAX_WORD_LEN] = {0};
char *p;
for (p = strtok(line, " "); p; p = strtok(NULL, " ")){
if(*last && strcmp(last, width)==0){
iwidth = atoi(p);
printf("width = %d\n", iwidth);
}
if(*last && strcmp(last, margin)==0){
imargin = atoi(p);
printf("margin = %d\n", imargin);
}
strncpy (last, p, MAX_WORD_LEN);
if(iwidth != 0 || imargin != 0){
printf("%s ", p);
}else{
printf("%s", line);
}
}
}
I am able to store the value of width and margin to a variable. I am now stuck on how I can specify the required formatting. I did some research but I couldn't find what I want. Please help!
Thank you!
Cheers!

Answer 1

After you have had several hours to work on the problem, let me give you a few pointers (no pun intended) that may help simplify your approach to the problem. While you can certainly use strtok to parse your option and width from the input file, there really is no need to tokenize when you know the line format containing the option will be "?name value".
A simplified approach, knowing your file contains the option as the first line, would simply be to read the entire line (using fgets or POSIX getline), verify the first character is '?' and then parse the option name and value from the line with sscanf. (you can either include the '?' in your format-string, or simply begin the parse at the 2nd character. (my choice) To accomplish this you could start with something similar to:
#include <stdio.h>
#include <string.h> /* for strcmp, strlen */
#define OPT 32 /* if you need constants, #define one (or more) */
#define WDTH 78
#define MAXC 1024
void str_word_wrap (char *buf, int n); /* wrap function prototype */
int main (void) {
char buf[MAXC] = "", /* buffer to hold words in file */
*p = buf, /* pointer to buf */
opt[OPT] = ""; /* buffer to hold option found in file */
int width = WDTH, /* variable holding width from option */
used = 0, /* number of chars used in buf */
val = 0; /* temp value to read option value from file */
/* option on line 1, read entire line */
if (!fgets (buf, MAXC, stdin) || *buf != '?')
fputs ("error: unexpected file format, using default width.\n\n",
stderr);
/* parse option and value, compare option is "width", use val as width */
if (sscanf (buf + 1, "%s %d", opt, &val) == 2) {
if (strcmp (opt, "width") == 0)
width = val;
}
...
At this point in your code, buf contains the first line, opt contains the option name, and width contains the width specified in the file (or the default width WDTH (78) in the event the first line did not contain the "?width val" information). Ideally, if the first line was not a valid option/value line, you would simply eliminate the excess whitespace from buf, add an ending ' ' and continue, but that code is left to you.
(note: I just redirect the file to stdin so I read from stdin instead of a file here -- but your infile is fine as well. You would just substitute infile where I read stdin)
Since you simply want to eliminate all the additional whitespace from your input file leaving a normally formatted paragraph which you will wrap to the specified width, using fscanf with the "%s" format specifier can handle the whitespace removal automatically. (with the scanf family, "%s" and numeric format specifiers ignore leading whitespace, "%c" and "%[..]" do not). So reading the remainder of the file into your buffer is simply a matter of reading each word in the file, keeping track of how many characters in your buffer you have used (so you know the next word will fit), and adding a ' ' (space) between each word as you add them to your buffer.
You can use strcat if that helps, or you can simply use a pointer and write a ' ' at one past the end of the current buffer and then a nul-terminating character past that on each iteration. Either way, just keep track of how many characters you have used so far and the len (length) of what you are adding, and then update your used count with the length of each word as you go. You could do something like the following:
while (scanf ("%s", p + used) == 1) { /* read each word, ignore WS */
size_t len = strlen (p + used); /* get length of word */
if (used + len + 2 >= MAXC) { /* make sure it fits with ' ' */
fputs ("warning: file truncated.\n", stderr);
break; /* note you can refine to save 1-char space at end */
}
*(p + used + len++) = ' '; /* add space at end of word */
*(p + used + len) = 0; /* nul-termiante after space */
used += len; /* update used with len */
}
*(p + --used) = 0; /* overwrite final ' ' with nul-character */
At this point you could write out your width value and the contents of your filled buffer for a check before you wrap the lines to width. I simply write the width used out before outputting the wrapped lines which completes the main() function of the program, e.g.
printf ("Wrapping file at width: %d\n\n", width);
str_word_wrap (buf, width); /* wrap buffer at width chars/output */
return 0;
}
All that remains is finishing the function to wrap the buffer to no more that width characters per line as you output your buffer. I provided the prototype above for str_word_wrap function and details in my original comment concerning the approach to wrapping the buffer by simply using a sliding-window of width length to work down your buffer, outputting the words that fit within the sliding window each time it is moved down the buffer.
To accomplish the task you generally use three pointers (I name then p the pointer to the current char, sp the start pointer for the window, and ep the end pointer for the window. The scheme is this, you begin with all three initialized to the beginning of your buffer, you then iterate over each char with p until p points to a space between the words, setting the end-pointer ep = p; each time a space is encountered. On each iteration you check if p - sp >= width, where p - sp is simply the current pointer address minus the start pointer address which tells you how many characters you have moved from the start. If that equals or exceeds your width, you know you last set ep (your end-pointer) to the last whitespace in the windows marking the end of the last word to output.
All that remains is outputting the line up to the end-pointer, (and a '\n') and then setting your new start-pointer to the next character after end-pointer and you can set your end-pointer to one after the current pointer (which slides your window forward) and you repeat. Nothing fancy is needed. Something like the following works fine:
void str_word_wrap (char *buf, int n)
{
char *p = buf, /* pointer to current char */
*sp = buf, /* pointer to start of line to print */
*ep = buf; /* pointer to end of line to print */
for (; *p && *p != '\n'; p++) { /* loop over each char (omit '\n')*/
if (*p == ' ') /* if space, set ep */
ep = p;
if (p - sp >= n) { /* if wrap length 'n' reached */
while (sp < ep) /* loop outputting chars sp -> ep */
putchar (*sp++);
putchar ('\n'); /* tidy up with '\n' */
sp = ++ep; /* set start to next after end */
ep = ++p; /* set end to next after current */
}
}
while (*sp && *sp != '\n') /* output last line of chars */
putchar (*sp++);
putchar ('\n'); /* tidy up with final '\n' */
}
Putting that altogether will handle your case, exactly:
Example Input File
$ cat dat/taggedparagraph.txt
?width 30
While there are enough characters here to
fill
at least one line, there is
plenty
of
white space that needs to be
eliminated
from the original
text file.
Now simply running the program using the file as input or redirecting the file to the programs stdin gives:
Example Use/Output
$ ./bin/wrapped_tagged_p < dat/taggedparagraph.txt
Wrapping file at width: 30
While there are enough
characters here to fill at
least one line, there is
plenty of white space that
needs to be eliminated from
the original text file.
Look things over and let me know if you have questions. This all boils down to basic pointer arithmetic and keeping track of where you are within a buffer while iterating over each character in the buffer to extract whatever specific information you need from it. You will often hear that referred to as "walking-a-pointer" over or down the buffer. Using a sliding-window is nothing more than walking-a-pointer while keeping track of the fixed point you started from and limiting the walk to no more than some fixed width of characters, and doing whatever it is you need to over-and-over again until you reach the end.
Help "Learn About Pointers"
Since in your comment below your question you mentioned you were "going to learn about pointers", start with the basics:
A pointer is simply a normal variable that holds the address of something else as its value. In other words, a pointer points to the address where something else can be found. Where you normally think of a variable holding an immediate values, such as int a = 5;, a pointer would simply hold the address where 5 is stored in memory, e.g. int *b = &a;.
To reference the value at the address held by a pointer you dereference the pointer by using the unary '*' character before the pointer name. E.g., b holds the address of a (e.g. b point to a), so to get the value at the address held by b, you simply dereference b, e.g. *b.
It works the same way regardless what type of object the pointer points to. It is able to work that way because the type of the pointer controls the pointer arithmetic, e.g. with a char * pointer, pointer+1 point to the next byte, for an int * pointer (normal 4-byte integer), pointer+1 will point to the next int at an offset 4-bytes after pointer. (so a pointer, is just a pointer.... where arithmetic is automatically handled by the type)
When you are dealing with strings in C, you can iterate from the beginning to the end of the string checking each character and stopping when you reach the nul-terminating character at the end of every string. This nul-character serves as a sentinel for the end of the string. You will see it represented as '\0' or just plain 0. Both are equivalent. The ASCII character '\0' has the integer value 0.
A simple example of walking a pointer may help cement the concept:
#include <stdio.h>
int main (void) {
char buf[] = "walk-a-pointer down buf", /* buffer */
*p = buf; /* initialize p to point to buffer */
/* dereference the pointer to get the character at that address */
while (*p) { /* while *p != 0, or (*p != '\0') */
putchar (*p); /* output each character */
p++; /* advance pointer to next char */
}
putchar ('\n'); /* then tidy up with a newline */
return 0;
}
Example Use/Output
$ ./bin/walkpointer
walk-a-pointer down buf