Subversion Repositories Projects

/*****************************************************************************
 *   Copyright (C) 2013 Oliver Gemesi                                        *
 *                                                                           *
 *   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 2 of the License.          *
 *                                                                           *
 *   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, write to the                           *
 *   Free Software Foundation, Inc.,                                         *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
 *****************************************************************************/

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+ xutils.c - erweiterte String-Funktionen, xprintf (Info nach History)
//+            und weitere Hilfsfunktionen wie z.B. UTCdatetime2local()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//############################################################################
//# HISTORY  xutils.c
//#
//# 12.04.2014 OG
//# - chg: strncpyat(), strncpyat_P(), _strncpyat() erweitert um Parameter 'sepcharcount'
//#
//# 08.04.2014 OG
//# - add: strncpyat(), strncpyat_P(), _strncpyat()
//#
//# 28.02.2014 OG
//# - add: buffered_sprintf(), buffered_sprintf_P()
//# - add: buffer sprintf_buffer[]
//# - chg: PGMBUFF_SIZE und ARGBUFF_SIZE von 80 auf 40 geaendert
//#
//# 24.06.2013 OG
//# - add: strrtrim() entfernt Leerzeichen auf der rechten Seite
//#
//# 14.05.2013 OG
//# - chg: Kommentarkopf von UTCdatetime2local() aktualisiert
//#
//# 05.05.2013 OG
//# - chg: UTCdatetime2local() auf Config.timezone/summertime umgestellt
//# - add: include eeprom.h
//#
//# 04.05.2013 OG
//# - chg: umbenannt zu xutils.c
//#
//# 03.05.2013 OG
//# - add: UTCdatetime2local()
//# - fix: _xvsnprintf() Darstellung kleiner negativer Nachkommazahlen (-1<z<0)
//#
//# 29.04.2013 OG
//# - chg: Doku zu xprintf Ergaenzt bei 'bekannte Einschraenkungen'
//# - chg: includes reduziert auf das Notwendige
//#
//# 28.04.2013 OG - NEU
//############################################################################


//############################################################################
//# xprintf
//#
//# Diese Variante von printf ist angepasst auf das PKT:
//#
//#  - Unterstuetzung von Festkomma-Integer Anzeige
//#  - Overflow-Anzeige durch '*' wenn eine Zahl die Format-Maske sprengt
//#  - progmen wird optional unterstuetz fuer den format-String als auch fuer
//#     String Argumente
//#  - strikte Einhaltung von Laengen einer Format-Maske
//#    (ggf. wird die Ausgabe gekuerzt)
//#
//# In diesem Source sind nur die Basis-xprintf zum Erzeugen von formatierten
//# Strings. Die direkten Ausgabefunktionen auf den Screen sind in lcd.c
//# als lcdx_printf_at() und lcdx_printf_at_P().
//#
//# FORMAT ANGABEN:
//#
//#   %d: dezimal int signed (Rechtsbuendige Ausgabe)   (Wandlung via itoa)
//#       "%d"    arg: 1234 -> "1234"
//#       "%5d"   arg: 1234 -> " 1234"
//#       "%5.2d" arg: 1234 -> "   12.34"
//#       "%05d"  arg: 123  -> "00123"
//#       "%3.2d" arg: -13  -> " -0.13"
//#
//#   %u: dezimal int unsigned (Rechtsbuendige Ausgabe) (Wandlung via utoa)
//#       wie %d jedoch mittels utoa
//#
//#   %h: hex int unsigned    -> Hex-Zahl     Rechtsbuendig, Laenge wird unterstuetzt z.B. "%4h"
//#   %o: octal int unsigned  -> Octal-Zahl   Rechtsbuendig, Laenge wird unterstuetzt z.B. "%2o"
//#   %b: binary int unsigned -> Binaer-Zahl  Rechtsbuendig, Laenge wird unterstuetzt z.B. "%8b"
//#
//#   %ld, %lu, %lh, %lo, %lb:
//#       wie die obigen jedoch fuer long-zahlen (via ltoa, ultoa)
//#       nur wenn define USE_XPRINTF_LONG gesetzt ist!
//#       Bespiele: "%ld", "%5.6ld" usw.
//#
//#   %s: String aus RAM      -> Linksbuendig, Laenge wird unterstuetzt (z.B. "%8s")
//#   %S: String aus progmem  -> Linksbuendig, Laenge wird unterstuetzt (z.B. "%8s")
//#
//#   %c: einzelnes char      -> Linksbuendig, Laenge wird unterstuetzt (z.B. "%8s")
//#   %%: Ausgabe von "%"
//#
//#
//# BEISPIELE:
//#
//#  vorhanden in: osd/osdata.c, lcd/lcd.c
//#
//#
//# BEKANNTE EINSCHRAENKUNGEN:
//#
//#  1. padding '0' mit negativen Zahlen wenn padding aktiv ist ergibt z.B. "00-1.5"
//#  2. der Entwickler muss auf eine korrekte Format-Maske achten. Andernfalls
//#     kommt es zu nicht vorhersehbaren Ausgaben.
//#  3. nicht in ISR's verwenden - dazu muss ggf. eine Anpassung durchgefuert werden
//#
//# KOMPILIER OPTIONEN
//#
//#  define: USE_XPRINTF_LONG
//#    Unterstuetzung von long int / unsigned long int ('l' Modifier in Maske)
//     Wird in der main.h gesetzt
//############################################################################

