Not printing new lines with printf

Question

I am currently printing a string using printf("'%.*s'\n", length, start);, where start is a const char* and length is an int.

The string being printed sometimes contains newline characters \n which mess up the formatting, is it possible for them to be replaced with the characters \ and n in the printed output, instead of the \n character. If not, could you help with a function that would replace the characters?

The string is a malloc'd string that is has other references from different pointers so it cannot be changed.

EDIT: I have written the following code which I think does what I need it to

static void printStr(const char* start, int length) {
  char* buffer = malloc(length * sizeof(char));
  int processedCount = 0;
  for(int i = 0; i < length; i++) {
    char c = start[i];
    if(c == '\n') {
      printf("%.*s\\n", processedCount, buffer);
      processedCount = 0;
    } else {
      buffer[processedCount] = c;
      processedCount++;
    }
  }
  printf("%.*s", processedCount, buffer);
  free(buffer);
}

Answer 1

There is no need to allocate memory to process the string. Simply, iterate through the original one and print the characters as required. For instance:

#include <stdio.h>

void print(const char * str, int length)
{
    for (int i = 0; i < length; ++i) {
        if (str[i] == '\n') {
            putchar('\\');
            putchar('n');
        } else
            putchar(str[i]);
    }
}

int main()
{
    print("hello\nworld!", 12);
    return 0;
}

Answer 2

I would implement your custom print function slightly differently:

#include <stdlib.h>
#include <ctype.h>
#include <stdio.h>
#include <errno.h>

static int output_escaped(FILE *out, const char *str, const char *end)
{
    int  count = 0;
    while (str < end)
        switch (*str) {
        case '\\': fputs("\\\\", out); count++; break;
        case '\a': fputs("\\a", out);  count++; break;
        case '\b': fputs("\\b", out);  count++; break;
        case '\t': fputs("\\t", out);  count++; break;
        case '\n': fputs("\\n", out);  count++; break;
        case '\v': fputs("\\v", out);  count++; break;
        case '\f': fputs("\\f", out);  count++; break;
        case '\r': fputs("\\r", out);  count++; break;
        default:
            if (isprint((unsigned char)(*str)))
                fputc(*str, out);
            else {
                fprintf(out, "\\x%02x", (unsigned char)(*str));
                count += 3; /* Note: incremented by one later */
            }
        }
        str++;
        count++;
    }
    return count;
}

with wrapper functions

int escape(const char *str)
{
    if (!stdout || !str) {
        errno = EINVAL;
        return -1;
    } else
        return output_escaped(stdout, str, str + strlen(str));
}

int escapen(const char *str, const size_t len)
{
    if (!stdout || !str) {
        errno = EINVAL;
        return -1;
    } else
        return output_escaped(stdout, str, str + len);
}

int fescape(FILE *out, const char *str)
{
    if (!out || !str) {
        errno = EINVAL;
        return -1;
    } else
        return output_escaped(out, str, str + strlen(str));
}

int fescapen(FILE *out, const char *str, const size_t len)
{
    if (!out || !str) {
        errno = EINVAL;
        return -1;
    } else
        return output_escaped(out, str, str + len);
}

The four wrappers cater for the cases when you want to print the entire thing, or just some len first characters, to stdout or a specific stream. All return the number of characters output, or -1 if an error occurs (and errno set).

Note that this prints \ as \\, and other non-printable characters using a hexadecimal escape sequence \x00 to \xFF. If you want octal (\001 through \377) rather than hexadecimal escapes, use

            else {
                fprintf(out, "\\%03o", (unsigned char)(*str));
                count += 3; /* Note: incremented by one later */
            }

instead.

The (unsigned char) casts ensure that the character value is never negative.

Answer 3

This is essentially the same thing, but it uses strchr in memory to see exactly how many chars we can write before an escape sequence, and fwrites them all in one. This may be faster then character-at-a-time output, (perhaps related https://stackoverflow.com/a/37991361/2472827.) (Not thoroughly tested.)

#include <stdlib.h> /* EXIT_ */
#include <stdio.h>  /* perror fwrite fputs */
#include <string.h> /* strchr */
#include <assert.h>

/** Prints the string, escaping newlines to "\n"; a newline will be added at
 the end.
 @return A non-negative number, otherwise EOF; in the latter case, it shall
 set an error indicator for the stream and (may) set {errno} (IEEE Std
 1003.1-2001-conforming systems?) */
static int printStr(const char* start) {
    const char *so_far = start, *nl;
    size_t nchars;
    assert(start);
    while((nl = strchr(so_far, '\n'))) {
        nchars = nl - so_far;
        if(fwrite(so_far, 1, nchars, stdout) != nchars
            || fwrite("\\n", 1, 2, stdout) != 2) return EOF;
        so_far = nl + 1;
    }
    /* The rest. */
    return fputs(so_far, stdout) == EOF || fputc('\n', stdout) == EOF ? EOF : 1;
}

int main(void) {
    return printStr("Lalala\n\nlalala\n\n") == EOF
        ? perror("string"), EXIT_FAILURE : EXIT_SUCCESS;
}

It doesn't require length, but you could put in by checking nchars, (if your string was not null-terminated?)

Answer 4

The code you posted in your question seems to work, except for the potential undefined behavior if memory allocation fails. It can be simplified: there is no need for a temporary buffer, you can print from the supplied array directly, avoiding allocation:

static void printStr(const char *s, int length) {
    int i, j;
    for (i = j = 0; i < length; i++) {
        if (s[i] == '\n') {
            printf("%.*s\\n", i - j, s + j);
        }
    }
    if (i > j) {
        printf("%.*s", i - j, s + j);
    }
}