outbasic.c

ELFkickers是一组elf工具

/* outbasic.c: The low-level output functions.
 *
 * Copyright (C) 1999-2001 by Brian Raiter, under the GNU General
 * Public License. No warranty. See COPYING for details.
 */

#include	<stdio.h>
#include	<string.h>
#include	<ctype.h>
#include	<stdarg.h>
#include	"gen.h"
#include	"elftoc.h"
#include	"outbasic.h"

/* The right-hand margin of the output. The output should never extend
 * more than a few characters past this column.
 */
static int const	rmargin = 76;

/* How many spaces to indent within a block.
 */
static int const	indent = 2;

/* The stack of booleans for each level of indentation. A true value
 * on the top of the stack means that the braces around the current
 * block should appear alone on a line.
 */
static char		blockstack[80];

/* The current level of indentation.
 */
static int		level = 0;

/* The cursor's current x-position.
 */
static int		xpos = 0;

/* True if a comma should separate the next item that is output.
 * Separating commas are not output until a sibling item arrives for
 * output, so that the final item in a block will not have a trailing
 * comma.
 */
static int		pendingseparator = 0;


/* Outputs a string and updates xpos.
 */
static void textout(char const *str)
{
    int	n;

    n = strlen(str);
    fputs(str, outfile);
    xpos += n;
    str = strrchr(str, '\n');
    if (str)
	xpos = strlen(str + 1);
}

/* Returns the C representation for a character value as a literal
 * character constant.
 */
char const *cqchar(int ch)
{
    static char	buf[8];

    switch (ch) {
      case '\a': return "'\\a'";	case '\t': return "'\\t'";
      case '\b': return "'\\b'";	case '\v': return "'\\t'";
      case '\f': return "'\\f'";	case '\0': return "'\\0'";
      case '\n': return "'\\n'";	case '\'': return "'\\''";
      case '\r': return "'\\r'";	case '\\': return "'\\\\'";
    }

    if (isprint(ch) || ch == ' ') {
	buf[0] = '\'';
	buf[1] = ch;
	buf[2] = '\'';
	buf[3] = '\0';
    } else
	sprintf(buf, "0x%02X", (unsigned char)ch);
    return buf;
}

/* Returns the C representation for a character value, as it should
 * appear within a literal string constant.
 */
char const *sqchar(char const *ptr)
{
    static char	buf[8];

    switch (*ptr) {
      case '\a': return "\\a";		case '\r': return "\\r";
      case '\b': return "\\b";		case '\t': return "\\t";
      case '\f': return "\\f";		case '\v': return "\\v";
      case '\n': return "\\n";		case '\\': return "\\\\";
      case '"':  return "\\\"";
    }

    if (!*ptr && !(ptr[1] >= '0' && ptr[1] <= '7'))
	return "\\0";
    else if (isprint(*ptr) || *ptr == ' ') {
	buf[0] = *ptr;
	buf[1] = '\0';
    } else {
	buf[0] = '\\';
	buf[1] = '0' + ((unsigned char)*ptr / 64);
	buf[2] = '0' + (((unsigned char)*ptr / 8) % 8);
	buf[3] = '0' + (*ptr % 8);
	buf[4] = '\0';
    }
    return buf;
}

/* Given a series of length bytes at str, returns the number of
 * characters that would be required to output those bytes within a
 * literal C string.
 */
int stringsize(char const *str, int length)
{
    int	size = 0;

    for ( ; length ; ++str, --length) {
	if (isprint(*str))
	    ++size;
	else
	    switch (*str) {
	      case ' ':
		++size;
		break;
	      case '\0':
		size += length > 1 && str[1] >= '0' && str[1] <= '7' ? 4 : 2;
		break;
	      case '\a': case '\r':
	      case '\b': case '\t':
	      case '\f': case '\v':
	      case '\n': case '\\':
	      case '"':
		size += 2;
		break;
	      default:
		size += 4;
		break;
	    }
    }
    return size;
}