#define USE_XPRINTF_LONG  // Unterstuetzung von long integer - Achtung! Muss fuer PKT gesetzt sein
                          // da in Sourcen verwendet!


#include <avr/pgmspace.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <stdbool.h>

#include "../main.h"
#include "../timer/timer.h"
#include "../eeprom/eeprom.h"


#define PGMBUFF_SIZE 40     // max. 40 chars bei format-String aus progmem
#define ARGBUFF_SIZE 40     // buffer fuer xprintf Parameter (strings, itoa, utoa) (fuer ltoa ggf. anpassen)


#define SPRINTF_BUFFER_SIZE  40                  // max. 40 Chars fuer den Buffer fuer xsnprintf(), xsnprintf_P()
char sprintf_buffer[SPRINTF_BUFFER_SIZE];


//----------------------
// xprintf parser data
//----------------------
typedef struct
{
    uint8_t  parse;     // true / false
    char cmd;           // char: d u h o b s S c %
    uint8_t  prelen;    // Vorkomma
    uint8_t  declen;    // decimal (Nachkomma)
    uint8_t  point;     // true / false
    uint8_t  uselong;   // true / false
    uint8_t  mask;      // true / false
    char pad;           // ' ' oder '0'
} xprintf_t;


//----------------------
// Buffers
//----------------------
char cmddigit[7];
char argbuff[ARGBUFF_SIZE];
char pgmbuff[PGMBUFF_SIZE];


//####################################################################################


