Remove all trailing blanks and spaces from a string
When working with strings, always try to avoid copying/duplicating/moving them, if possible. This would be a perfect example to do so.

When you think about strings in memory, they may be described as a specific number of characters (i.e. length or determined by a terminator) at a specific offset in memory. So all you'll have to do is move both, the starting offset as well as the end indicator (whether it's another pointer or some specific value, i.e. terminator, doesn't matter).

Both these tasks can easily be achieved using a loop in a single line each.

Here's what I'd do (simplified; try it on Ideone.com):

#include &lt;string.h&gt;
#include &lt;stdio.h&gt;

char *trim(char *text) {
    char *start = text; // points to the first character
    char *end = text + strlen(text); // points past the last character

    // Let's start with the left side.
    // Move the pointer as long as there's a whitespace
    for (; isspace(*start); ++start);

    // In a similar way, let's get the right end.
    // Again, move the pointer as long as there's a whitespace right before it
    for (;end &gt; start &amp;&amp; isspace(end[-1]); --end);

    // Insert the new terminator
    *end = '\0';

    // Return the new starting pointer
    return start;
}

int main(int argc, char **argv) {
    char string[] = "  \t  Hello World\t\t\n";
    printf("result: '%s'\n", trim(string));
    return 0;
}


Note that I'm removing line breaks as whitespaces as well. In this example you'd add it after trimming the line.



Other points regarding your code:


If this is no contest to write code that's as short as possible (like code golf), try to use telling names. len is good, arr is good as well, but pc and nl aren't (nl is obviously "new line", but how about pc?).
The same applies to your preprocessor constants. This is even more important, since you might unintentionally rewrite code. As such never define F or T. If you want a TRUE and FALSE, call them like that or simply use 0 or 1.
In a similar way, use white spaces to make your code more readable.

For example, the line:

while(pc==' '||pc=='\t'||pc=='\n')


could be reformatted to this:

while (pc == ' ' || pc == '\t' || pc == '\n')


This way it's easier to see where single expressions start or end, especially combined with syntax highlighting colors.
I'd also rewrite the contents of your append() function. Since there's nothing happening inside the loop other than the increments, you could use a for() instead:

void append(char to[], char from[], int pos)
{
    int i;

    for (i = 0; pos &lt; STORELEN - 1 &amp;&amp; from[i]; to[pos++] = from[i++]);

    to[pos] = '\0'; // Only required in case you run out of space
}


As long as your target string isn't too long already and there's still a character left in your source string it will copy the contents and then move both offsets every iteration. Also note the - 1 when checking for the maximum length. Otherwise pos would point one past the maximum length (see below).
There's a buffer overrun in your code:


If you define char string[1000], your last valid offset would be 999, since the index starts at 0.
When checking pos &lt; STORELEN and this check fails, the value of pos would be 1000 already. Once you hit the line to[pos] = '\0' you're essentially writing past the allocated memory at string[1000].