/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


/*
 * Translate a string into C literal string constant notation.
 */

#include        <stdio.h>
#include        <ctype.h>
#include        <_conv.h>
#include        <c_literal_msg.h>


/*
 * Convert characters to the form used by the C language to represent
 * literal strings:
 *      - Printable characters are shown as themselves
 *      - Convert special characters to their 2-character escaped forms:
 *              alert (bell)    \a
 *              backspace       \b
 *              formfeed        \f
 *              newline         \n
 *              return          \r
 *              horizontal tab  \t
 *              vertical tab    \v
 *              backspace       \\
 *              single quote    \'
 *              double quote    \"
 *      - Display other non-printable characters as 4-character escaped
 *              octal constants.
 *
 * entry:
 *      buf - Buffer of characters to be processed
 *      n # of characters in buf to be processed
 *      outfunc - Function to be called to move output characters.
 *      uvalue - User value. This argument is passed to outfunc without
 *              examination. The caller can use it to pass additional
 *              information required by the callback.
 *
 * exit:
 *      The string has been processed, with the resulting data passed
 *      to outfunc for processing.
 */
void
conv_str_to_c_literal(const char *buf, size_t n,
    Conv_str_to_c_literal_func_t *outfunc, void *uvalue)
{
        char    bs_buf[2];      /* For two-character backslash codes */
        char    octal_buf[10];  /* For \000 style octal constants */

        bs_buf[0] = '\\';
        while (n > 0) {
                switch (*buf) {
                case '\0':
                        bs_buf[1] = '0';
                        break;
                case '\a':
                        bs_buf[1] = 'a';
                        break;
                case '\b':
                        bs_buf[1] = 'b';
                        break;
                case '\f':
                        bs_buf[1] = 'f';
                        break;
                case '\n':
                        bs_buf[1] = 'n';
                        break;
                case '\r':
                        bs_buf[1] = 'r';
                        break;
                case '\t':
                        bs_buf[1] = 't';
                        break;
                case '\v':
                        bs_buf[1] = 'v';
                        break;
                case '\\':
                        bs_buf[1] = '\\';
                        break;
                case '\'':
                        bs_buf[1] = '\'';
                        break;
                case '"':
                        bs_buf[1] = '"';
                        break;
                default:
                        bs_buf[1] = '\0';
                }

                if (bs_buf[1] != '\0') {
                        (*outfunc)(bs_buf, 2, uvalue);
                        buf++;
                        n--;
                } else if (isprint(*buf)) {
                        /*
                         * Output the entire sequence of printable
                         * characters in a single shot.
                         */
                        const char      *start = buf;
                        size_t          outlen = 0;

                        for (start = buf; (n > 0) && isprint(*buf); buf++, n--)
                                outlen++;
                        (*outfunc)(start, outlen, uvalue);
                } else {
                        /* Generic unprintable character: Use octal notation */
                        (void) snprintf(octal_buf, sizeof (octal_buf),
                            MSG_ORIG(MSG_FMT_OCTCONST), (uchar_t)*buf);
                        (*outfunc)(octal_buf, strlen(octal_buf), uvalue);
                        buf++;
                        n--;
                }
        }
}

/*
 * Given the pointer to the character following a '\' character in
 * a C style literal, return the ASCII character code it represents,
 * and advance the string pointer to the character following the last
 * character in the escape sequence.
 *
 * entry:
 *      str - Address of string pointer to first character following
 *              the backslash.
 *
 * exit:
 *      If the character is not valid, -1 is returned. Otherwise
 *      it returns the ASCII code for the translated character, and
 *      *str has been advanced.
 */
int
conv_translate_c_esc(char **str)
{
        char    *s = *str;
        int     ch, i;

        ch = *s++;
        switch (ch) {
        case 'a':
                ch = '\a';
                break;
        case 'b':
                ch = '\b';
                break;
        case 'f':
                ch = '\f';
                break;
        case 'n':
                ch = '\n';
                break;
        case 'r':
                ch = '\r';
                break;
        case 't':
                ch = '\t';
                break;
        case 'v':
                ch = '\v';
                break;

        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
                /* Octal constant: There can be up to 3 digits */
                ch -= '0';
                for (i = 0; i < 2; i++) {
                        if ((*s < '0') || (*s > '7'))
                                break;
                        ch = (ch << 3) + (*s++ - '0');
                }
                break;

        /*
         * There are some cases where ch already has the desired value.
         * These cases exist simply to remove the special meaning that
         * character would otherwise have. We need to match them to
         * prevent them from falling into the default error case.
         */
        case '\\':
        case '\'':
        case '"':
                break;

        default:
                ch = -1;
                break;
        }

        *str = s;
        return (ch);
}