//---------------------------------------------------------------------
// Basisfunktion von xprintf
// Doku: siehe oben
//---------------------------------------------------------------------
void _xvsnprintf( uint8_t useprogmem, char *buffer, uint8_t n, const char *format, va_list ap )
{
    const char  *p_fmt;                         // pointer auf den format-String
    char        *p_dst;                         // pointer auf den destination buffer
    const char  *p_str;                         // pointer auf einen arg-String wenn ein String ausgegeben werden soll
    char        *p_cmddigit = 0;                // pointer auf den Digit-Buffer fuer eine Maske (Laenge/Nachkommastellen)
    const char  *p_fmtbuff;                     // pointer auf den format-Buffer (fuer progmem)
    const char  *p_argbuff;                     // pointer auf den argbuffer
    uint8_t     fmtlen, arglen, overflow;
    uint8_t     i,j,dec;
    uint8_t     dstcnt;
    uint8_t     minus;
    xprintf_t   cmd;                            // parser Daten

    p_fmtbuff = format;

    if( useprogmem )                            // format von progmem in's RAM kopieren
    {
        strncpy_P( pgmbuff, format, PGMBUFF_SIZE);
        pgmbuff[PGMBUFF_SIZE-1] = 0;
        p_fmtbuff = pgmbuff;
    }

    cmd.parse = false;
    p_fmt     = p_fmtbuff-1;                    // -1 -> wird am Anfang der Schleife korrigiert
    p_dst     = buffer;
    dstcnt    = 0;

    do
    {
        if( dstcnt >= n )                       // max. Anzahl von Zeichen fuer Ziel 'buffer' erreicht?
            break;

        p_fmt++;                                // naechstes Zeichen von format

        //########################
        //# 1. PARSE
        //########################

        //------------------------
        // START: parse cmd
        //------------------------
        if( cmd.parse == false && *p_fmt == '%' )
        {
            memset( &cmd, 0, sizeof(xprintf_t) );       // init
            cmd.parse  = true;
            cmd.pad    = ' ';
            p_cmddigit = cmddigit;
            continue;
        }

        //------------------------
        // NO parse: copy char
        //------------------------
        if( cmd.parse == false )
        {
            *p_dst = *p_fmt;
            p_dst++;
            dstcnt++;
            continue;
        }

        //------------------------
        // set: pad (eine '0' ganz am Anfang der Formatmaske)
        //------------------------
        if( cmd.parse == true && *p_fmt == '0' && p_cmddigit == cmddigit )
        {
            cmd.pad = '0';
            continue;
        }

        //------------------------
        // set: vor/nach-kommastellen
        //------------------------
        if( cmd.parse == true && *p_fmt >= '0' && *p_fmt <= '9' )
        {
            *p_cmddigit = *p_fmt;
            p_cmddigit++;
            continue;
        }

        //------------------------
        // set: point
        //------------------------
        if( cmd.parse == true && *p_fmt == '.' && cmd.point == false )
        {
            cmd.point   = true;
            *p_cmddigit = 0;
            cmd.prelen  = atoi( cmddigit );
            p_cmddigit  = cmddigit;
            continue;
        }

        //------------------------
        // set: uselong
        //------------------------
        #ifdef  USE_XPRINTF_LONG
        if( cmd.parse == true && *p_fmt == 'l' )
        {
            cmd.uselong  = true;
            continue;
        }
        #endif

        //------------------------
        // END: parse cmd
        //------------------------
        if( cmd.parse == true && (*p_fmt == 'd' || *p_fmt == 'u' || *p_fmt == 'x' || *p_fmt == 'b' || *p_fmt == 'o' ||
                                  *p_fmt == 's' || *p_fmt == 'S' || *p_fmt == 'c' || *p_fmt == '%') )
        {
            cmd.cmd     = *p_fmt;
            cmd.parse   = false;

            *p_cmddigit = 0;
            if( cmd.point == false )    cmd.prelen = atoi(cmddigit);
            else                        cmd.declen = atoi(cmddigit);

            if( cmd.point || cmd.prelen>0 )
                cmd.mask  = true;
        }


        //########################
        //# 2. EXECUTE
        //########################

        //------------------------
        // exec cmd: "d,u,x,b,o"
        //------------------------
        if( cmd.cmd == 'd' || cmd.cmd == 'u' || cmd.cmd == 'x' || cmd.cmd == 'b' || cmd.cmd == 'o' )
        {
            if( cmd.uselong )
            {
#ifdef  USE_XPRINTF_LONG
                switch(cmd.cmd)
                {
                    case 'd': ltoa ( va_arg(ap, long)         , argbuff, 10); break;    // LONG dezimal int signed
                    case 'u': ultoa( va_arg(ap, unsigned long), argbuff, 10); break;    // LONG dezimal int unsigned
                    case 'x': ultoa( va_arg(ap, unsigned long), argbuff, 16); break;    // LONG hex int unsigned
                    case 'b': ultoa( va_arg(ap, unsigned long), argbuff,  2); break;    // LONG binary int unsigned
                    case 'o': ultoa( va_arg(ap, unsigned long), argbuff,  8); break;    // LONG octal int unsigned
                }
#endif
            }
            else
            {
                switch(cmd.cmd)
                {
                    case 'd': itoa( va_arg(ap, int)         , argbuff, 10); break;      // dezimal int signed
                    case 'u': utoa( va_arg(ap, unsigned int), argbuff, 10); break;      // dezimal int unsigned
                    case 'x': utoa( va_arg(ap, unsigned int), argbuff, 16); break;      // hex int unsigned
                    case 'b': utoa( va_arg(ap, unsigned int), argbuff,  2); break;      // binary int unsigned
                    case 'o': utoa( va_arg(ap, unsigned int), argbuff,  8); break;      // octal int unsigned
                }
            }

            minus    = (argbuff[0] == '-');
            arglen   = strlen(argbuff);

            fmtlen   = cmd.prelen + cmd.declen + (cmd.point ? 1 : 0);
            arglen   = strlen(argbuff);

            overflow = cmd.mask &&                                                      // Zahl zu gross -> "*" anzeigen statt der Zahl
                         (arglen > cmd.prelen + cmd.declen || cmd.prelen < 1+minus);

            if( overflow )                                                              // overflow: Zahl passt nicht in Maske
            {                                                                           //   -> zeige '*.*'
                for( i=0; (i < fmtlen) && (dstcnt < n); i++)
                {
                    if( cmd.point && i==cmd.prelen )    *p_dst = '.';
                    else                                *p_dst = '*';
                    p_dst++;
                    dstcnt++;
                }
            }
            else                                                                        // else: if( overflow )
            {
                if( !cmd.mask )                                                         // keine Maske: alles von der Zahl ausgeben
                    fmtlen = arglen;

                p_argbuff = argbuff;
                if( minus )                                                             // wenn Zahl negativ: merken und auf dem argbuff nehmen
                {
                    p_argbuff++;
                    arglen--;
                }

                //-----------------
                // die Zahl wird 'Rueckwaerts' uebertragen
                //-----------------
                dec = -1;                                                               // wird am Anfang der Schleife auf 0 gesetzt
                j   = 1;                                                                // zaehler fuer argbuff
                for( i=1; i<=fmtlen; i++ )
                {
                    dec++;                                                              // Zaehler Dizmalstellen

                    if( dstcnt+fmtlen-i <= n )                                          // wenn Zielbuffer nicht ueberschritten
                    {
                        if( cmd.point && (dec == cmd.declen) )                          // Dezimalpunkt setzen
                        {
                            p_dst[fmtlen-i] = '.';
                            continue;
                        }

                        if( j <= arglen )                                               // Ziffer uebertragen aus argbuff
                        {
                            p_dst[fmtlen-i] = p_argbuff[arglen-j];
                            j++;
                            continue;
                        }

                        if( cmd.declen > 0 &&                                           // Nachkomma und 1. Vorkommastelle ggf. auf '0'
                              (dec < cmd.declen || dec == cmd.declen+1) )               //   setzen wenn die Zahl zu klein ist
                        {
                            p_dst[fmtlen-i] = '0';
                            continue;
                        }

                        if( minus && ( (cmd.pad == ' ') ||                              // ggf. Minuszeichen setzen
                                       (cmd.pad != ' ' && i == fmtlen) ) )              //  Minuszeichen bei '0'-padding an erster Stelle setzen
                        {
                            minus = false;
                            p_dst[fmtlen-i] = '-';
                            continue;
                        }

                        p_dst[fmtlen-i] = cmd.pad;                                      // padding ' ' oder '0'
                    }                                                                   // end: if( dstcnt+fmtlen-i <= n )
                }
                p_dst  += fmtlen;
                dstcnt += fmtlen;
            }
            continue;
        }

        //------------------------
        // exec cmd: "s", "S", "c"
        //------------------------
        if( cmd.cmd == 's' || cmd.cmd == 'S' || cmd.cmd == 'c' )
        {
            switch(cmd.cmd)
            {
                case 's':   p_str = va_arg( ap, char *);                                // String aus dem RAM
                            break;

                case 'S':   strncpy_P( argbuff, va_arg( ap, char *), ARGBUFF_SIZE);     // String liegt im progmem -> in's RAM kopieren
                            argbuff[ARGBUFF_SIZE-1] = 0;
                            p_str = argbuff;
                            break;

                case 'c':   argbuff[0] = va_arg( ap, int);                              // einzelnes char
                            argbuff[1] = 0;
                            p_str = argbuff;
                            break;
            }

            fmtlen = cmd.prelen;
            arglen = strlen(p_str);

            if( !cmd.mask )                                     // keine Maske: alles vom String ausgeben
                fmtlen = arglen;

            for( i=0; i<fmtlen; i++)
            {
                if( dstcnt < n )                                // wenn Zielbuffer nicht ueberschritten
                {
                    if( *p_str )                                // char uebertragen
                    {
                        *p_dst = *p_str;
                        p_str++;
                    }
                    else                                        // padding
                    {
                        *p_dst = ' ';
                    }
                    p_dst++;
                }
                dstcnt++;
            }

            continue;
        }

        //------------------------
        // exec cmd: "%"
        //------------------------
        if( cmd.cmd == '%' )
        {
            *p_dst = '%';
            p_dst++;
            dstcnt++;
            continue;
        }

    } while( (dstcnt < n) && *p_fmt );

    *(p_dst + (dstcnt < n ? 0 : -1)) = 0;       // terminierende 0 im Ausgabebuffer setzen
}



