kicad_io_utils.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#include <fmt/format.h>
 
#include <kiid.h>
#include <io/kicad/kicad_io_utils.h>
#include <richio.h>
#include <string_utils.h>
 
namespace KICAD_FORMAT {
 
void FormatBool( OUTPUTFORMATTER* aOut, int aNestLevel, const wxString& aKey, bool aValue,
                 char aSuffix )
{
    aOut->Print( aNestLevel, "(%ls %s)%c", aKey.wc_str(), aValue ? "yes" : "no", aSuffix );
}
 
 
void FormatUuid( OUTPUTFORMATTER* aOut, const KIID& aUuid, char aSuffix )
{
    if( aSuffix )
        aOut->Print( 0, "(uuid \"%s\")%c", TO_UTF8( aUuid.AsString() ), aSuffix );
    else
        aOut->Print( 0, "(uuid \"%s\")", TO_UTF8( aUuid.AsString() ) );
 
}
 
/*
 * Formatting rules:
 * - All extra (non-indentation) whitespace is trimmed
 * - Indentation is one tab
 * - Starting a new list (open paren) starts a new line with one deeper indentation
 * - Lists with no inner lists go on a single line
 * - End of multi-line lists (close paren) goes on a single line at same indentation as its start
 *
 * For example:
 * (first
 *  (second
 *   (third list)
 *   (another list)
 *  )
 *  (fifth)
 *  (sixth thing with lots of tokens
 *   (and a sub list)
 *  )
 * )
 */
void Prettify( std::string& aSource, char aQuoteChar )
{
    // Configuration
    const char indentChar = '\t';
    const int  indentSize = 1;
 
    // In order to visually compress PCB files, it is helpful to special-case long lists of (xy ...)
    // lists, which we allow to exist on a single line until we reach column 99.
    const int  xySpecialCaseColumnLimit = 99;
 
    // If whitespace occurs inside a list after this threshold, it will be converted into a newline
    // and the indentation will be increased.  This is mainly used for image and group objects,
    // which contain potentially long sets of string tokens within a single list.
    const int  consecutiveTokenWrapThreshold = 72;
 
    std::string formatted;
    formatted.reserve( aSource.length() );
 
    auto cursor = aSource.begin();
    auto seek = cursor;
 
    int  listDepth = 0;
    char lastNonWhitespace = 0;
    bool inQuote = false;
    bool hasInsertedSpace = false;
    bool inMultiLineList = false;
    bool inXY = false;
    int  column = 0;
    int  backslashCount = 0;    // Count of successive backslash read since any other char
 
    auto isWhitespace = []( const char aChar )
            {
                return ( aChar == ' ' || aChar == '\t' || aChar == '\n' || aChar == '\r' );
            };
 
    auto nextNonWhitespace =
            [&]( std::string::iterator aIt )
            {
                seek = aIt;
 
                while( seek != aSource.end() && isWhitespace( *seek ) )
                    seek++;
 
                if( seek == aSource.end() )
                    return (char)0;
 
                return *seek;
            };
 
    auto isXY =
            [&]( std::string::iterator aIt )
            {
                seek = aIt;
 
                if( ++seek == aSource.end() || *seek != 'x' )
                    return false;
 
                if( ++seek == aSource.end() || *seek != 'y' )
                    return false;
 
                if( ++seek == aSource.end() || *seek != ' ' )
                    return false;
 
                return true;
            };
 
    while( cursor != aSource.end() )
    {
        char next = nextNonWhitespace( cursor );
 
        if( isWhitespace( *cursor ) && !inQuote )
        {
            if( !hasInsertedSpace           // Only permit one space between chars
                && listDepth > 0            // Do not permit spaces in outer list
                && lastNonWhitespace != '(' // Remove extra space after start of list
                && next != ')'              // Remove extra space before end of list
                && next != '(' )            // Remove extra space before newline
            {
                if( inXY || column < consecutiveTokenWrapThreshold )
                {
                    // Note that we only insert spaces here, no matter what kind of whitespace is in
                    // the input.  Newlines will be inserted as needed by the logic below.
                    formatted.push_back( ' ' );
                    column++;
                }
                else
                {
                    formatted += fmt::format( "\n{}",
                                              std::string( listDepth * indentSize, indentChar ) );
                    column = listDepth * indentSize;
                    inMultiLineList = true;
                }
 
                hasInsertedSpace = true;
            }
        }
        else
        {
            hasInsertedSpace = false;
 
            if( *cursor == '(' && !inQuote )
            {
                bool currentIsXY = isXY( cursor );
 
                if( listDepth == 0 )
                {
                    formatted.push_back( '(' );
                    column++;
                }
                else if( inXY && currentIsXY && column < xySpecialCaseColumnLimit )
                {
                    // List-of-points special case
                    formatted += " (";
                    column += 2;
                    inXY = true;
                }
                else
                {
                    formatted += fmt::format( "\n{}(",
                                              std::string( listDepth * indentSize, indentChar ) );
                    column = listDepth * indentSize + 1;
                }
 
                inXY = currentIsXY;
                listDepth++;
            }
            else if( *cursor == ')' && !inQuote )
            {
                if( listDepth > 0 )
                    listDepth--;
 
                if( lastNonWhitespace == ')' || inMultiLineList )
                {
                    formatted += fmt::format( "\n{})",
                                              std::string( listDepth * indentSize, indentChar ) );
                    column = listDepth * indentSize + 1;
                    inMultiLineList = false;
                }
                else
                {
                    formatted.push_back( ')' );
                    column++;
                }
            }
            else
            {
                // The output formatter escapes double-quotes (like \")
                // But a corner case is a sequence like \\"
                // therefore a '\' is attached to a '"' if a odd number of '\' is detected
                if( *cursor == '\\' )
                    backslashCount++;
                else if( *cursor == aQuoteChar && ( backslashCount & 1 ) == 0 )
                    inQuote = !inQuote;
 
                if( *cursor != '\\' )
                    backslashCount = 0;
 
                formatted.push_back( *cursor );
                column++;
            }
 
            lastNonWhitespace = *cursor;
        }
 
        ++cursor;
    }
 
    // newline required at end of line / file for POSIX compliance. Keeps git diffs clean.
    formatted += '\n';
 
    aSource = std::move( formatted );
}
 
} // namespace KICAD_FORMAT