/*
 * [FromJavaStringLiteral.java]
 *
 * Summary: convert Java String literal back to simple string.
 *
 * Copyright: (c) 2012-2017 Roedy Green, Canadian Mind Products, http://mindprod.com
 *
 * Licence: This software may be copied and used freely for any purpose but military.
 *          http://mindprod.com/contact/nonmil.html
 *
 * Requires: JDK 1.8+
 *
 * Created with: JetBrains IntelliJ IDEA IDE http://www.jetbrains.com/idea/
 *
 * Version History:
 *  1.0 2012-12-17 initial version
 */
package com.mindprod.quoter;

import com.mindprod.common18.ST;

/**
 * convert Java String literal back to simple string.
 *
 * @author Roedy Green, Canadian Mind Products
 * @version 1.0 2012-12-17 initial version
 * @since 2012-12-17
 */
public final class FromJavaStringLiteral extends Translator
    {
    /**
     * convert Java String literal back to simple string.
     *
     * @param raw String to be converted
     *
     * @return converted string.
     */
    public String process( String raw )
        {
        assert raw != null : "Translator.process raw must not be null";
        // prune off lead and trail " if present.
        if ( raw.startsWith( "\"" ) )
            {
            raw = raw.substring( 1 );
            }
        if ( raw.endsWith( "\"" ) )
            {
            raw = raw.substring( 0, raw.length() - 1 );
            }
        StringBuilder cooked = new StringBuilder( raw.length() );  // should shrink a bit
        int lastChar = raw.length() - 1;
        for ( int i = 0; i < raw.length(); i++ )
            {
            char c = raw.charAt( i );
            switch ( c )
                {
                case '\\':
                    if ( ++i > lastChar )
                        {
                        cooked.append( '\\' );
                        cooked.append( "[malformed]" );
                        }
                    else
                        {
                        char d = raw.charAt( i );
                        switch ( d )
                            {
                            case 'b':
                                cooked.append( '\b' );
                                break;
                            case 'f':
                                cooked.append( '\f' );
                                break;
                            case 'n':
                                cooked.append( '\n' );
                                break;
                            case 'r':
                                cooked.append( '\r' );
                                break;
                            case 't':
                                cooked.append( '\t' );
                                break;
                            case '\"':
                                cooked.append( '\"' );
                                break;
                            case '\'':
                                cooked.append( '\'' );
                                break;
                            case '\\':
                                cooked.append( '\\' );
                                break;
                            case 'u':
                                // should be 4 hex digits
                                i += 4;
                                if ( i > lastChar )
                                    {
                                    cooked.append( "\\u[malformed]" );
                                    }
                                else
                                    {
                                    String fourHexChars = raw.substring( i - 3, i + 1 );
                                    if ( !ST.isLegal( fourHexChars, "0123456789abcdefABCDEF" ) )
                                        {
                                        cooked.append( "\\u" );
                                        cooked.append( fourHexChars );
                                        cooked.append( "[malformed]" );
                                        }
                                    else
                                        {
                                        cooked.append( ( char ) Integer.parseInt( fourHexChars, 16 ) );
                                        }
                                    }
                                break;
                            case '0':
                                // should be 2 more octal digits
                                i += 2;
                                if ( i > lastChar )
                                    {
                                    cooked.append( "\\o[malformed]" );
                                    }
                                else
                                    {
                                    String twoOctalChars = raw.substring( i - 1, i + 1 );
                                    if ( !ST.isLegal( twoOctalChars, "01234567" ) )
                                        {
                                        cooked.append( "\\o" );
                                        cooked.append( twoOctalChars );
                                        cooked.append( "[malformed]" );
                                        }
                                    else
                                        {
                                        cooked.append( ( char ) Integer.parseInt( twoOctalChars, 8 ) );
                                        }
                                    }
                                break;
                            default:
                                cooked.append( "\\" );
                                cooked.append( d );
                                cooked.append( "[malformed]" );
                            }
                        }
                    break;
                default:
                    cooked.append( c );
                }
            } // end for
        return cooked.toString();
        } // end process
    }