//---------------------------------------------------------------------
//---------------------------------------------------------------------
void xsnprintf( char *buffer, uint8_t n, const char *format, ... )
{
    va_list ap;

    va_start(ap, format);
    _xvsnprintf( false, buffer, n, format, ap);
    va_end(ap);
}


//---------------------------------------------------------------------
//---------------------------------------------------------------------
void xsnprintf_P( char *buffer, uint8_t n, const char *format, ... )
{
    va_list ap;

    va_start(ap, format);
    _xvsnprintf( true, buffer, n, format, ap);
    va_end(ap);
}



//-----------------------------------------------------------
// buffered_sprintf_P( format, ...)
//
// Ausgabe direkt in einen internen Buffer.
// Der Pointer auf den RAM-Buffer wird zurueckgegeben.
// Abgesichert bzgl. Buffer-Overflow.
//
// Groesse des Buffers: PRINTF_BUFFER_SIZE
//
// Parameter:
//  format     : String aus PROGMEM (siehe: xprintf in utils/xstring.h)
//  ...        : Parameter fuer 'format'
//-----------------------------------------------------------
char * buffered_sprintf( const char *format, ... )
{
    va_list ap;

    va_start( ap, format );
    _xvsnprintf( false, sprintf_buffer, SPRINTF_BUFFER_SIZE, format, ap );
    va_end(ap);
    return sprintf_buffer;
}