/* Moves the output to the beginning of the next line, if the current
 * cursor position is not already at the beginning of a line.
 */
void linebreak(void)
{
    static char	spaces[80];
    int		n;

    if (pendingseparator) {
	textout(",");
	pendingseparator = 0;
    }
    n = level * indent;
    if (xpos > n)
	textout("\n");
    if (xpos < n) {
	n -= xpos;
	memset(spaces, ' ', n);
	spaces[n] = '\0';
	textout(spaces);
    }
}

/* Starts a new block: outputs a left brace and increases the current
 * indentation level by one. If brk is true, then the block's braces
 * will be followed by line breaks; otherwise, the block's contents
 * will appear on the same lines as the braces.
 */
void beginblock(int brk)
{
    linebreak();
    blockstack[level] = brk;
    ++level;
    pendingseparator = 0;
    textout("{");
    if (brk) {
	textout("\n");
	linebreak();
    } else
	textout(" ");
}

/* Closes the current block: outputs a right brace and decrements the
 * level of indentation.
 */
void endblock(void)
{
    pendingseparator = 0;
    --level;
    if (blockstack[level])
	linebreak();
    else
	textout(" ");
    textout("}");
    if (level)
	pendingseparator = -1;
    else
	textout(";\n");
}

/* Outputs a string, and if the indentation level is not zero (i.e.,
 * if the current output is inside a block, a separator is set as
 * pending.
 */
void out(char const *str)
{
    int	n;

    n = strlen(str);
    if (xpos + n >= rmargin)
	linebreak();
    if (pendingseparator) {
	if (pendingseparator > 0 && xpos + 2 < rmargin)
	    textout(", ");
	else
	    linebreak();
    }
    textout(str);
    pendingseparator = level > 0;
}

/* Calls out after building a formatted string.
 */
void outf(char const *fmt, ...)
{
    static char	       *buf = NULL;
    static int		bufsize = 0;
    va_list		args;
    int			n;

    va_start(args, fmt);
#if 0
    while (!bufsize || (n = vsnprintf(buf, bufsize, fmt, args)) < 0) {
	bufsize += rmargin;
	xalloc(buf, bufsize);
    }
#else
    for (;;) {
	bufsize += rmargin;
	xalloc(buf, bufsize);
	n = vsnprintf(buf, bufsize, fmt, args);
	if (n >= 0 && n < bufsize)
	    break;
    }
#endif
    va_end(args);
    out(buf);
}

/* Takes an integer and outputs it in hexadecimal notation.
 */
void outword(unsigned int word)
{
    if (word > 0xFFFFFF)
	outf("0x%08X", word);
    else if (word > 0xFFFF)
	outf("0x%06X", word);
    else if (word > 15)
	outf("0x%X", word);
    else
	outf("%u", word);
}

/* Takes a string (not necessarily null-terminated) and outputs it as
 * a literal C string, as a single item.
 */
void outstring(char const *str, int length)
{
    char const *s;
    int		ps, i;

    if (xpos >= rmargin || (length > 4 && xpos + 8 >= rmargin))
	linebreak();
    out("\"");
    ps = pendingseparator;
    pendingseparator = 0;
    ++level;
    for (i = 0, s = str ; i < length ; ++i, ++s) {
	textout(sqchar(s));
	if (xpos >= rmargin && i + 2 < length) {
	    textout("\"");
	    linebreak();
	    textout("\"");
	}
    }
    --level;
    textout("\"");
    pendingseparator = ps;
}

/* Outputs a given string as a C comment, with no separator pending
 * afterwards.
 */
void outcomment(char const *str)
{
    int	n;

    n = strlen(str);
    if (pendingseparator) {
	if (pendingseparator < 0 || xpos + n + 9 >= rmargin) {
	    textout(",");
	    linebreak();
	} else
	    textout(", ");
	pendingseparator = 0;
    } else {
	if (xpos + n + 7 >= rmargin)
	    linebreak();
    }
    textout("/* ");
    textout(str);
    textout(" */ ");
}