Best way to print a large amount of text.

I have been experimenting with C in a cgi environment. What a difference from php.

Anyway, I'm wondering what's the best way to print a large amount of text? The best I have been able to come up with is:

Code:

---

puts("Some large amoun tof text"
"And even more text"
"and still more");

---

Is this the best way?

Normally, I would put all that in a separate text file.

If you have many messages, you could structure it in some way.

Code:

---

<messages>
  <message id="1" lang="en">Hello</message>
  <message id="1" lang="fr">Bonjour</message>
</messages>

---

What do you mean by 'large'? Several characters or loads of megabytes of them?

The printf() family of functions are intended to work with fairly short strings. A modern system will probably scale up to at least INT_MAX characters, but it's not unlikely that you'll end up passing the data to an old system, or to an informally speciifed drop-in replacement which uses a fixed size buffer.

So if outputting areally long string, it's best to construct it in memory and write it char by char in a tight loop. Remember that if passing to printf(), you need to pass printf("%s", str) rather than printf(str) if the string has any percentage characters in it.

I'd imagine puts() would be pretty efficient.

Sorry, I should have included more info.

It's for a webpage, and I need to output all the head information (CSS, Javascript, meta tags). I just didn't want to have to type out `printf` for every line.

I agree it would be easier to contain the text in a file, but this is a single webpage, and it's easier to remember all the files needed when there's only one.

I have the webpage currently working, I'm just transfering over to the C program. So a lot of escaping of quotes (") is really all that's needed. I was just hoping there was some version of `heredocs` for C.

I don't mind it being in the program, as once it is completed, all that should ever be adjusted is contained in the `#defines` (aside from major changes to HTML standard).

I guess I'll stick to what I have been doing.

Ty

Quote:

---

Originally Posted by Yonut

It's for a webpage, and I need to output all the head information (CSS, Javascript, meta tags). I just didn't want to have to type out `printf` for every line.

I agree it would be easier to contain the text in a file, but this is a single webpage, and it's easier to remember all the files needed when there's only one.

I have the webpage currently working, I'm just transfering over to the C program. So a lot of escaping of quotes (") is really all that's needed. I was just hoping there was some version of `heredocs` for C.

I don't mind it being in the program, as once it is completed, all that should ever be adjusted is contained in the `#defines` (aside from major changes to HTML standard).

---

For HTML, I think the usual approach is either to serve the HTML pages directly, or if you need to programmatically muck around with the content, to have some kind of HTML-friendly template language with template files that your program reads and performs the template substitutions before serving. It might be easier to remember a single file, but it would also be easier to understand and modify the HTML code if it were separate, and it isn't that hard to remember such HTML (template) files if they are bundled together in the same project directory (or subdirectory thereof).

Quote:

---

Originally Posted by Yonut

It's for a webpage, and I need to output all the head information (CSS, Javascript, meta tags). I just didn't want to have to type out `printf` for every line.

I have the webpage currently working, I'm just transfering over to the C program. So a lot of escaping of quotes (") is really all that's needed. I was just hoping there was some version of `heredocs` for C.

---

I am assuming the CGI processor spawns a process and, in case of failure (disconnections, for example) it simply kills the process. I don't know how you are dealing with errors in your CGI...

In that case, to output a large string I think it is better to do it in blocks. For example:

Code:

---

#define CHUNK_SIZE  4096

int outputString( char *strp, size_t size )
{
  size_t chunks = size / CHUNK_SIZE;
  size_t lastChunk_size = size % CHUNK_SIZE;

  while ( chunks-- )
  {
    if ( write( STDOUT_FILENO, strp, CHUNK_SIZE ) < 0 )
      return 0;
    strp += CHUNK_SIZE;
  }

  if ( write( STDOUT_FILENO, strp, lastChunk_size ) < 0 )
    return 0;

  return 1;
}

---

You can, of course, use bigger "chunks" (I don't recomend more than 64 KiB - write bigger chunks than this will cause some degradation of performance)... Notice the test on `write()`... If it fails, it means data could not be transmitted, since the descriptor 1 (STDOUT_FILENO is defined at unistd.h) will be a socket, not the tty output descriptor. In that case, the funcion will return 0 (false). To transmit the string in chunks gives you a chance to do something in case of errors, faster.

The way to use such a function is:

Code:

---

static char javascript[] = "var x = 0;\n"
"function f() ...";
...
if ( ! outputString( javascript, sizeof javascript ) )
{
  // ... log the error or do anything you want to deal with it...
  exit(1);
}
...

---

And keep in mind that you shouldn't mix streamming functions like printf() with write() unless you 'flush' the stream with fflush(stdout) before calling write(). You can use fwrite() instead, but the rule is the same. I prefer to deal directly with the file descriptor, instead of FILE pointer when I want to avoid buffering.


[]s
Fred