//-----------------------------------------------------------
// buffered_sprintf_P( format, ...)
//
// Ausgabe direkt in einen internen Buffer.
// Der Pointer auf den RAM-Buffer wird zurueckgegeben.
// Abgesichert bzgl. Buffer-Overflow.
//
// Groesse des Buffers: PRINTF_BUFFER_SIZE
//
// Parameter:
//  format     : String aus PROGMEM (siehe: xprintf in utils/xstring.h)
//  ...        : Parameter fuer 'format'
//-----------------------------------------------------------
char * buffered_sprintf_P( const char *format, ... )
{
    va_list ap;

    va_start( ap, format );
    _xvsnprintf( true, sprintf_buffer, SPRINTF_BUFFER_SIZE, format, ap );
    va_end(ap);
    return sprintf_buffer;
}



//--------------------------------------------------------------
// kopiert einen String von src auf dst mit fester Laenge und
// ggf. Space paddings rechts
//
// - fuellt ggf. den dst-String auf size Laenge mit Spaces
// - setzt Terminierung's 0 bei dst auf Position size
//--------------------------------------------------------------
void strncpyfill( char *dst, const char *src, size_t size)
{
    uint8_t i;
    uint8_t pad = false;

    for( i=0; i<size; i++)
    {
        if(*src == 0) pad = true;

        if( pad )   *dst = ' ';
        else        *dst = *src;

        src++;
        dst++;
    }
    dst--;
    *dst = 0;
}



//--------------------------------------------------------------
// entfernt rechte Leerzeichen aus einem String
//--------------------------------------------------------------
void strrtrim( char *dst)
{
    char    *p;

    p = dst + strlen(dst) - 1;

    while( (p != dst) && (*p == ' ') ) p--;

    if( (*p != ' ') && (*p != 0) ) p++;
    *p = 0;
}



//--------------------------------------------------------------
// INTERN - fuer strncpyat(), strncpyat_P()
//--------------------------------------------------------------
void _strncpyat( char *dst, const char *src, size_t size, const char sepchar, uint8_t sepcharcount, uint8_t progmem)
{
    uint8_t i;

    if( progmem )
        strncpy_P( dst, src, size);
    else
        strncpy( dst, src, size);

    for( i=0; i<size; i++)
    {
        if( *dst == 0) return;
        if( *dst == sepchar)
        {
            sepcharcount--;
            if( sepcharcount==0 )
            {
                *dst = 0;
                return;
            }
        }
        dst++;
    }
    dst--;
    *dst = 0;
}


//--------------------------------------------------------------
// strncpyat( dst, src, size, sepchar)
//
// kopiert einen String von 'src 'auf 'dst' mit max. Laenge 'size'
// oder bis 'sepchar' gefunden wird.
//
// src in PROGMEM
//--------------------------------------------------------------
void strncpyat( char *dst, const char *src, size_t size, const char sepchar, uint8_t sepcharcount)
{
    _strncpyat( dst, src, size, sepchar, sepcharcount, false);
}


//--------------------------------------------------------------
// strncpyat_P( dst, src, size, sepchar)
//
// kopiert einen String von 'src 'auf 'dst' mit max. Laenge 'size'
// oder bis 'sepchar' gefunden wird.
//
// src in RAM
//--------------------------------------------------------------
void strncpyat_P( char *dst, const char *src, size_t size, const char sepchar, uint8_t sepcharcount)
{
    _strncpyat( dst, src, size, sepchar, sepcharcount, true);
}



//--------------------------------------------------------------
// UTCdatetime2local( PKTdatetime_t *dtbuffer, PKTdatetime_t dt )
//
// konvertiert die UTC-Time 'dt' in die lokale Zeit und speichert
// dieses in 'dtbuffer' ab.
//
// Parameter:
//
//  dtdst: Pointer Destination (PKTdatetime_t) (Speicher muss alloziiert sein!)
//  dtsrc: Pointer Source (PKTdatetime_t)
//
// Hinweise:
//
//  Schaltjahre (bzw. der 29.02.) werden nicht unterstuetzt
//--------------------------------------------------------------
void UTCdatetime2local( PKTdatetime_t *dtdst, PKTdatetime_t *dtsrc )
{
    int8_t  timeoffset;
    int32_t v;
    int8_t  diff;
    //                    01 02 03 04 05 06 07 08 09 10 11 12    Monat
    int8_t  daymonth[] = {31,28,31,30,31,30,31,31,30,31,30,31};

    //--------------------------
    // timezone: Einstellbereich -12 .. 0 .. 12 (+1 = Berlin)
    // summertime: Einstellung: 0 oder 1 (0=Winterzeit, 1=Sommerzeit)
    //--------------------------
    timeoffset = Config.timezone + Config.summertime;
    //timeoffset = 2;                                   // solange noch nicht in PKT-Config: Berlin, Sommerzeit


    memcpy( dtdst, dtsrc, sizeof(PKTdatetime_t) );      // copy datetime to destination

    //--------------------------
    // Zeitzonenanpassung
    //--------------------------
    if( dtdst->year != 0 && dtdst->month >= 1 && dtdst->month <= 12 )   // nur wenn gueltiges Datum vorhanden
    {
        //--------------------------
        // 1. Sekunden
        //--------------------------
        v = (int32_t)dtdst->seconds;
        v += timeoffset*3600;                           // Stunden korrigieren
        diff = 0;

        if( v > 86400 )                                 // Tagesueberschreitung?    (86400 = 24*60*60 bzw. 24 Stunden)
        {
            v -= 86400;
            diff++;                                     //  inc: Tag
        }
        else if( v < 0 )                                // Tagesunterschreitung?
        {
            v += 86400;
            diff--;                                     //  dec: Tag
        }
        dtdst->seconds = (uint32_t)v;                   // SET: seconds

        //--------------------------
        // 2. Tag
        //--------------------------
        v = (int32_t)dtdst->day;
        v += diff;
        diff = 0;

        if( v > daymonth[dtdst->month-1] )              // Monatsueberschreitung?
        {
            v = 1;                                      // erster Tag des Monats
            diff++;                                     //  inc: Monat
        }
        else if( v < 1 )                                // Monatsunterschreitung?
        {
            if( dtdst->month > 1 )
                v = daymonth[dtdst->month-1-1];         // letzter Tag des vorherigen Monats
            else
                v = 31;                                 // letzter Tag im Dezember des vorherigen Jahres
            diff--;                                     //   dec: Monat
        }
        dtdst->day = (uint8_t)v;                        // SET: day

        //--------------------------
        // 3. Monat
        //--------------------------
        v = (int32_t)dtdst->month;
        v += diff;
        diff = 0;

        if( v > 12 )                                    // Jahresueberschreitung?
        {
            v = 1;
            diff++;                                     //  inc: Jahr
        }
        else if( v < 1 )                                // Jahresunterschreitung?
        {
            v = 12;
            diff--;                                     //  dec: Jahr
        }
        dtdst->month = (uint8_t)v;                      // SET: month

        //--------------------------
        // 4. Jahr
        //--------------------------
        dtdst->year += diff;                            // SET: year
    }
}