 @@ -1,1000 +1,1000 @@
-/*	$NetBSD: refclock_parse.c,v 1.22 2020/05/25 20:47:25 christos Exp $	*/
+/*	$NetBSD: refclock_parse.c,v 1.23 2020/09/03 07:26:41 kardel Exp $	*/
 /*
  * /src/NTP/REPOSITORY/ntp4-dev/ntpd/refclock_parse.c,v 4.81 2009/05/01 10:15:29 kardel RELEASE_20090105_A
+ *
  * refclock_parse.c,v 4.81 2009/05/01 10:15:29 kardel RELEASE_20090105_A
+ *
  * generic reference clock driver for several DCF/GPS/MSF/... receivers
+ *
  * PPS notes:
  *   On systems that support PPSAPI (RFC2783) PPSAPI is the
  *   preferred interface.
+ *
  *   Optionally make use of a STREAMS module for input processing where
  *   available and configured. This STREAMS module reduces the time
  *   stamp latency for serial and PPS events.
  *   Currently the STREAMS module is only available for Suns running
  *   SunOS 4.x and SunOS5.x.
+ *
  * Copyright (c) 1995-2015 by Frank Kardel <kardel <AT> ntp.org>
  * Copyright (c) 1989-1994 by Frank Kardel, Friedrich-Alexander Universitaet Erlangen-Nuernberg, Germany
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the author nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  */
 #ifdef HAVE_CONFIG_H
 # include "config.h"
 #endif
 #include "ntp_types.h"
 #if defined(REFCLOCK) && defined(CLOCK_PARSE)
 /*
  * This driver currently provides the support for
  *   - Meinberg receiver DCF77 PZF535 (TCXO version)        (DCF)
  *   - Meinberg receiver DCF77 PZF535 (OCXO version)        (DCF)
  *   - Meinberg receiver DCF77 PZF509                       (DCF)
  *   - Meinberg receiver DCF77 AM receivers (e.g. C51)      (DCF)
  *   - IGEL CLOCK                                           (DCF)
  *   - ELV DCF7000                                          (DCF)
  *   - Schmid clock                                         (DCF)
  *   - Conrad DCF77 receiver module                         (DCF)
  *   - FAU DCF77 NTP receiver (TimeBrick)                   (DCF)
  *   - WHARTON 400A Series clock                            (DCF)
+ *
  *   - Meinberg GPS receivers                               (GPS)
  *   - Trimble (TSIP and TAIP protocol)                     (GPS)
+ *
  *   - RCC8000 MSF Receiver                                 (MSF)
  *   - VARITEXT clock                                       (MSF)
  */
 /*
  * Meinberg receivers are usually connected via a
  * 9600/7E1 or 19200/8N1 serial line.
+ *
  * The Meinberg GPS receivers also have a special NTP time stamp
  * format. The firmware release is Uni-Erlangen.
+ *
  * Meinberg generic receiver setup:
  *      output time code every second
  *      Baud rate 9600 7E2S
+ *
  * Meinberg GPS receiver setup:
  *      output time code every second
  *      Baudrate 19200 8N1
+ *
  * This software supports the standard data formats used
  * in Meinberg receivers.
+ *
  * Special software versions are only sensible for the
  * oldest GPS receiver, GPS16x. For newer receiver types
  * the output string format can be configured at the device,
  * and the device name is generally GPSxxx instead of GPS16x.
+ *
  * Meinberg can be reached via: http://www.meinberg.de/
  */
 #include "ntpd.h"
 #include "ntp_refclock.h"
 #include "timevalops.h"		/* includes <sys/time.h> */
 #include "ntp_control.h"
 #include "ntp_string.h"
 #include <stdio.h>
 #include <ctype.h>
 #ifndef TM_IN_SYS_TIME
 # include <time.h>
 #endif
 #ifdef HAVE_UNISTD_H
 # include <unistd.h>
 #endif
 #if !defined(STREAM) && !defined(HAVE_SYSV_TTYS) && !defined(HAVE_BSD_TTYS) && !defined(HAVE_TERMIOS)
 # include "Bletch:  Define one of {STREAM,HAVE_SYSV_TTYS,HAVE_TERMIOS}"
 #endif
 #ifdef STREAM
 # include <sys/stream.h>
 # include <sys/stropts.h>
 #endif
 #ifdef HAVE_TERMIOS
 # include <termios.h>
 # define TTY_GETATTR(_FD_, _ARG_) tcgetattr((_FD_), (_ARG_))
 # define TTY_SETATTR(_FD_, _ARG_) tcsetattr((_FD_), TCSANOW, (_ARG_))
 # undef HAVE_SYSV_TTYS
 #endif
 #ifdef HAVE_SYSV_TTYS
 # define TTY_GETATTR(_FD_, _ARG_) ioctl((_FD_), TCGETA, (_ARG_))
 # define TTY_SETATTR(_FD_, _ARG_) ioctl((_FD_), TCSETAW, (_ARG_))
 #endif
 #ifdef HAVE_BSD_TTYS
 /* #error CURRENTLY NO BSD TTY SUPPORT */
 # include "Bletch: BSD TTY not currently supported"
 #endif
 #ifdef HAVE_SYS_IOCTL_H
 # include <sys/ioctl.h>
 #endif
 #ifdef HAVE_PPSAPI
 # include "ppsapi_timepps.h"
 # include "refclock_atom.h"
 #endif
 #ifdef PPS
 # ifdef HAVE_SYS_PPSCLOCK_H
 #  include <sys/ppsclock.h>
 # endif
 # ifdef HAVE_TIO_SERIAL_STUFF
 #  include <linux/serial.h>
 # endif
 #endif
 # define BUFFER_SIZE(_BUF, _PTR)       ((int)((_BUF) + sizeof(_BUF) - (_PTR)))
 # define BUFFER_SIZES(_BUF, _PTR, _SZ) ((int)((_BUF) + (_SZ) - (_PTR)))
 /*
  * document type of PPS interfacing - copy of ifdef mechanism in local_input()
  */
 #undef PPS_METHOD
 #ifdef HAVE_PPSAPI
 #define PPS_METHOD "PPS API"
 #else
 #ifdef TIOCDCDTIMESTAMP
 #define PPS_METHOD "TIOCDCDTIMESTAMP"
 #else /* TIOCDCDTIMESTAMP */
 #if defined(HAVE_STRUCT_PPSCLOCKEV) && (defined(HAVE_CIOGETEV) || defined(HAVE_TIOCGPPSEV))
 #ifdef HAVE_CIOGETEV
 #define PPS_METHOD "CIOGETEV"
 #endif
 #ifdef HAVE_TIOCGPPSEV
 #define PPS_METHOD "TIOCGPPSEV"
 #endif
 #endif
 #endif /* TIOCDCDTIMESTAMP */
 #endif /* HAVE_PPSAPI */
 /*
  * COND_DEF can be conditionally defined as DEF or 0. If defined as DEF
  * then some more parse-specific variables are flagged to be printed with
  * "ntpq -c cv <assid>". This can be lengthy, so by default COND_DEF
  * should be defined as 0.
  */
 #if 0
 # define COND_DEF   DEF   // enable this for testing
 #else
 # define COND_DEF   0     // enable this by default
 #endif
 #include "ntp_io.h"
 #include "ntp_stdlib.h"
 #include "parse.h"
 #include "mbg_gps166.h"
 #include "trimble.h"
 #include "binio.h"
 #include "ascii.h"
 #include "ieee754io.h"
 #include "recvbuff.h"
 static char rcsid[] = "refclock_parse.c,v 4.81 2009/05/01 10:15:29 kardel RELEASE_20090105_A+POWERUPTRUST";
 /**===========================================================================
  ** external interface to ntp mechanism
  **/
 static	int	parse_start	(int, struct peer *);
 static	void	parse_shutdown	(int, struct peer *);
 static	void	parse_poll	(int, struct peer *);
 static	void	parse_control	(int, const struct refclockstat *, struct refclockstat *, struct peer *);
 struct	refclock refclock_parse = {
 	parse_start,
 	parse_shutdown,
 	parse_poll,
 	parse_control,
 	noentry,
 	noentry,
 	NOFLAGS
 };
 /*
  * Definitions
  */
 #define	MAXUNITS	4	/* maximum number of "PARSE" units permitted */
 #define PARSEDEVICE	"/dev/refclock-%d" /* device to open %d is unit number */
 #define PARSEPPSDEVICE	"/dev/refclockpps-%d" /* optional pps device to open %d is unit number */
 #undef ABS
 #define ABS(_X_) (((_X_) < 0) ? -(_X_) : (_X_))
 #define PARSE_HARDPPS_DISABLE 0
 #define PARSE_HARDPPS_ENABLE  1
 /**===========================================================================
  ** function vector for dynamically binding io handling mechanism
  **/
 struct parseunit;		/* to keep inquiring minds happy */
 typedef struct bind
+{
   const char *bd_description;	                                /* name of type of binding */
   int	(*bd_init)     (struct parseunit *);			/* initialize */
   void	(*bd_end)      (struct parseunit *);			/* end */
   int   (*bd_setcs)    (struct parseunit *, parsectl_t *);	/* set character size */
   int	(*bd_disable)  (struct parseunit *);			/* disable */
   int	(*bd_enable)   (struct parseunit *);			/* enable */
   int	(*bd_getfmt)   (struct parseunit *, parsectl_t *);	/* get format */
   int	(*bd_setfmt)   (struct parseunit *, parsectl_t *);	/* setfmt */
   int	(*bd_timecode) (struct parseunit *, parsectl_t *);	/* get time code */
   void	(*bd_receive)  (struct recvbuf *);			/* receive operation */
   int	(*bd_io_input) (struct recvbuf *);			/* input operation */
 } bind_t;
 #define PARSE_END(_X_)			(*(_X_)->binding->bd_end)(_X_)
 #define PARSE_SETCS(_X_, _CS_)		(*(_X_)->binding->bd_setcs)(_X_, _CS_)
 #define PARSE_ENABLE(_X_)		(*(_X_)->binding->bd_enable)(_X_)
 #define PARSE_DISABLE(_X_)		(*(_X_)->binding->bd_disable)(_X_)
 #define PARSE_GETFMT(_X_, _DCT_)	(*(_X_)->binding->bd_getfmt)(_X_, _DCT_)
 #define PARSE_SETFMT(_X_, _DCT_)	(*(_X_)->binding->bd_setfmt)(_X_, _DCT_)
 #define PARSE_GETTIMECODE(_X_, _DCT_)	(*(_X_)->binding->bd_timecode)(_X_, _DCT_)
 /*
  * special handling flags
  */
 #define PARSE_F_PPSONSECOND	0x00000001 /* PPS pulses are on second */
 #define PARSE_F_POWERUPTRUST	0x00000100 /* POWERUP state ist trusted for */
                                            /* trusttime after SYNC was seen */
 /**===========================================================================
  ** error message regression handling
  **
  ** there are quite a few errors that can occur in rapid succession such as
  ** noisy input data or no data at all. in order to reduce the amount of
  ** syslog messages in such case, we are using a backoff algorithm. We limit
  ** the number of error messages of a certain class to 1 per time unit. if a
  ** configurable number of messages is displayed that way, we move on to the
  ** next time unit / count for that class. a count of messages that have been
  ** suppressed is held and displayed whenever a corresponding message is
  ** displayed. the time units for a message class will also be displayed.
  ** whenever an error condition clears we reset the error message state,
  ** thus we would still generate much output on pathological conditions
  ** where the system oscillates between OK and NOT OK states. coping
  ** with that condition is currently considered too complicated.
  **/
 #define ERR_ALL	        (unsigned)~0	/* "all" errors */
 #define ERR_BADDATA	(unsigned)0	/* unusable input data/conversion errors */
 #define ERR_NODATA	(unsigned)1	/* no input data */
 #define ERR_BADIO	(unsigned)2	/* read/write/select errors */
 #define ERR_BADSTATUS	(unsigned)3	/* unsync states */
 #define ERR_BADEVENT	(unsigned)4	/* non nominal events */
 #define ERR_INTERNAL	(unsigned)5	/* internal error */
 #define ERR_CNT		(unsigned)(ERR_INTERNAL+1)
 #define ERR(_X_)	if (list_err(parse, (_X_)))
 struct errorregression
+{
 	u_long err_count;	/* number of repititions per class */
 	u_long err_delay;	/* minimum delay between messages */
 };
 static struct errorregression
 err_baddata[] =			/* error messages for bad input data */
+{
 	{ 1,       0 },		/* output first message immediately */
 	{ 5,      60 },		/* output next five messages in 60 second intervals */
 	{ 3,    3600 },		/* output next 3 messages in hour intervals */
 	{ 0, 12*3600 }		/* repeat messages only every 12 hours */
 };
 static struct errorregression
 err_nodata[] =			/* error messages for missing input data */
+{
 	{ 1,       0 },		/* output first message immediately */
 	{ 5,      60 },		/* output next five messages in 60 second intervals */
 	{ 3,    3600 },		/* output next 3 messages in hour intervals */
 	{ 0, 12*3600 }		/* repeat messages only every 12 hours */
 };
 static struct errorregression
 err_badstatus[] =		/* unsynchronized state messages */
+{
 	{ 1,       0 },		/* output first message immediately */
 	{ 5,      60 },		/* output next five messages in 60 second intervals */
 	{ 3,    3600 },		/* output next 3 messages in hour intervals */
 	{ 0, 12*3600 }		/* repeat messages only every 12 hours */
 };
 static struct errorregression
 err_badio[] =			/* io failures (bad reads, selects, ...) */
+{
 	{ 1,       0 },		/* output first message immediately */
 	{ 5,      60 },		/* output next five messages in 60 second intervals */
 	{ 5,    3600 },		/* output next 3 messages in hour intervals */
 	{ 0, 12*3600 }		/* repeat messages only every 12 hours */
 };
 static struct errorregression
 err_badevent[] =		/* non nominal events */
+{
 	{ 20,      0 },		/* output first message immediately */
 	{ 6,      60 },		/* output next five messages in 60 second intervals */
 	{ 5,    3600 },		/* output next 3 messages in hour intervals */
 	{ 0, 12*3600 }		/* repeat messages only every 12 hours */
 };
 static struct errorregression
 err_internal[] =		/* really bad things - basically coding/OS errors */
+{
 	{ 0,       0 },		/* output all messages immediately */
 };
 static struct errorregression *
 err_tbl[] =
+{
 	err_baddata,
 	err_nodata,
 	err_badio,
 	err_badstatus,
 	err_badevent,
 	err_internal
 };
 struct errorinfo
+{
 	u_long err_started;	/* begin time (ntp) of error condition */
 	u_long err_last;	/* last time (ntp) error occurred */
 	u_long err_cnt;	/* number of error repititions */
 	u_long err_suppressed;	/* number of suppressed messages */
 	struct errorregression *err_stage; /* current error stage */
 };
 /**===========================================================================
  ** refclock instance data
  **/
 struct parseunit
+{
 	/*
 	 * NTP management
 	 */
 	struct peer         *peer;		/* backlink to peer structure - refclock inactive if 0  */
 	struct refclockproc *generic;		/* backlink to refclockproc structure */
 	/*
 	 * PARSE io
 	 */
 	bind_t	     *binding;	        /* io handling binding */
 	/*
 	 * parse state
 	 */
 	parse_t	      parseio;	        /* io handling structure (user level parsing) */
 	/*
 	 * type specific parameters
 	 */
 	struct parse_clockinfo   *parse_type;	        /* link to clock description */
 	/*
 	 * clock state handling/reporting
 	 */
 	u_char	      flags;	        /* flags (leap_control) */
 	u_long	      lastchange;       /* time (ntp) when last state change accured */
 	u_long	      statetime[CEVNT_MAX+1]; /* accumulated time of clock states */
 	u_long        pollneeddata; 	/* current_time(!=0) for receive sample expected in PPS mode */
 	u_short	      lastformat;       /* last format used */
 	u_long        lastsync;		/* time (ntp) when clock was last seen fully synchronized */
         u_long        maxunsync;        /* max time in seconds a receiver is trusted after loosing synchronisation */
         double        ppsphaseadjust;   /* phase adjustment of PPS time stamp */
         u_long        lastmissed;       /* time (ntp) when poll didn't get data (powerup heuristic) */
 	u_long        ppsserial;        /* magic cookie for ppsclock serials (avoids stale ppsclock data) */
 	int	      ppsfd;	        /* fd to ise for PPS io */
 #ifdef HAVE_PPSAPI
         int           hardppsstate;     /* current hard pps state */
 	struct refclock_atom atom;      /* PPSAPI structure */
 #endif
 	parsetime_t   timedata;		/* last (parse module) data */
 	void         *localdata;        /* optional local, receiver-specific data */
         unsigned long localstate;       /* private local state */
 	struct errorinfo errors[ERR_CNT];  /* error state table for suppressing excessive error messages */
 	struct ctl_var *kv;	        /* additional pseudo variables */
 	u_long        laststatistic;    /* time when staticstics where output */
 };
 /**===========================================================================
  ** Clockinfo section all parameter for specific clock types
  ** includes NTP parameters, TTY parameters and IO handling parameters
  **/
 static	void	poll_dpoll	(struct parseunit *);
 static	void	poll_poll	(struct peer *);
 static	int	poll_init	(struct parseunit *);
 typedef struct poll_info
+{
 	u_long      rate;		/* poll rate - once every "rate" seconds - 0 off */
 	const char *string;		/* string to send for polling */
 	u_long      count;		/* number of characters in string */
 } poll_info_t;
 #define NO_CL_FLAGS	0
 #define NO_POLL		0
 #define NO_INIT		0
 #define NO_END		0
 #define NO_EVENT	0
 #define NO_LCLDATA	0
 #define NO_MESSAGE	0
 #define NO_PPSDELAY     0
 #define DCF_ID		"DCF"	/* generic DCF */
 #define DCF_A_ID	"DCFa"	/* AM demodulation */
 #define DCF_P_ID	"DCFp"	/* psuedo random phase shift */
 #define GPS_ID		"GPS"	/* GPS receiver */
 #define NOCLOCK_ROOTDELAY       0.0
 #define NOCLOCK_BASEDELAY       0.0
 #define NOCLOCK_DESCRIPTION     0
 #define NOCLOCK_MAXUNSYNC       0
 #define NOCLOCK_CFLAG           0
 #define NOCLOCK_IFLAG           0
 #define NOCLOCK_OFLAG           0
 #define NOCLOCK_LFLAG           0
 #define NOCLOCK_ID              "TILT"
 #define NOCLOCK_POLL            NO_POLL
 #define NOCLOCK_INIT            NO_INIT
 #define NOCLOCK_END             NO_END
 #define NOCLOCK_DATA            NO_LCLDATA
 #define NOCLOCK_FORMAT          ""
 #define NOCLOCK_TYPE            CTL_SST_TS_UNSPEC
 #define NOCLOCK_SAMPLES         0
 #define NOCLOCK_KEEP            0
 #define DCF_TYPE		CTL_SST_TS_LF
 #define GPS_TYPE		CTL_SST_TS_UHF
 /*
  * receiver specific constants
  */
 #define MBG_SPEED		(B9600)
 #define MBG_CFLAG		(CS7|PARENB|CREAD|CLOCAL|HUPCL|CSTOPB)
 #define MBG_IFLAG		(IGNBRK|IGNPAR|ISTRIP)
 #define MBG_OFLAG		0
 #define MBG_LFLAG		0
 #define MBG_FLAGS               PARSE_F_PPSONSECOND
 /*
  * Meinberg DCF77 receivers
  */
 #define	DCFUA31_ROOTDELAY	0.0  /* 0 */
 #define	DCFUA31_BASEDELAY	0.010  /* 10.7421875ms: 10 ms (+/- 3 ms) */
 #define	DCFUA31_DESCRIPTION	"Meinberg DCF77 C51 or compatible"
 #define DCFUA31_MAXUNSYNC       60*30       /* only trust clock for 1/2 hour */
 #define DCFUA31_SPEED		MBG_SPEED
 #define DCFUA31_CFLAG           MBG_CFLAG
 #define DCFUA31_IFLAG           MBG_IFLAG
 #define DCFUA31_OFLAG           MBG_OFLAG
 #define DCFUA31_LFLAG           MBG_LFLAG
 #define DCFUA31_SAMPLES		5
 #define DCFUA31_KEEP		3
 #define DCFUA31_FORMAT		"Meinberg Standard"
 /*
  * Meinberg DCF PZF535/TCXO (FM/PZF) receiver
  */
 #define	DCFPZF535_ROOTDELAY	0.0
 #define	DCFPZF535_BASEDELAY	0.001968  /* 1.968ms +- 104us (oscilloscope) - relative to start (end of STX) */
 #define	DCFPZF535_DESCRIPTION	"Meinberg DCF PZF 535/509 / TCXO"
 #define DCFPZF535_MAXUNSYNC     60*60*12           /* only trust clock for 12 hours
 						    * @ 5e-8df/f we have accumulated
 						    * at most 2.16 ms (thus we move to
 						    * NTP synchronisation */
 #define DCFPZF535_SPEED		MBG_SPEED
 #define DCFPZF535_CFLAG         MBG_CFLAG
 #define DCFPZF535_IFLAG         MBG_IFLAG
 #define DCFPZF535_OFLAG         MBG_OFLAG
 #define DCFPZF535_LFLAG         MBG_LFLAG
 #define DCFPZF535_SAMPLES	       5
 #define DCFPZF535_KEEP		       3
 #define DCFPZF535_FORMAT	"Meinberg Standard"
 /*
  * Meinberg DCF PZF535/OCXO receiver
  */
 #define	DCFPZF535OCXO_ROOTDELAY	0.0
 #define	DCFPZF535OCXO_BASEDELAY	0.001968 /* 1.968ms +- 104us (oscilloscope) - relative to start (end of STX) */
 #define	DCFPZF535OCXO_DESCRIPTION "Meinberg DCF PZF 535/509 / OCXO"
 #define DCFPZF535OCXO_MAXUNSYNC     60*60*96       /* only trust clock for 4 days
 						    * @ 5e-9df/f we have accumulated
 						    * at most an error of 1.73 ms
 						    * (thus we move to NTP synchronisation) */
 #define DCFPZF535OCXO_SPEED	    MBG_SPEED
 #define DCFPZF535OCXO_CFLAG         MBG_CFLAG
 #define DCFPZF535OCXO_IFLAG         MBG_IFLAG
 #define DCFPZF535OCXO_OFLAG         MBG_OFLAG
 #define DCFPZF535OCXO_LFLAG         MBG_LFLAG
 #define DCFPZF535OCXO_SAMPLES		   5
 #define DCFPZF535OCXO_KEEP	           3
 #define DCFPZF535OCXO_FORMAT	    "Meinberg Standard"
 /*
  * Meinberg GPS receivers
  */
 static	void	gps16x_message	 (struct parseunit *, parsetime_t *);
 static  int     gps16x_poll_init (struct parseunit *);
 #define	GPS16X_ROOTDELAY	0.0         /* nothing here */
 #define	GPS16X_BASEDELAY	0.001968         /* XXX to be fixed ! 1.968ms +- 104us (oscilloscope) - relative to start (end of STX) */
 #define	GPS16X_DESCRIPTION      "Meinberg GPS receiver"
 #define GPS16X_MAXUNSYNC        60*60*96       /* only trust clock for 4 days
 						* @ 5e-9df/f we have accumulated
 						* at most an error of 1.73 ms
 						* (thus we move to NTP synchronisation) */
 #define GPS16X_SPEED		B19200
 #define GPS16X_CFLAG            (CS8|CREAD|CLOCAL|HUPCL)
 #define GPS16X_IFLAG            (IGNBRK|IGNPAR)
 #define GPS16X_OFLAG            MBG_OFLAG
 #define GPS16X_LFLAG            MBG_LFLAG
 #define GPS16X_POLLRATE	6
 #define GPS16X_POLLCMD	""
 #define GPS16X_CMDSIZE	0
 static poll_info_t gps16x_pollinfo = { GPS16X_POLLRATE, GPS16X_POLLCMD, GPS16X_CMDSIZE };
 #define GPS16X_INIT		gps16x_poll_init
 #define GPS16X_POLL	        0
 #define GPS16X_END		0
 #define GPS16X_DATA		((void *)(&gps16x_pollinfo))
 #define GPS16X_MESSAGE		gps16x_message
 #define GPS16X_ID		GPS_ID
 #define GPS16X_FORMAT		"Meinberg GPS Extended"
 #define GPS16X_SAMPLES		5
 #define GPS16X_KEEP		3
 /*
  * ELV DCF7000 Wallclock-Receiver/Switching Clock (Kit)
+ *
  * This is really not the hottest clock - but before you have nothing ...
  */
 #define DCF7000_ROOTDELAY	0.0 /* 0 */
 #define DCF7000_BASEDELAY	0.405 /* slow blow */
 #define DCF7000_DESCRIPTION	"ELV DCF7000"
 #define DCF7000_MAXUNSYNC	(60*5) /* sorry - but it just was not build as a clock */
 #define DCF7000_SPEED		(B9600)
 #define DCF7000_CFLAG           (CS8|CREAD|PARENB|PARODD|CLOCAL|HUPCL)
 #define DCF7000_IFLAG		(IGNBRK)
 #define DCF7000_OFLAG		0
 #define DCF7000_LFLAG		0
 #define DCF7000_SAMPLES		5
 #define DCF7000_KEEP		3
 #define DCF7000_FORMAT		"ELV DCF7000"
 /*
  * Schmid DCF Receiver Kit
+ *
  * When the WSDCF clock is operating optimally we want the primary clock
  * distance to come out at 300 ms.  Thus, peer.distance in the WSDCF peer
  * structure is set to 290 ms and we compute delays which are at least
  * 10 ms long.  The following are 290 ms and 10 ms expressed in u_fp format
  */
 #define WS_POLLRATE	1	/* every second - watch interdependency with poll routine */
 #define WS_POLLCMD	"\163"
 #define WS_CMDSIZE	1
 static poll_info_t wsdcf_pollinfo = { WS_POLLRATE, WS_POLLCMD, WS_CMDSIZE };
 #define WSDCF_INIT		poll_init
 #define WSDCF_POLL		poll_dpoll
 #define WSDCF_END		0
 #define WSDCF_DATA		((void *)(&wsdcf_pollinfo))
 #define	WSDCF_ROOTDELAY		0.0	/* 0 */
 #define	WSDCF_BASEDELAY	 	0.010	/*  ~  10ms */
 #define WSDCF_DESCRIPTION	"WS/DCF Receiver"
 #define WSDCF_FORMAT		"Schmid"
 #define WSDCF_MAXUNSYNC		(60*60)	/* assume this beast hold at 1 h better than 2 ms XXX-must verify */
 #define WSDCF_SPEED		(B1200)
 #define WSDCF_CFLAG		(CS8|CREAD|CLOCAL)
 #define WSDCF_IFLAG		0
 #define WSDCF_OFLAG		0
 #define WSDCF_LFLAG		0
 #define WSDCF_SAMPLES		5
 #define WSDCF_KEEP		3
 /*
  * RAW DCF77 - input of DCF marks via RS232 - many variants
  */
 #define RAWDCF_FLAGS		0
 #define RAWDCF_ROOTDELAY	0.0 /* 0 */
 #define RAWDCF_BASEDELAY	0.258
 #define RAWDCF_FORMAT		"RAW DCF77 Timecode"
 #define RAWDCF_MAXUNSYNC	(0) /* sorry - its a true receiver - no signal - no time */
 #define RAWDCF_SPEED		(B50)
 #ifdef NO_PARENB_IGNPAR /* Was: defined(SYS_IRIX4) || defined(SYS_IRIX5) */
 /* somehow doesn't grok PARENB & IGNPAR (mj) */
 # define RAWDCF_CFLAG            (CS8|CREAD|CLOCAL)
 #else
 # define RAWDCF_CFLAG            (CS8|CREAD|CLOCAL|PARENB)
 #endif
 #ifdef RAWDCF_NO_IGNPAR /* Was: defined(SYS_LINUX) && defined(CLOCK_RAWDCF) */
 # define RAWDCF_IFLAG		0
 #else
 # define RAWDCF_IFLAG		(IGNPAR)
 #endif
 #define RAWDCF_OFLAG		0
 #define RAWDCF_LFLAG		0
 #define RAWDCF_SAMPLES		20
 #define RAWDCF_KEEP		12
 #define RAWDCF_INIT		0
 /*
  * RAW DCF variants
  */
 /*
  * Conrad receiver
+ *
  * simplest (cheapest) DCF clock - e. g. DCF77 receiver by Conrad
  * (~40DM - roughly $30 ) followed by a level converter for RS232
  */
 #define CONRAD_BASEDELAY	0.292 /* Conrad receiver @ 50 Baud on a Sun */
 #define CONRAD_DESCRIPTION	"RAW DCF77 CODE (Conrad DCF77 receiver module)"
 /* Gude Analog- und Digitalsystem GmbH 'Expert mouseCLOCK USB v2.0' */
 #define GUDE_EMC_USB_V20_SPEED            (B4800)
 #define GUDE_EMC_USB_V20_BASEDELAY        0.425 /* USB serial<->USB converter FTDI232R */
 #define GUDE_EMC_USB_V20_DESCRIPTION      "RAW DCF77 CODE (Expert mouseCLOCK USB v2.0)"
 /*
  * TimeBrick receiver
  */
 #define TIMEBRICK_BASEDELAY	0.210 /* TimeBrick @ 50 Baud on a Sun */
 #define TIMEBRICK_DESCRIPTION	"RAW DCF77 CODE (TimeBrick)"
 /*
  * IGEL:clock receiver
  */
 #define IGELCLOCK_BASEDELAY	0.258 /* IGEL:clock receiver */
 #define IGELCLOCK_DESCRIPTION	"RAW DCF77 CODE (IGEL:clock)"
 #define IGELCLOCK_SPEED		(B1200)
 #define IGELCLOCK_CFLAG		(CS8|CREAD|HUPCL|CLOCAL)
 /*
  * RAWDCF receivers that need to be powered from DTR
  * (like Expert mouse clock)
  */
 static	int	rawdcf_init_1	(struct parseunit *);
 #define RAWDCFDTRSET_DESCRIPTION	"RAW DCF77 CODE (DTR SET/RTS CLR)"
 #define RAWDCFDTRSET75_DESCRIPTION	"RAW DCF77 CODE (DTR SET/RTS CLR @ 75 baud)"
 #define RAWDCFDTRSET_INIT 		rawdcf_init_1
 /*
  * RAWDCF receivers that need to be powered from
  * DTR CLR and RTS SET
  */
 static	int	rawdcf_init_2	(struct parseunit *);
 #define RAWDCFDTRCLRRTSSET_DESCRIPTION	"RAW DCF77 CODE (DTR CLR/RTS SET)"
 #define RAWDCFDTRCLRRTSSET75_DESCRIPTION "RAW DCF77 CODE (DTR CLR/RTS SET @ 75 baud)"
 #define RAWDCFDTRCLRRTSSET_INIT	rawdcf_init_2
 /*
  * Trimble GPS receivers (TAIP and TSIP protocols)
  */
 #ifndef TRIM_POLLRATE
 #define TRIM_POLLRATE	0	/* only true direct polling */
 #endif
 #define TRIM_TAIPPOLLCMD	">SRM;FR_FLAG=F;EC_FLAG=F<>QTM<"
 #define TRIM_TAIPCMDSIZE	(sizeof(TRIM_TAIPPOLLCMD)-1)
 static poll_info_t trimbletaip_pollinfo = { TRIM_POLLRATE, TRIM_TAIPPOLLCMD, TRIM_TAIPCMDSIZE };
 static	int	trimbletaip_init	(struct parseunit *);
 static	void	trimbletaip_event	(struct parseunit *, int);
 /* query time & UTC correction data */
 static char tsipquery[] = { DLE, 0x21, DLE, ETX, DLE, 0x2F, DLE, ETX };
 static poll_info_t trimbletsip_pollinfo = { TRIM_POLLRATE, tsipquery, sizeof(tsipquery) };
 static	int	trimbletsip_init	(struct parseunit *);
 static	void	trimbletsip_end   	(struct parseunit *);
 static	void	trimbletsip_message	(struct parseunit *, parsetime_t *);
 static	void	trimbletsip_event	(struct parseunit *, int);
 #define TRIMBLETSIP_IDLE_TIME	    (300) /* 5 minutes silence at most */
 #define TRIMBLE_RESET_HOLDOFF       TRIMBLETSIP_IDLE_TIME
 #define TRIMBLETAIP_SPEED	    (B4800)
 #define TRIMBLETAIP_CFLAG           (CS8|CREAD|CLOCAL)
 #define TRIMBLETAIP_IFLAG           (BRKINT|IGNPAR|ISTRIP|ICRNL|IXON)
 #define TRIMBLETAIP_OFLAG           (OPOST|ONLCR)
 #define TRIMBLETAIP_LFLAG           (0)
 #define TRIMBLETSIP_SPEED	    (B9600)
 #define TRIMBLETSIP_CFLAG           (CS8|CLOCAL|CREAD|PARENB|PARODD)
 #define TRIMBLETSIP_IFLAG           (IGNBRK)
 #define TRIMBLETSIP_OFLAG           (0)
 #define TRIMBLETSIP_LFLAG           (ICANON)
 #define TRIMBLETSIP_SAMPLES	    5
 #define TRIMBLETSIP_KEEP	    3
 #define TRIMBLETAIP_SAMPLES	    5
 #define TRIMBLETAIP_KEEP	    3
 #define TRIMBLETAIP_FLAGS	    (PARSE_F_PPSONSECOND)
 #define TRIMBLETSIP_FLAGS	    (TRIMBLETAIP_FLAGS)
 #define TRIMBLETAIP_POLL	    poll_dpoll
 #define TRIMBLETSIP_POLL	    poll_dpoll
 #define TRIMBLETAIP_INIT	    trimbletaip_init
 #define TRIMBLETSIP_INIT	    trimbletsip_init
 #define TRIMBLETAIP_EVENT	    trimbletaip_event
 #define TRIMBLETSIP_EVENT	    trimbletsip_event
 #define TRIMBLETSIP_MESSAGE	    trimbletsip_message
 #define TRIMBLETAIP_END		    0
 #define TRIMBLETSIP_END		    trimbletsip_end
 #define TRIMBLETAIP_DATA	    ((void *)(&trimbletaip_pollinfo))
 #define TRIMBLETSIP_DATA	    ((void *)(&trimbletsip_pollinfo))
 #define TRIMBLETAIP_ID		    GPS_ID
 #define TRIMBLETSIP_ID		    GPS_ID
 #define TRIMBLETAIP_FORMAT	    "Trimble TAIP"
 #define TRIMBLETSIP_FORMAT	    "Trimble TSIP"
 #define TRIMBLETAIP_ROOTDELAY        0x0
 #define TRIMBLETSIP_ROOTDELAY        0x0
 #define TRIMBLETAIP_BASEDELAY        0.0
 #define TRIMBLETSIP_BASEDELAY        0.020	/* GPS time message latency */
 #define TRIMBLETAIP_DESCRIPTION      "Trimble GPS (TAIP) receiver"
 #define TRIMBLETSIP_DESCRIPTION      "Trimble GPS (TSIP) receiver"
 #define TRIMBLETAIP_MAXUNSYNC        0
 #define TRIMBLETSIP_MAXUNSYNC        0
 #define TRIMBLETAIP_EOL		    '<'
 /*
  * RadioCode Clocks RCC 800 receiver
  */
 #define RCC_POLLRATE   0       /* only true direct polling */
 #define RCC_POLLCMD    "\r"
 #define RCC_CMDSIZE    1
 static poll_info_t rcc8000_pollinfo = { RCC_POLLRATE, RCC_POLLCMD, RCC_CMDSIZE };
 #define RCC8000_FLAGS		0
 #define RCC8000_POLL            poll_dpoll
 #define RCC8000_INIT            poll_init
 #define RCC8000_END             0
 #define RCC8000_DATA            ((void *)(&rcc8000_pollinfo))
 #define RCC8000_ROOTDELAY       0.0
 #define RCC8000_BASEDELAY       0.0
 #define RCC8000_ID              "MSF"
 #define RCC8000_DESCRIPTION     "RCC 8000 MSF Receiver"
 #define RCC8000_FORMAT          "Radiocode RCC8000"
 #define RCC8000_MAXUNSYNC       (60*60) /* should be ok for an hour */
 #define RCC8000_SPEED		(B2400)
 #define RCC8000_CFLAG           (CS8|CREAD|CLOCAL)
 #define RCC8000_IFLAG           (IGNBRK|IGNPAR)
 #define RCC8000_OFLAG           0
 #define RCC8000_LFLAG           0
 #define RCC8000_SAMPLES         5
 #define RCC8000_KEEP	        3
 /*
  * Hopf Radio clock 6021 Format
+ *
  */
 #define HOPF6021_ROOTDELAY	0.0
 #define HOPF6021_BASEDELAY	0.0
 #define HOPF6021_DESCRIPTION	"HOPF 6021"
 #define HOPF6021_FORMAT         "hopf Funkuhr 6021"
 #define HOPF6021_MAXUNSYNC	(60*60)  /* should be ok for an hour */
 #define HOPF6021_SPEED         (B9600)
 #define HOPF6021_CFLAG          (CS8|CREAD|CLOCAL)
 #define HOPF6021_IFLAG		(IGNBRK|ISTRIP)
 #define HOPF6021_OFLAG		0
 #define HOPF6021_LFLAG		0
 #define HOPF6021_FLAGS          0
 #define HOPF6021_SAMPLES        5
 #define HOPF6021_KEEP	        3
 /*
  * Diem's Computime Radio Clock Receiver
  */
 #define COMPUTIME_FLAGS       0
 #define COMPUTIME_ROOTDELAY   0.0
 #define COMPUTIME_BASEDELAY   0.0
 #define COMPUTIME_ID          DCF_ID
 #define COMPUTIME_DESCRIPTION "Diem's Computime receiver"
 #define COMPUTIME_FORMAT      "Diem's Computime Radio Clock"
 #define COMPUTIME_TYPE        DCF_TYPE
 #define COMPUTIME_MAXUNSYNC   (60*60)       /* only trust clock for 1 hour */
 #define COMPUTIME_SPEED       (B9600)
 #define COMPUTIME_CFLAG       (CSTOPB|CS7|CREAD|CLOCAL)
 #define COMPUTIME_IFLAG       (IGNBRK|IGNPAR|ISTRIP)
 #define COMPUTIME_OFLAG       0
 #define COMPUTIME_LFLAG       0
 #define COMPUTIME_SAMPLES     5
 #define COMPUTIME_KEEP        3
 /*
  * Varitext Radio Clock Receiver
  */
 #define VARITEXT_FLAGS       0
 #define VARITEXT_ROOTDELAY   0.0
 #define VARITEXT_BASEDELAY   0.0
 #define VARITEXT_ID          "MSF"
 #define VARITEXT_DESCRIPTION "Varitext receiver"
 #define VARITEXT_FORMAT      "Varitext Radio Clock"
 #define VARITEXT_TYPE        DCF_TYPE
 #define VARITEXT_MAXUNSYNC   (60*60)       /* only trust clock for 1 hour */
 #define VARITEXT_SPEED       (B9600)
 #define VARITEXT_CFLAG       (CS7|CREAD|CLOCAL|PARENB|PARODD)
 #define VARITEXT_IFLAG       (IGNPAR|IGNBRK|INPCK) /*|ISTRIP)*/
 #define VARITEXT_OFLAG       0
 #define VARITEXT_LFLAG       0
 #define VARITEXT_SAMPLES     32
 #define VARITEXT_KEEP        20
 /*
  * SEL240x Satellite Sychronized Clock
  */
 #define SEL240X_POLLRATE	0 /* only true direct polling */
 #define SEL240X_POLLCMD		"BUB8"
 #define SEL240X_CMDSIZE		4
 static poll_info_t sel240x_pollinfo = { SEL240X_POLLRATE,
 	                                SEL240X_POLLCMD,
 					SEL240X_CMDSIZE };
 #define SEL240X_FLAGS		(PARSE_F_PPSONSECOND)
 #define SEL240X_POLL		poll_dpoll
 #define SEL240X_INIT		poll_init
 #define SEL240X_END		0
 #define SEL240X_DATA            ((void *)(&sel240x_pollinfo))
 #define SEL240X_ROOTDELAY	0.0
 #define SEL240X_BASEDELAY	0.0
 #define SEL240X_ID		GPS_ID
 #define SEL240X_DESCRIPTION	"SEL240x Satellite Synchronized Clock"
 #define SEL240X_FORMAT		"SEL B8"
 #define SEL240X_MAXUNSYNC	60*60*12 /* only trust clock for 12 hours */
 #define SEL240X_SPEED		(B9600)
 #define SEL240X_CFLAG		(CS8|CREAD|CLOCAL)
 #define SEL240X_IFLAG		(IGNBRK|IGNPAR)
 #define SEL240X_OFLAG		(0)
 #define SEL240X_LFLAG		(0)
 #define SEL240X_SAMPLES		5
 #define SEL240X_KEEP		3
 static struct parse_clockinfo
+{
 	u_long  cl_flags;		/* operation flags (PPS interpretation, trust handling) */
   void  (*cl_poll)    (struct parseunit *);			/* active poll routine */
   int   (*cl_init)    (struct parseunit *);			/* active poll init routine */
   void  (*cl_event)   (struct parseunit *, int);		/* special event handling (e.g. reset clock) */
   void  (*cl_end)     (struct parseunit *);			/* active poll end routine */
   void  (*cl_message) (struct parseunit *, parsetime_t *);	/* process a lower layer message */
 	void   *cl_data;		/* local data area for "poll" mechanism */
 	double    cl_rootdelay;		/* rootdelay */
 	double    cl_basedelay;		/* current offset by which the RS232
 				time code is delayed from the actual time */
 	const char *cl_id;		/* ID code */
 	const char *cl_description;		/* device name */
 	const char *cl_format;		/* fixed format */
 	u_char  cl_type;		/* clock type (ntp control) */
 	u_long  cl_maxunsync;		/* time to trust oscillator after losing synch */
 	u_long  cl_speed;		/* terminal input & output baudrate */
 	u_long  cl_cflag;             /* terminal control flags */
 	u_long  cl_iflag;             /* terminal input flags */
 	u_long  cl_oflag;             /* terminal output flags */
 	u_long  cl_lflag;             /* terminal local flags */
 	u_long  cl_samples;	      /* samples for median filter */
 	u_long  cl_keep;              /* samples for median filter to keep */
 } parse_clockinfo[] =
+{
 	{				/* mode 0 */
 		MBG_FLAGS,
 		NO_POLL,
 		NO_INIT,
 		NO_EVENT,
 		NO_END,
 		NO_MESSAGE,
 		NO_LCLDATA,
 		DCFPZF535_ROOTDELAY,
 		DCFPZF535_BASEDELAY,
 		DCF_P_ID,
 		DCFPZF535_DESCRIPTION,
 		DCFPZF535_FORMAT,
 		DCF_TYPE,
 		DCFPZF535_MAXUNSYNC,
 		DCFPZF535_SPEED,
 		DCFPZF535_CFLAG,
 		DCFPZF535_IFLAG,
 		DCFPZF535_OFLAG,
 		DCFPZF535_LFLAG,
 		DCFPZF535_SAMPLES,
 		DCFPZF535_KEEP
 	},
 	{				/* mode 1 */
 		MBG_FLAGS,
 		NO_POLL,
 		NO_INIT,
 		NO_EVENT,
 		NO_END,
 		NO_MESSAGE,
 		NO_LCLDATA,
 		DCFPZF535OCXO_ROOTDELAY,
 		DCFPZF535OCXO_BASEDELAY,
 		DCF_P_ID,
 		DCFPZF535OCXO_DESCRIPTION,
 		DCFPZF535OCXO_FORMAT,
 		DCF_TYPE,
 		DCFPZF535OCXO_MAXUNSYNC,
 		DCFPZF535OCXO_SPEED,
 		DCFPZF535OCXO_CFLAG,
 		DCFPZF535OCXO_IFLAG,
 		DCFPZF535OCXO_OFLAG,
 		DCFPZF535OCXO_LFLAG,
 		DCFPZF535OCXO_SAMPLES,
 		DCFPZF535OCXO_KEEP
 	},
 	{				/* mode 2 */
 		MBG_FLAGS,
 		NO_POLL,
 		NO_INIT,
 		NO_EVENT,
 		NO_END,
 		NO_MESSAGE,
 		NO_LCLDATA,
 		DCFUA31_ROOTDELAY,
 		DCFUA31_BASEDELAY,
 		DCF_A_ID,
 		DCFUA31_DESCRIPTION,
 		DCFUA31_FORMAT,
 		DCF_TYPE,
 		DCFUA31_MAXUNSYNC,
 		DCFUA31_SPEED,
 		DCFUA31_CFLAG,
 		DCFUA31_IFLAG,
 		DCFUA31_OFLAG,
 		DCFUA31_LFLAG,
 		DCFUA31_SAMPLES,
 		DCFUA31_KEEP
 @@ -3291,1999 +3291,1999 @@ parse_start(
+	{
 		msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: parse_setfmt() FAILED.", unit);
 		parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
 		return 0;			/* well, ok - special initialisation broke */
+	}
 	/*
 	 * get rid of all IO accumulated so far
 	 */
 #ifdef HAVE_TERMIOS
 	(void) tcflush(parse->generic->io.fd, TCIOFLUSH);
 #else
 #if defined(TCFLSH) && defined(TCIOFLUSH)
+	{
 		int flshcmd = TCIOFLUSH;
 		(void) ioctl(parse->generic->io.fd, TCFLSH, (caddr_t)&flshcmd);
+	}
 #endif
 #endif
 	/*
 	 * try to do any special initializations
 	 */
 	if (parse->parse_type->cl_init)
+		{
 			if (parse->parse_type->cl_init(parse))
+				{
 					parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
 					return 0;		/* well, ok - special initialisation broke */
+				}
+		}
 	/*
 	 * Insert in async io device list.
 	 */
 	if (!io_addclock(&parse->generic->io))
+        {
 		msyslog(LOG_ERR,
 			"PARSE receiver #%d: parse_start: addclock %s fails (ABORT - clock type requires async io)", CLK_UNIT(parse->peer), parsedev);
 		parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
 		return 0;
+	}
 	/*
 	 * print out configuration
 	 */
 	NLOG(NLOG_CLOCKINFO)
+		{
 			/* conditional if clause for conditional syslog */
 			msyslog(LOG_INFO, "PARSE receiver #%d: reference clock \"%s\" (I/O device %s, PPS device %s) added",
 				CLK_UNIT(parse->peer),
 				parse->parse_type->cl_description, parsedev,
 				(parse->ppsfd != parse->generic->io.fd) ? parseppsdev : parsedev);
 			msyslog(LOG_INFO, "PARSE receiver #%d: Stratum %d, trust time %s, precision %d",
 				CLK_UNIT(parse->peer),
 				parse->peer->stratum,
 				l_mktime(parse->maxunsync), parse->peer->precision);
 			msyslog(LOG_INFO, "PARSE receiver #%d: rootdelay %.6f s, phase adjustment %.6f s, PPS phase adjustment %.6f s, %s IO handling",
 				CLK_UNIT(parse->peer),
 				parse->parse_type->cl_rootdelay,
 				parse->generic->fudgetime1,
 				parse->ppsphaseadjust,
                                 parse->binding->bd_description);
 			msyslog(LOG_INFO, "PARSE receiver #%d: Format recognition: %s", CLK_UNIT(parse->peer),
 				parse->parse_type->cl_format);
                         msyslog(LOG_INFO, "PARSE receiver #%d: %sPPS support%s", CLK_UNIT(parse->peer),
 				CLK_PPS(parse->peer) ? "" : "NO ",
 				CLK_PPS(parse->peer) ?
 #ifdef PPS_METHOD
 				" (implementation " PPS_METHOD ")"
 #else
 				""
 #endif
 				: ""
 				);
+		}
 	return 1;
+}
 /*--------------------------------------------------
  * parse_ctl - process changes on flags/time values
  */
 static void
 parse_ctl(
 	    struct parseunit *parse,
 	    const struct refclockstat *in
+	    )
+{
         if (in)
+	{
 		if (in->haveflags & (CLK_HAVEFLAG1|CLK_HAVEFLAG2|CLK_HAVEFLAG3|CLK_HAVEFLAG4))
+		{
 		  u_char mask = CLK_FLAG1|CLK_FLAG2|CLK_FLAG3|CLK_FLAG4;
 		  parse->flags = (parse->flags & (u_char)(~mask)) | (in->flags & mask);
 #if defined(HAVE_PPSAPI)
 		  if (CLK_PPS(parse->peer))
+		    {
 		      parse_ppsapi(parse);
+		    }
 #endif
+		}
 		if (in->haveflags & CLK_HAVETIME1)
+                {
 		  parse->generic->fudgetime1 = in->fudgetime1;
 		  msyslog(LOG_INFO, "PARSE receiver #%d: new phase adjustment %.6f s",
 			  CLK_UNIT(parse->peer),
 			  parse->generic->fudgetime1);
+		}
 		if (in->haveflags & CLK_HAVETIME2)
+                {
 		  parse->generic->fudgetime2 = in->fudgetime2;
 		  if (parse->flags & PARSE_TRUSTTIME)
+		    {
 		      parse->maxunsync = (u_long)ABS(in->fudgetime2);
 		      msyslog(LOG_INFO, "PARSE receiver #%d: new trust time %s",
 			      CLK_UNIT(parse->peer),
 			      l_mktime(parse->maxunsync));
+		    }
 		  else
+		    {
 		      parse->ppsphaseadjust = in->fudgetime2;
 		      msyslog(LOG_INFO, "PARSE receiver #%d: new PPS phase adjustment %.6f s",
 			  CLK_UNIT(parse->peer),
 			      parse->ppsphaseadjust);
 #if defined(HAVE_PPSAPI)
 		      if (CLK_PPS(parse->peer))
+		      {
 			      parse_ppsapi(parse);
+		      }
 #endif
+		    }
+		}
 		parse->generic->fudgeminjitter = in->fudgeminjitter;
+	}
+}
 /*--------------------------------------------------
  * parse_poll - called by the transmit procedure
  */
 static void
 parse_poll(
 	int unit,
 	struct peer *peer
+	)
+{
 	struct parseunit *parse = peer->procptr->unitptr;
 	if (peer != parse->peer)
+	{
 		msyslog(LOG_ERR,
 			"PARSE receiver #%d: poll: INTERNAL: peer incorrect",
 			unit);
 		return;
+	}
 	/*
 	 * Update clock stat counters
 	 */
 	parse->generic->polls++;
 	if (parse->pollneeddata &&
 	    ((int)(current_time - parse->pollneeddata) > (1<<(max(min(parse->peer->hpoll, parse->peer->ppoll), parse->peer->minpoll)))))
+	{
 		/*
 		 * start worrying when exceeding a poll inteval
 		 * bad news - didn't get a response last time
 		 */
 		parse->lastmissed = current_time;
 		parse_event(parse, CEVNT_TIMEOUT);
 		ERR(ERR_NODATA)
 			msyslog(LOG_WARNING, "PARSE receiver #%d: no data from device within poll interval (check receiver / wiring)", CLK_UNIT(parse->peer));
+	}
 	/*
 	 * we just mark that we want the next sample for the clock filter
 	 */
 	parse->pollneeddata = current_time;
 	if (parse->parse_type->cl_poll)
+	{
 		parse->parse_type->cl_poll(parse);
+	}
 	cparse_statistics(parse);
 	return;
+}
 #define LEN_STATES 300		/* length of state string */
 /*--------------------------------------------------
  * parse_control - set fudge factors, return statistics
  */
 static void
 parse_control(
 	int unit,
 	const struct refclockstat *in,
 	struct refclockstat *out,
 	struct peer *peer
+	)
+{
 	struct parseunit *parse = peer->procptr->unitptr;
 	parsectl_t tmpctl;
 	static char outstatus[400];	/* status output buffer */
 	if (out)
+	{
 		out->lencode       = 0;
 		out->p_lastcode    = 0;
 		out->kv_list       = (struct ctl_var *)0;
+	}
 	if (!parse || !parse->peer)
+	{
 		msyslog(LOG_ERR, "PARSE receiver #%d: parse_control: unit invalid (UNIT INACTIVE)",
 			unit);
 		return;
+	}
 	unit = CLK_UNIT(parse->peer);
 	/*
 	 * handle changes
 	 */
 	parse_ctl(parse, in);
 	/*
 	 * supply data
 	 */
 	if (out)
+	{
 		u_long sum = 0;
 		char *tt, *start;
 		int i;
 		outstatus[0] = '\0';
 		out->type       = REFCLK_PARSE;
 		/*
 		 * keep fudgetime2 in sync with TRUSTTIME/MAXUNSYNC flag1
 		 */
 		parse->generic->fudgetime2 = (parse->flags & PARSE_TRUSTTIME) ? (double)parse->maxunsync : parse->ppsphaseadjust;
 		/*
 		 * figure out skew between PPS and RS232 - just for informational
 		 * purposes
 		 */
 		if (PARSE_SYNC(parse->timedata.parse_state))
+		{
 			if (PARSE_PPS(parse->timedata.parse_state) && PARSE_TIMECODE(parse->timedata.parse_state))
+			{
 				l_fp off;
 				/*
 				 * we have a PPS and RS232 signal - calculate the skew
 				 * WARNING: assumes on TIMECODE == PULSE (timecode after pulse)
 				 */
 				off = parse->timedata.parse_stime.fp;
 				L_SUB(&off, &parse->timedata.parse_ptime.fp); /* true offset */
 				tt = add_var(&out->kv_list, 80, RO);
 				snprintf(tt, 80, "refclock_ppsskew=%s", lfptoms(&off, 6));
+			}
+		}
 		if (PARSE_PPS(parse->timedata.parse_state))
+		{
 			tt = add_var(&out->kv_list, 80, RO|DEF);
 			snprintf(tt, 80, "refclock_ppstime=\"%s\"", gmprettydate(&parse->timedata.parse_ptime.fp));
+		}
 		start = tt = add_var(&out->kv_list, 128, RO|DEF);
 		tt = ap(start, 128, tt, "refclock_time=\"");
 		if (parse->timedata.parse_time.fp.l_ui == 0)
+		{
 			tt = ap(start, 128, tt, "<UNDEFINED>\"");
+		}
 		else
+		{
 			tt = ap(start, 128, tt, "%s\"",
 			    gmprettydate(&parse->timedata.parse_time.fp));
+		}
 		if (!PARSE_GETTIMECODE(parse, &tmpctl))
+		{
 			ERR(ERR_INTERNAL)
 				msyslog(LOG_ERR, "PARSE receiver #%d: parse_control: parse_timecode() FAILED", unit);
+		}
 		else
+		{
 			start = tt = add_var(&out->kv_list, 512, RO|DEF);
 			tt = ap(start, 512, tt, "refclock_status=\"");
 			/*
 			 * copy PPS flags from last read transaction (informational only)
 			 */
 			tmpctl.parsegettc.parse_state |= parse->timedata.parse_state &
 				(PARSEB_PPS|PARSEB_S_PPS);
 			(void)parsestate(tmpctl.parsegettc.parse_state, tt, BUFFER_SIZES(start, tt, 512));
 			tt += strlen(tt);
 			tt = ap(start, 512, tt, "\"");
 			if (tmpctl.parsegettc.parse_count)
 			    mkascii(outstatus+strlen(outstatus), (int)(sizeof(outstatus)- strlen(outstatus) - 1),
 				    tmpctl.parsegettc.parse_buffer, (unsigned)(tmpctl.parsegettc.parse_count));
+		}
 		tmpctl.parseformat.parse_format = tmpctl.parsegettc.parse_format;
 		if (!PARSE_GETFMT(parse, &tmpctl))
+		{
 			ERR(ERR_INTERNAL)
 				msyslog(LOG_ERR, "PARSE receiver #%d: parse_control: parse_getfmt() FAILED", unit);
+		}
 		else
+		{
 			int count = tmpctl.parseformat.parse_count;
 			if (count)
 				--count;
 			start = tt = add_var(&out->kv_list, 80, RO|DEF);
 			tt = ap(start, 80, tt, "refclock_format=\"");
 			if (count > 0) {
 				tt = ap(start, 80, tt, "%*.*s",
 			        	count,
 			        	count,
 			        	tmpctl.parseformat.parse_buffer);
+			}
 			tt = ap(start, 80, tt, "\"");
+		}
 		/*
 		 * gather state statistics
 		 */
 		start = tt = add_var(&out->kv_list, LEN_STATES, RO|DEF);
 		tt = ap(start, LEN_STATES, tt, "refclock_states=\"");
 		for (i = 0; i <= CEVNT_MAX; i++)
+		{
 			u_long s_time;
 			u_long d = current_time - parse->generic->timestarted;
 			u_long percent;
 			percent = s_time = PARSE_STATETIME(parse, i);
 			while (((u_long)(~0) / 10000) < percent)
+			{
 				percent /= 10;
 				d       /= 10;
+			}
 			if (d)
 			    percent = (percent * 10000) / d;
 			else
 			    percent = 10000;
 			if (s_time)
+			{
 				char item[80];
 				int count;
 				snprintf(item, 80, "%s%s%s: %s (%d.%02d%%)",
 					sum ? "; " : "",
 					(parse->generic->currentstatus == i) ? "*" : "",
 					clockstatus((unsigned int)i),
 					l_mktime(s_time),
 					(int)(percent / 100), (int)(percent % 100));
 				if ((count = (int) strlen(item)) < (LEN_STATES - 40 - (tt - start)))
+					{
 						tt = ap(start, LEN_STATES, tt,
 						    "%s", item);
+					}
 				sum += s_time;
+			}
+		}
 		ap(start, LEN_STATES, tt, "; running time: %s\"", l_mktime(sum));
 		tt = add_var(&out->kv_list, 32, RO);
 		snprintf(tt, 32,  "refclock_id=\"%s\"", parse->parse_type->cl_id);
 		tt = add_var(&out->kv_list, 80, RO);
 		snprintf(tt, 80,  "refclock_iomode=\"%s\"", parse->binding->bd_description);
 		tt = add_var(&out->kv_list, 128, RO);
 		snprintf(tt, 128, "refclock_driver_version=\"%s\"", rcsid);
+		{
 			struct ctl_var *k;
 			k = parse->kv;
 			while (k && !(k->flags & EOV))
+			{
 				set_var(&out->kv_list, k->text, strlen(k->text)+1, k->flags);
 				k++;
+			}
+		}
 		out->lencode       = (u_short) strlen(outstatus);
 		out->p_lastcode    = outstatus;
+	}
+}
 /**===========================================================================
  ** processing routines
  **/
 /*--------------------------------------------------
  * event handling - note that nominal events will also be posted
  * keep track of state dwelling times
  */
 static void
 parse_event(
 	struct parseunit *parse,
 	int event
+	)
+{
 	if (parse->generic->currentstatus != (u_char) event)
+	{
 		parse->statetime[parse->generic->currentstatus] += current_time - parse->lastchange;
 		parse->lastchange              = current_time;
 		if (parse->parse_type->cl_event)
 		    parse->parse_type->cl_event(parse, event);
 		if (event == CEVNT_NOMINAL)
+		{
 			NLOG(NLOG_CLOCKSTATUS)
 				msyslog(LOG_INFO, "PARSE receiver #%d: SYNCHRONIZED",
 					CLK_UNIT(parse->peer));
+		}
 		refclock_report(parse->peer, event);
+	}
+}
 /*--------------------------------------------------
  * process a PARSE time sample
  */
 static void
 parse_process(
 	struct parseunit *parse,
 	parsetime_t      *parsetime
+	)
+{
 	l_fp off, rectime, reftime;
 	double fudge;
 	/* silence warning: 'off.Ul_i.Xl_i' may be used uninitialized in this function */
 	ZERO(off);
 	/*
 	 * check for changes in conversion status
 	 * (only one for each new status !)
 	 */
 	if (((parsetime->parse_status & CVT_MASK) != CVT_OK) &&
 	    ((parsetime->parse_status & CVT_MASK) != CVT_NONE) &&
 	    (parse->timedata.parse_status != parsetime->parse_status))
+	{
 		char buffer[400];
 		NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
 			msyslog(LOG_WARNING, "PARSE receiver #%d: conversion status \"%s\"",
 				CLK_UNIT(parse->peer), parsestatus(parsetime->parse_status, buffer, sizeof(buffer)));
 		if ((parsetime->parse_status & CVT_MASK) == CVT_FAIL)
+		{
 			/*
 			 * tell more about the story - list time code
 			 * there is a slight change for a race condition and
 			 * the time code might be overwritten by the next packet
 			 */
 			parsectl_t tmpctl;
 			if (!PARSE_GETTIMECODE(parse, &tmpctl))
+			{
 				ERR(ERR_INTERNAL)
 					msyslog(LOG_ERR, "PARSE receiver #%d: parse_process: parse_timecode() FAILED", CLK_UNIT(parse->peer));
+			}
 			else
+			{
 				unsigned int count = tmpctl.parsegettc.parse_count;
 				if (count)
 					--count;
 				ERR(ERR_BADDATA)
 				    msyslog(LOG_WARNING, "PARSE receiver #%d: FAILED TIMECODE: \"%s\" (check receiver configuration / wiring)",
 					    CLK_UNIT(parse->peer),
 					    mkascii(buffer, sizeof(buffer),
 						    tmpctl.parsegettc.parse_buffer, count));
+			}
 			/* copy status to show only changes in case of failures */
 			parse->timedata.parse_status = parsetime->parse_status;
+		}
+	}
 	/*
 	 * examine status and post appropriate events
 	 */
 	if ((parsetime->parse_status & CVT_MASK) != CVT_OK)
+	{
 		/*
 		 * got bad data - tell the rest of the system
 		 */
 		switch (parsetime->parse_status & CVT_MASK)
+		{
 		case CVT_NONE:
 			if ((parsetime->parse_status & CVT_ADDITIONAL) &&
 			    parse->parse_type->cl_message)
 				parse->parse_type->cl_message(parse, parsetime);
 			/*
 			 * save PPS information that comes piggyback
 			 */
 			if (PARSE_PPS(parsetime->parse_state))
+			  {
 			    parse->timedata.parse_state |= PARSEB_PPS|PARSEB_S_PPS;
 			    parse->timedata.parse_ptime  = parsetime->parse_ptime;
+			  }
 			break; 		/* well, still waiting - timeout is handled at higher levels */
 		case CVT_FAIL:
 			if (parsetime->parse_status & CVT_BADFMT)
+			{
 				parse_event(parse, CEVNT_BADREPLY);
+			}
 			else
 				if (parsetime->parse_status & CVT_BADDATE)
+				{
 					parse_event(parse, CEVNT_BADDATE);
+				}
 				else
 					if (parsetime->parse_status & CVT_BADTIME)
+					{
 						parse_event(parse, CEVNT_BADTIME);
+					}
 					else
+					{
 						parse_event(parse, CEVNT_BADREPLY); /* for the lack of something better */
+					}
+		}
 		return;			/* skip the rest - useless */
+	}
 	/*
 	 * check for format changes
 	 * (in case somebody has swapped clocks 8-)
 	 */
 	if (parse->lastformat != parsetime->parse_format)
+	{
 		parsectl_t tmpctl;
 		tmpctl.parseformat.parse_format = parsetime->parse_format;
 		if (!PARSE_GETFMT(parse, &tmpctl))
+		{
 			ERR(ERR_INTERNAL)
 				msyslog(LOG_ERR, "PARSE receiver #%d: parse_getfmt() FAILED", CLK_UNIT(parse->peer));
+		}
 		else
+		{
 			NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
 				msyslog(LOG_INFO, "PARSE receiver #%d: packet format \"%s\"",
 					CLK_UNIT(parse->peer), tmpctl.parseformat.parse_buffer);
+		}
 		parse->lastformat = parsetime->parse_format;
+	}
 	/*
 	 * now, any changes ?
 	 */
 	if ((parse->timedata.parse_state ^ parsetime->parse_state) &
 	    ~(unsigned)(PARSEB_PPS|PARSEB_S_PPS))
+	{
 		char tmp1[200];
 		char tmp2[200];
 		/*
 		 * something happend - except for PPS events
 		 */
 		(void) parsestate(parsetime->parse_state, tmp1, sizeof(tmp1));
 		(void) parsestate(parse->timedata.parse_state, tmp2, sizeof(tmp2));
 		NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
 			msyslog(LOG_INFO,"PARSE receiver #%d: STATE CHANGE: %s -> %s",
 				CLK_UNIT(parse->peer), tmp2, tmp1);
+	}
 	/*
 	 * carry on PPS information if still usable
 	 */
 	if (PARSE_PPS(parse->timedata.parse_state) && !PARSE_PPS(parsetime->parse_state))
+        {
 	        parsetime->parse_state |= PARSEB_PPS|PARSEB_S_PPS;
 		parsetime->parse_ptime  = parse->timedata.parse_ptime;
+	}
 	/*
 	 * remember for future
 	 */
 	parse->timedata = *parsetime;
 	/*
 	 * check to see, whether the clock did a complete powerup or lost PZF signal
 	 * and post correct events for current condition
 	 */
 	if (PARSE_POWERUP(parsetime->parse_state))
+	{
 		/*
 		 * this is bad, as we have completely lost synchronisation
 		 * well this is a problem with the receiver here
 		 * for PARSE Meinberg DCF77 receivers the lost synchronisation
 		 * is true as it is the powerup state and the time is taken
 		 * from a crude real time clock chip
 		 * for the PZF/GPS series this is only partly true, as
 		 * PARSE_POWERUP only means that the pseudo random
 		 * phase shift sequence cannot be found. this is only
 		 * bad, if we have never seen the clock in the SYNC
 		 * state, where the PHASE and EPOCH are correct.
 		 * for reporting events the above business does not
 		 * really matter, but we can use the time code
 		 * even in the POWERUP state after having seen
 		 * the clock in the synchronized state (PZF class
 		 * receivers) unless we have had a telegram disruption
 		 * after having seen the clock in the SYNC state. we
 		 * thus require having seen the clock in SYNC state
 		 * *after* having missed telegrams (noresponse) from
 		 * the clock. one problem remains: we might use erroneously
 		 * POWERUP data if the disruption is shorter than 1 polling
 		 * interval. fortunately powerdowns last usually longer than 64
 		 * seconds and the receiver is at least 2 minutes in the
 		 * POWERUP or NOSYNC state before switching to SYNC
 		 * for GPS receivers this can mean antenna problems and other causes.
 		 * the additional grace period can be enables by a clock
 		 * mode having the PARSE_F_POWERUPTRUST flag in cl_flag set.
 		 */
 		parse_event(parse, CEVNT_FAULT);
 		NLOG(NLOG_CLOCKSTATUS)
 			ERR(ERR_BADSTATUS)
 			msyslog(LOG_ERR,"PARSE receiver #%d: NOT SYNCHRONIZED/RECEIVER PROBLEMS",
 				CLK_UNIT(parse->peer));
+	}
 	else
+	{
 		/*
 		 * we have two states left
+		 *
 		 * SYNC:
 		 *  this state means that the EPOCH (timecode) and PHASE
 		 *  information has be read correctly (at least two
 		 *  successive PARSE timecodes were received correctly)
 		 *  this is the best possible state - full trust
+		 *
 		 * NOSYNC:
 		 *  The clock should be on phase with respect to the second
 		 *  signal, but the timecode has not been received correctly within
 		 *  at least the last two minutes. this is a sort of half baked state
 		 *  for PARSE Meinberg DCF77 clocks this is bad news (clock running
 		 *  without timecode confirmation)
 		 *  PZF 535 has also no time confirmation, but the phase should be
 		 *  very precise as the PZF signal can be decoded
 		 */
 		if (PARSE_SYNC(parsetime->parse_state))
+		{
 			/*
 			 * currently completely synchronized - best possible state
 			 */
 			parse->lastsync = current_time;
 			clear_err(parse, ERR_BADSTATUS);
+		}
 		else
+		{
 			/*
 			 * we have had some problems receiving the time code
 			 */
 			parse_event(parse, CEVNT_PROP);
 			NLOG(NLOG_CLOCKSTATUS)
 				ERR(ERR_BADSTATUS)
 				msyslog(LOG_ERR,"PARSE receiver #%d: TIMECODE NOT CONFIRMED",
 					CLK_UNIT(parse->peer));
+		}
+	}
 	fudge = parse->generic->fudgetime1; /* standard RS232 Fudgefactor */
 	if (PARSE_TIMECODE(parsetime->parse_state))
+	{
 		rectime = parsetime->parse_stime.fp;
 		off = reftime = parsetime->parse_time.fp;
 		L_SUB(&off, &rectime); /* prepare for PPS adjustments logic */
 #ifdef DEBUG
 		if (debug > 3)
 			printf("PARSE receiver #%d: Reftime %s, Recvtime %s - initial offset %s\n",
 			       CLK_UNIT(parse->peer),
 			       prettydate(&reftime),
 			       prettydate(&rectime),
 			       lfptoa(&off,6));
 #endif
+	}
 	if (PARSE_PPS(parsetime->parse_state) && CLK_PPS(parse->peer))
+	{
 		l_fp offset;
 		double ppsphaseadjust = parse->ppsphaseadjust;
 #ifdef HAVE_PPSAPI
 		/*
 		 * set fudge = 0.0 if already included in PPS time stamps
 		 */
 		if (parse->atom.pps_params.mode & (PPS_OFFSETCLEAR|PPS_OFFSETASSERT))
+		        {
 			        ppsphaseadjust = 0.0;
+			}
 #endif
 		/*
 		 * we have a PPS signal - much better than the RS232 stuff (we hope)
 		 */
 		offset = parsetime->parse_ptime.fp;
 #ifdef DEBUG
 		if (debug > 3)
 			printf("PARSE receiver #%d: PPStime %s\n",
 				CLK_UNIT(parse->peer),
 				prettydate(&offset));
 #endif
 		if (PARSE_TIMECODE(parsetime->parse_state))
+		{
 			if (M_ISGEQ(off.l_i, off.l_uf, -1, 0x80000000) &&
 			    M_ISGEQ(0, 0x7fffffff, off.l_i, off.l_uf))
+			{
 				fudge = ppsphaseadjust; /* pick PPS fudge factor */
 				/*
 				 * RS232 offsets within [-0.5..0.5[ - take PPS offsets
 				 */
 				if (parse->parse_type->cl_flags & PARSE_F_PPSONSECOND)
+				{
 					reftime = off = offset;
 					if (reftime.l_uf & 0x80000000)
 						reftime.l_ui++;
 					reftime.l_uf = 0;
 					/*
 					 * implied on second offset
 					 */
 					off.l_uf = ~off.l_uf; /* map [0.5..1[ -> [-0.5..0[ */
 					off.l_i = (off.l_uf & 0x80000000) ? -1 : 0; /* sign extend */
+				}
 				else
+				{
 					/*
 					 * time code describes pulse
 					 */
 					reftime = off = parsetime->parse_time.fp;
 					L_SUB(&off, &offset); /* true offset */
+				}
+			}
 			/*
 			 * take RS232 offset when PPS when out of bounds
 			 */
+		}
 		else
+		{
 			fudge = ppsphaseadjust; /* pick PPS fudge factor */
 			/*
 			 * Well, no time code to guide us - assume on second pulse
 			 * and pray, that we are within [-0.5..0.5[
 			 */
 			off = offset;
 			reftime = offset;
 			if (reftime.l_uf & 0x80000000)
 				reftime.l_ui++;
 			reftime.l_uf = 0;
 			/*
 			 * implied on second offset
 			 */
 			off.l_uf = ~off.l_uf; /* map [0.5..1[ -> [-0.5..0[ */
 			off.l_i = (off.l_uf & 0x80000000) ? -1 : 0; /* sign extend */
+		}
+	}
 	else
+	{
 		if (!PARSE_TIMECODE(parsetime->parse_state))
+		{
 			/*
 			 * Well, no PPS, no TIMECODE, no more work ...
 			 */
 			if ((parsetime->parse_status & CVT_ADDITIONAL) &&
 			    parse->parse_type->cl_message)
 				parse->parse_type->cl_message(parse, parsetime);
 			return;
+		}
+	}
 #ifdef DEBUG
 	if (debug > 3)
 		printf("PARSE receiver #%d: Reftime %s, Recvtime %s - final offset %s\n",
 			CLK_UNIT(parse->peer),
 			prettydate(&reftime),
 			prettydate(&rectime),
 			lfptoa(&off,6));
 #endif
 	rectime = reftime;
 	L_SUB(&rectime, &off);	/* just to keep the ntp interface happy */
 #ifdef DEBUG
 	if (debug > 3)
 		printf("PARSE receiver #%d: calculated Reftime %s, Recvtime %s\n",
 			CLK_UNIT(parse->peer),
 			prettydate(&reftime),
 			prettydate(&rectime));
 #endif
 	if ((parsetime->parse_status & CVT_ADDITIONAL) &&
 	    parse->parse_type->cl_message)
 		parse->parse_type->cl_message(parse, parsetime);
 	if (PARSE_SYNC(parsetime->parse_state))
+	{
 		/*
 		 * log OK status
 		 */
 		parse_event(parse, CEVNT_NOMINAL);
+	}
 	clear_err(parse, ERR_BADIO);
 	clear_err(parse, ERR_BADDATA);
 	clear_err(parse, ERR_NODATA);
 	clear_err(parse, ERR_INTERNAL);
 	/*
 	 * and now stick it into the clock machine
 	 * samples are only valid iff lastsync is not too old and
 	 * we have seen the clock in sync at least once
 	 * after the last time we didn't see an expected data telegram
 	 * at startup being not in sync is also bad just like
 	 * POWERUP state unless PARSE_F_POWERUPTRUST is set
 	 * see the clock states section above for more reasoning
 	 */
 	if (((current_time - parse->lastsync) > parse->maxunsync)           ||
 	    (parse->lastsync < parse->lastmissed)                           ||
 	    ((parse->lastsync == 0) && !PARSE_SYNC(parsetime->parse_state)) ||
 	    (((parse->parse_type->cl_flags & PARSE_F_POWERUPTRUST) == 0) &&
 	     PARSE_POWERUP(parsetime->parse_state)))
+	{
 		parse->generic->leap = LEAP_NOTINSYNC;
 		parse->lastsync = 0;	/* wait for full sync again */
+	}
 	else
+	{
 		if (PARSE_LEAPADD(parsetime->parse_state))
+		{
 			/*
 			 * we pick this state also for time code that pass leap warnings
 			 * without direction information (as earth is currently slowing
 			 * down).
 			 */
 			parse->generic->leap = (parse->flags & PARSE_LEAP_DELETE) ? LEAP_DELSECOND : LEAP_ADDSECOND;
+		}
 		else
 		    if (PARSE_LEAPDEL(parsetime->parse_state))
+		    {
 			    parse->generic->leap = LEAP_DELSECOND;
+		    }
 		    else
+		    {
 			    parse->generic->leap = LEAP_NOWARNING;
+		    }
+	}
 	if (parse->generic->leap != LEAP_NOTINSYNC)
+	{
 	        /*
 		 * only good/trusted samples are interesting
 		 */
 #ifdef DEBUG
 	        if (debug > 2)
+			{
 				       printf("PARSE receiver #%d: refclock_process_offset(reftime=%s, rectime=%s, Fudge=%f)\n",
 				       CLK_UNIT(parse->peer),
 				       prettydate(&reftime),
 				       prettydate(&rectime),
 				       fudge);
+			}
 #endif
 		parse->generic->lastref = reftime;
 		refclock_process_offset(parse->generic, reftime, rectime, fudge);
 #ifdef HAVE_PPSAPI
 		/*
 		 * pass PPS information on to PPS clock
 		 */
 		if (PARSE_PPS(parsetime->parse_state) && CLK_PPS(parse->peer))
+			{
 				parse->peer->flags |= (FLAG_PPS | FLAG_TSTAMP_PPS);
 				parse_hardpps(parse, PARSE_HARDPPS_ENABLE);
+			}
 #endif
 	} else {
 		parse_hardpps(parse, PARSE_HARDPPS_DISABLE);
 		parse->peer->flags &= ~(FLAG_PPS | FLAG_TSTAMP_PPS);
+	}
 	/*
 	 * ready, unless the machine wants a sample or
 	 * we are in fast startup mode (peer->dist > MAXDISTANCE)
 	 */
 	if (!parse->pollneeddata && parse->peer->disp <= MAXDISTANCE)
 	    return;
 	parse->pollneeddata = 0;
 	parse->timedata.parse_state &= ~(unsigned)(PARSEB_PPS|PARSEB_S_PPS);
 	refclock_receive(parse->peer);
+}
 /**===========================================================================
  ** special code for special clocks
  **/
 static void
 mk_utcinfo(
 	   char *t,  /* pointer to the output string buffer */
 	   uint16_t wnt,
 	   uint16_t wnlsf,
 	   int dn,
 	   int dtls,
 	   int dtlsf,
 	   int size  /* size of the output string buffer */
+	   )
+{
 	/*
 	 * The week number transmitted by the GPS satellites for the leap date
 	 * is truncated to 8 bits only. If the nearest leap second date is off
 	 * the current date by more than +/- 128 weeks then conversion to a
 	 * calendar date is ambiguous. On the other hand, if a leap second is
 	 * currently being announced (i.e. dtlsf != dtls) then the week number
 	 * wnlsf is close enough, and we can unambiguously determine the date
 	 * for which the leap second is scheduled.
 	 */
 	if ( dtlsf != dtls )
+	{
 		time_t t_ls;
 		struct tm *tm;
 		int nc;
 		wnlsf = basedate_expand_gpsweek(wnlsf);
 		/* 'wnt' not used here: would need the same treatment as 'wnlsf */
 		t_ls = (time_t) wnlsf * SECSPERWEEK
 			+ (time_t) dn * SECSPERDAY
 			+ GPS_SEC_BIAS - 1;
 		tm = gmtime( &t_ls );
 		if (tm == NULL)  /* gmtime() failed */
+		{
 			snprintf( t, size, "** (gmtime() failed in mk_utcinfo())" );
 			return;
+		}
 		nc = snprintf( t, size, "UTC offset transition from %is to %is due to leap second %s",
 				dtls, dtlsf, ( dtls < dtlsf ) ? "insertion" : "deletion" );
 		if (nc < 0)
 			nc = strlen(t);
 		else if (nc > size)
 			nc = size;
 		snprintf( t + nc, size - nc, " at UTC midnight at the end of %s, %04i-%02i-%02i",
 				daynames[tm->tm_wday], tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday );
+	}
 	else
+	{
-		snprintf( t, size, "UTC offset parameter: %is, no leap second announced.\n", dtls );
+		snprintf( t, size, "UTC offset parameter: %is, no leap second announced.", dtls );
+	}
+}
 #ifdef CLOCK_MEINBERG
 /**===========================================================================
  ** Meinberg GPS receiver support
  **/
 /*------------------------------------------------------------
  * gps16x_message - process messages from Meinberg GPS receiver
  */
 static void
 gps16x_message(
 	       struct parseunit *parse,
 	       parsetime_t      *parsetime
+	       )
+{
 	if (parse->timedata.parse_msglen && parsetime->parse_msg[0] == SOH)
+	{
 		GPS_MSG_HDR header;
 		unsigned char *bufp = (unsigned char *)parsetime->parse_msg + 1;
 #ifdef DEBUG
 		if (debug > 2)
+		{
 			char msgbuffer[600];
 			mkreadable(msgbuffer, sizeof(msgbuffer), (char *)parsetime->parse_msg, parsetime->parse_msglen, 1);
 			printf("PARSE receiver #%d: received message (%d bytes) >%s<\n",
 				CLK_UNIT(parse->peer),
 				parsetime->parse_msglen,
 				msgbuffer);
+		}
 #endif
 		get_mbg_header(&bufp, &header);
 		if (header.hdr_csum == mbg_csum(parsetime->parse_msg + 1, 6) &&
 		    (header.len == 0 ||
 		     (header.len < sizeof(parsetime->parse_msg) &&
 		      header.data_csum == mbg_csum(bufp, header.len))))
+		{
 			/*
 			 * clean message
 			 */
 			switch (header.cmd)
+			{
 			case GPS_SW_REV:
+				{
 					char buffer[64];
 					SW_REV gps_sw_rev;
 					get_mbg_sw_rev(&bufp, &gps_sw_rev);
 					snprintf(buffer, sizeof(buffer), "meinberg_gps_version=\"%x.%02x%s%s\"",
 						(gps_sw_rev.code >> 8) & 0xFF,
 						gps_sw_rev.code & 0xFF,
 						gps_sw_rev.name[0] ? " " : "",
 						gps_sw_rev.name);
 					set_var(&parse->kv, buffer, strlen(buffer)+1, RO|DEF);
+				}
 			break;
 			case GPS_BVAR_STAT:
+				{
 					static struct state
+					{
 						BVAR_STAT flag; /* status flag */
 						const char *string; /* bit name */
 					} states[] =
+					  {
 						  { BVAR_CFGH_INVALID,     "Configuration/Health" },
 						  { BVAR_ALM_NOT_COMPLETE, "Almanachs" },
 						  { BVAR_UTC_INVALID,      "UTC Correction" },
 						  { BVAR_IONO_INVALID,     "Ionospheric Correction" },
 						  { BVAR_RCVR_POS_INVALID, "Receiver Position" },
 						  { 0, "" }
 					  };
 					BVAR_STAT status;
 					struct state *s = states;
 					char buffer[512];
 					char *p, *b;
 					status = (BVAR_STAT) get_lsb_short(&bufp);
 					p = b = buffer;
 					p = ap(buffer, sizeof(buffer), p,
 					    "meinberg_gps_status=\"[0x%04x] ",
 					    status);
 					if (status)
+					{
 						p = ap(buffer, sizeof(buffer), p, "incomplete buffered data: ");
 						b = p;
 						while (s->flag)
+						{
 							if (status & s->flag)
+							{
 								if (p != b)
+								{
 									p = ap(buffer, sizeof(buffer), p, ", ");
+								}
 								p = ap(buffer, sizeof(buffer), p, "%s", (const char *)s->string);
+							}
 							s++;
+						}
 						p = ap(buffer, sizeof(buffer), p, "\"");
+					}
 					else
+					{
 						p = ap(buffer, sizeof(buffer), p, "<all buffered data complete>\"");
+					}
 					set_var(&parse->kv, buffer, strlen(buffer)+1, RO|DEF);
+				}
 			break;
 			case GPS_POS_XYZ:
+				{
 					XYZ xyz;
 					char buffer[256];
 					get_mbg_xyz(&bufp, xyz);
 					snprintf(buffer, sizeof(buffer), "gps_position(XYZ)=\"%s m, %s m, %s m\"",
 						mfptoa(xyz[XP].l_ui, xyz[XP].l_uf, 1),
 						mfptoa(xyz[YP].l_ui, xyz[YP].l_uf, 1),
 						mfptoa(xyz[ZP].l_ui, xyz[ZP].l_uf, 1));
 					set_var(&parse->kv, buffer, sizeof(buffer), RO|DEF);
+				}
 			break;
 			case GPS_POS_LLA:
+				{
 					LLA lla;
 					char buffer[256];
 					get_mbg_lla(&bufp, lla);
 					snprintf(buffer, sizeof(buffer), "gps_position(LLA)=\"%s deg, %s deg, %s m\"",
 						mfptoa(lla[LAT].l_ui, lla[LAT].l_uf, 4),
 						mfptoa(lla[LON].l_ui, lla[LON].l_uf, 4),
 						mfptoa(lla[ALT].l_ui, lla[ALT].l_uf, 1));
 					set_var(&parse->kv, buffer, sizeof(buffer), RO|DEF);
+				}
 			break;
 			case GPS_TZDL:
 				break;
 			case GPS_PORT_PARM:
 				break;
 			case GPS_SYNTH:
 				break;
 			case GPS_ANT_INFO:
+				{
 					ANT_INFO antinfo;
 					char buffer[512];
 					char *p, *q;
 					get_mbg_antinfo(&bufp, &antinfo);
 					p = buffer;
 					p = ap(buffer, sizeof(buffer), p, "meinberg_antenna_status=\"");
 					switch (antinfo.status)
+					{
 					case ANT_INVALID: // No other fields valid since antenna has not yet been disconnected
 						p = ap(buffer, sizeof(buffer),
 						    p, "<OK>");
 						break;
 					case ANT_DISCONN: // Antenna is disconnected, tm_reconn and delta_t not yet set
 						q = ap(buffer, sizeof(buffer),
 						    p, "DISCONNECTED since ");
 						NLOG(NLOG_CLOCKSTATUS)
 							ERR(ERR_BADSTATUS)
 							msyslog(LOG_ERR,"PARSE receiver #%d: ANTENNA FAILURE: %s",
 								CLK_UNIT(parse->peer), p);
 						p = q;
 						mbg_tm_str(&p, &antinfo.tm_disconn, BUFFER_SIZE(buffer, p), 0);
 						*p = '\0';
 						break;
 					case ANT_RECONN: // Antenna had been disconnect, but receiver sync. after reconnect, so all fields valid
 						p = ap(buffer, sizeof(buffer),
 						    p, "SYNC AFTER RECONNECT on ");
 						mbg_tm_str(&p, &antinfo.tm_reconn, BUFFER_SIZE(buffer, p), 0);
 						p = ap(buffer, sizeof(buffer),
 							p, ", clock offset at reconnect %c%ld.%07ld s, disconnect time ",
 							(antinfo.delta_t < 0) ? '-' : '+',
 							(long) ABS(antinfo.delta_t) / 10000,
 							(long) ABS(antinfo.delta_t) % 10000);
 						mbg_tm_str(&p, &antinfo.tm_disconn, BUFFER_SIZE(buffer, p), 0);
 						*p = '\0';
 						break;
 					default:
 						p = ap(buffer, sizeof(buffer),
 						    p, "bad status 0x%04x",
 						    antinfo.status);
 						break;
+					}
 					p = ap(buffer, sizeof(buffer), p, "\"");
 					set_var(&parse->kv, buffer, sizeof(buffer), RO|DEF);
+				}
 			break;
 			case GPS_UCAP:
 				break;
 			case GPS_CFGH:
+				{
 					CFGH cfgh;
 					char buffer[512];
 					char *p;
 					get_mbg_cfgh(&bufp, &cfgh);
 					if (cfgh.valid)
+					{
 						const char *cp;
 						uint16_t tmp_val;
 						int i;
 						p = buffer;
 						p = ap(buffer, sizeof(buffer),
 						    p, "gps_tot_51=\"");
 						mbg_tgps_str(&p, &cfgh.tot_51, BUFFER_SIZE(buffer, p));
 						p = ap(buffer, sizeof(buffer),
 						    p, "\"");
 						set_var(&parse->kv, buffer, sizeof(buffer), RO|COND_DEF);
 						p = buffer;
 						p = ap(buffer, sizeof(buffer),
 						    p, "gps_tot_63=\"");
 						mbg_tgps_str(&p, &cfgh.tot_63, BUFFER_SIZE(buffer, p));
 						p = ap(buffer, sizeof(buffer),
 						    p, "\"");
 						set_var(&parse->kv, buffer, sizeof(buffer), RO|COND_DEF);
 						p = buffer;
 						p = ap(buffer, sizeof(buffer),
 						    p, "gps_t0a=\"");
 						mbg_tgps_str(&p, &cfgh.t0a, BUFFER_SIZE(buffer, p));
 						p = ap(buffer, sizeof(buffer),
 						    p, "\"");
 						set_var(&parse->kv, buffer, sizeof(buffer), RO|COND_DEF);
 						for (i = 0; i < N_SVNO_GPS; i++)
+						{
 							p = buffer;
 							p = ap(buffer, sizeof(buffer), p, "sv_info[%d]=\"PRN%d", i, i + N_SVNO_GPS);
 							tmp_val = cfgh.health[i];  /* a 6 bit SV health code */
 							p = ap(buffer, sizeof(buffer), p, "; health=0x%02x (", tmp_val);
 							/* "All Ones" has a special meaning" */
 							if (tmp_val == 0x3F) /* satellite is unusable or doesn't even exist */
 								cp = "SV UNAVAILABLE";
 							else {
 								/* The MSB contains a summary of the 3 MSBs of the 8 bit health code,
 								 * indicating if the data sent by the satellite is OK or not. */
 								p = ap(buffer, sizeof(buffer), p, "DATA %s, ", (tmp_val & 0x20) ? "BAD" : "OK" );
 								/* The 5 LSBs contain the status of the different signals sent by the satellite. */
 								switch (tmp_val & 0x1F)
+								{
 									case 0x00: cp = "SIGNAL OK";              break;
 									/* codes 0x01 through 0x1B indicate that one or more
 									 * specific signal components are weak or dead.
 									 * We don't decode this here in detail. */
 									case 0x1C: cp = "SV IS TEMP OUT";         break;
 									case 0x1D: cp = "SV WILL BE TEMP OUT";    break;
 									default:   cp = "TRANSMISSION PROBLEMS";  break;
+								}
+							}
 							p = ap(buffer, sizeof(buffer), p, "%s)", cp );
 							tmp_val = cfgh.cfg[i];  /* a 4 bit SV configuration/type code */
 							p = ap(buffer, sizeof(buffer), p, "; cfg=0x%02x (", tmp_val);
 							switch (tmp_val & 0x7)
+							{
 								case 0x00:  cp = "(reserved)";        break;
 								case 0x01:  cp = "BLOCK II/IIA/IIR";  break;
 								case 0x02:  cp = "BLOCK IIR-M";       break;
 								case 0x03:  cp = "BLOCK IIF";         break;
 								case 0x04:  cp = "BLOCK III";         break;
 								default:   cp = "unknown SV type";   break;
+							}
 							p = ap(buffer, sizeof(buffer), p, "%s", cp );
 							if (tmp_val & 0x08)  /* A-S is on, P-code is encrypted */
 								p = ap( buffer, sizeof(buffer), p, ", A-S on" );
 							p = ap(buffer, sizeof(buffer), p, ")\"");
 							set_var(&parse->kv, buffer, sizeof(buffer), RO|COND_DEF);
+						}
+					}
+				}
 			break;
 			case GPS_ALM:
 				break;
 			case GPS_EPH:
 				break;
 			case GPS_UTC:
+				{
 					UTC utc;
 					char buffer[512];
 					char *p;
 					p = buffer;
 					get_mbg_utc(&bufp, &utc);
 					if (utc.valid)
+					{
 						p = ap(buffer, sizeof(buffer), p, "gps_utc_correction=\"");
 						mk_utcinfo(p, utc.t0t.wn, utc.WNlsf, utc.DNt, utc.delta_tls, utc.delta_tlsf, BUFFER_SIZE(buffer, p));
 						p += strlen(p);
 						p = ap(buffer, sizeof(buffer), p, "\"");
+					}
 					else
+					{
 						p = ap(buffer, sizeof(buffer), p, "gps_utc_correction=\"<NO UTC DATA>\"");
+					}
 					set_var(&parse->kv, buffer, sizeof(buffer), RO|DEF);
+				}
 			break;
 			case GPS_IONO:
 				break;
 			case GPS_ASCII_MSG:
+				{
 					ASCII_MSG gps_ascii_msg;
 					char buffer[128];
 					get_mbg_ascii_msg(&bufp, &gps_ascii_msg);
 					if (gps_ascii_msg.valid)
+						{
 							char buffer1[128];
 							mkreadable(buffer1, sizeof(buffer1), gps_ascii_msg.s, strlen(gps_ascii_msg.s), (int)0);
 							snprintf(buffer, sizeof(buffer), "gps_message=\"%s\"", buffer1);
+						}
 					else
 						snprintf(buffer, sizeof(buffer), "gps_message=<NONE>");
 					set_var(&parse->kv, buffer, sizeof(buffer), RO|DEF);
+				}
 			break;
 			default:
 				break;
+			}
+		}
 		else
+		{
 			msyslog(LOG_DEBUG, "PARSE receiver #%d: gps16x_message: message checksum error: hdr_csum = 0x%x (expected 0x%x), "
 			                   "data_len = %d, data_csum = 0x%x (expected 0x%x)",
 				CLK_UNIT(parse->peer),
 				header.hdr_csum, mbg_csum(parsetime->parse_msg + 1, 6),
 				header.len,
 				header.data_csum, mbg_csum(bufp, (unsigned)((header.len < sizeof(parsetime->parse_msg)) ? header.len : 0)));
+		}
+	}
 	return;
+}
 /*------------------------------------------------------------
  * gps16x_poll - query the reciver peridically
  */
 static void
 gps16x_poll(
 	    struct peer *peer
+	    )
+{
 	struct parseunit *parse = peer->procptr->unitptr;
 	static GPS_MSG_HDR sequence[] =
+	{
 		{ GPS_SW_REV,          0, 0, 0 },
 		{ GPS_BVAR_STAT,       0, 0, 0 },
 		{ GPS_UTC,             0, 0, 0 },
 		{ GPS_ASCII_MSG,       0, 0, 0 },
 		{ GPS_ANT_INFO,        0, 0, 0 },
 		{ GPS_CFGH,            0, 0, 0 },
 		{ GPS_POS_XYZ,         0, 0, 0 },
 		{ GPS_POS_LLA,         0, 0, 0 },
 		{ (unsigned short)~0,  0, 0, 0 }
 	};
 	int rtc;
 	unsigned char cmd_buffer[64];
 	unsigned char *outp = cmd_buffer;
 	GPS_MSG_HDR *header;
 	if (((poll_info_t *)parse->parse_type->cl_data)->rate)
+	{
 		parse->peer->procptr->nextaction = current_time + ((poll_info_t *)parse->parse_type->cl_data)->rate;
+	}
 	if (sequence[parse->localstate].cmd == (unsigned short)~0)
 		parse->localstate = 0;
 	header = sequence + parse->localstate++;
 	*outp++ = SOH;		/* start command */
 	put_mbg_header(&outp, header);
 	outp = cmd_buffer + 1;
 	header->hdr_csum = (short)mbg_csum(outp, 6);
 	put_mbg_header(&outp, header);
 #ifdef DEBUG
 	if (debug > 2)
+	{
 		char buffer[128];
 		mkreadable(buffer, sizeof(buffer), (char *)cmd_buffer, (unsigned)(outp - cmd_buffer), 1);
 		printf("PARSE receiver #%d: transmitted message #%ld (%d bytes) >%s<\n",
 		       CLK_UNIT(parse->peer),
 		       parse->localstate - 1,
 		       (int)(outp - cmd_buffer),
 		       buffer);
+	}
 #endif
 	rtc = (int) write(parse->generic->io.fd, cmd_buffer, (unsigned long)(outp - cmd_buffer));
 	if (rtc < 0)
+	{
 		ERR(ERR_BADIO)
 			msyslog(LOG_ERR, "PARSE receiver #%d: gps16x_poll: failed to send cmd to clock: %m", CLK_UNIT(parse->peer));
+	}
 	else
 	if (rtc != outp - cmd_buffer)
+	{
 		ERR(ERR_BADIO)
 			msyslog(LOG_ERR, "PARSE receiver #%d: gps16x_poll: failed to send cmd incomplete (%d of %d bytes sent)", CLK_UNIT(parse->peer), rtc, (int)(outp - cmd_buffer));
+	}
 	clear_err(parse, ERR_BADIO);
 	return;
+}
 /*--------------------------------------------------
  * init routine - setup timer
  */
 static int
 gps16x_poll_init(
 	struct parseunit *parse
+	)
+{
 	if (((poll_info_t *)parse->parse_type->cl_data)->rate)
+	{
 		parse->peer->procptr->action = gps16x_poll;
 		gps16x_poll(parse->peer);
+	}
 	return 0;
+}
 #else
 static void
 gps16x_message(
 	       struct parseunit *parse,
 	       parsetime_t      *parsetime
+	       )
 {}
 static int
 gps16x_poll_init(
 	struct parseunit *parse
+	)
+{
 	return 1;
+}
 #endif /* CLOCK_MEINBERG */
 /**===========================================================================
  ** clock polling support
  **/
 /*--------------------------------------------------
  * direct poll routine
  */
 static void
 poll_dpoll(
 	struct parseunit *parse
+	)
+{
 	long rtc;
 	const char *ps = ((poll_info_t *)parse->parse_type->cl_data)->string;
 	long ct = ((poll_info_t *)parse->parse_type->cl_data)->count;
 	rtc = write(parse->generic->io.fd, ps, ct);
 	if (rtc < 0)
+	{
 		ERR(ERR_BADIO)
 			msyslog(LOG_ERR, "PARSE receiver #%d: poll_dpoll: failed to send cmd to clock: %m", CLK_UNIT(parse->peer));
+	}
 	else
 	    if (rtc != ct)
+	    {
 		    ERR(ERR_BADIO)
 			    msyslog(LOG_ERR, "PARSE receiver #%d: poll_dpoll: failed to send cmd incomplete (%ld of %ld bytes sent)", CLK_UNIT(parse->peer), rtc, ct);
+	    }
 	clear_err(parse, ERR_BADIO);
+}
 /*--------------------------------------------------
  * periodic poll routine
  */
 static void
 poll_poll(
 	struct peer *peer
+	)
+{
 	struct parseunit *parse = peer->procptr->unitptr;
 	if (parse->parse_type->cl_poll)
 		parse->parse_type->cl_poll(parse);
 	if (((poll_info_t *)parse->parse_type->cl_data)->rate)
+	{
 		parse->peer->procptr->nextaction = current_time + ((poll_info_t *)parse->parse_type->cl_data)->rate;
+	}
+}
 /*--------------------------------------------------
  * init routine - setup timer
  */
 static int
 poll_init(
 	struct parseunit *parse
+	)
+{
 	if (((poll_info_t *)parse->parse_type->cl_data)->rate)
+	{
 		parse->peer->procptr->action = poll_poll;
 		poll_poll(parse->peer);
+	}
 	return 0;
+}
 /**===========================================================================
  ** Trimble support
  **/
 /*-------------------------------------------------------------
  * trimble TAIP init routine - setup EOL and then do poll_init.
  */
 static int
 trimbletaip_init(
 	struct parseunit *parse
+	)
+{
 #ifdef HAVE_TERMIOS
 	struct termios tio;
 #endif
 #ifdef HAVE_SYSV_TTYS
 	struct termio tio;
 #endif
 	/*
 	 * configure terminal line for trimble receiver
 	 */
 	if (TTY_GETATTR(parse->generic->io.fd, &tio) == -1)
+	{
 		msyslog(LOG_ERR, "PARSE receiver #%d: trimbletaip_init: tcgetattr(fd, &tio): %m", CLK_UNIT(parse->peer));
 		return 0;
+	}
 	else
+	{
 		tio.c_cc[VEOL] = TRIMBLETAIP_EOL;
 		if (TTY_SETATTR(parse->generic->io.fd, &tio) == -1)
+		{
 			msyslog(LOG_ERR, "PARSE receiver #%d: trimbletaip_init: tcsetattr(fd, &tio): %m", CLK_UNIT(parse->peer));
 			return 0;
+		}
+	}
 	return poll_init(parse);
+}
 /*--------------------------------------------------
  * trimble TAIP event routine - reset receiver upon data format trouble
  */
 static const char *taipinit[] = {
 	">FPV00000000<",
 	">SRM;ID_FLAG=F;CS_FLAG=T;EC_FLAG=F;FR_FLAG=T;CR_FLAG=F<",
 	">FTM00020001<",
 	(char *)0
 };
 static void
 trimbletaip_event(
 	struct parseunit *parse,
 	int event
+	)
+{
 	switch (event)
+	{
 	    case CEVNT_BADREPLY:	/* reset on garbled input */
 	    case CEVNT_TIMEOUT:		/* reset on no input */
+		    {
 			    const char **iv;
 			    iv = taipinit;
 			    while (*iv)
+			    {
 				    int rtc = (int) write(parse->generic->io.fd, *iv, strlen(*iv));
 				    if (rtc < 0)
+				    {
 					    msyslog(LOG_ERR, "PARSE receiver #%d: trimbletaip_event: failed to send cmd to clock: %m", CLK_UNIT(parse->peer));
 					    return;
+				    }
 				    else
+				    {
 					    if (rtc != (int)strlen(*iv))
+					    {
 						    msyslog(LOG_ERR, "PARSE receiver #%d: trimbletaip_event: failed to send cmd incomplete (%d of %d bytes sent)",
 							    CLK_UNIT(parse->peer), rtc, (int)strlen(*iv));
 						    return;
+					    }
+				    }
 				    iv++;
+			    }
 			    NLOG(NLOG_CLOCKINFO)
 				    ERR(ERR_BADIO)
 				    msyslog(LOG_ERR, "PARSE receiver #%d: trimbletaip_event: RECEIVER INITIALIZED",
 					    CLK_UNIT(parse->peer));
+		    }
 		    break;
 	    default:			/* ignore */
 		break;
+	}
+}
 /*
  * This driver supports the Trimble SVee Six Plus GPS receiver module.
  * It should support other Trimble receivers which use the Trimble Standard
  * Interface Protocol (see below).
+ *
  * The module has a serial I/O port for command/data and a 1 pulse-per-second
  * output, about 1 microsecond wide. The leading edge of the pulse is
  * coincident with the change of the GPS second. This is the same as
  * the change of the UTC second +/- ~1 microsecond. Some other clocks
  * specifically use a feature in the data message as a timing reference, but
  * the SVee Six Plus does not do this. In fact there is considerable jitter
  * on the timing of the messages, so this driver only supports the use
  * of the PPS pulse for accurate timing. Where it is determined that
  * the offset is way off, when first starting up ntpd for example,
  * the timing of the data stream is used until the offset becomes low enough
  * (|offset| < CLOCK_MAX), at which point the pps offset is used.
+ *
  * It can use either option for receiving PPS information - the 'ppsclock'
  * stream pushed onto the serial data interface to timestamp the Carrier
  * Detect interrupts, where the 1PPS connects to the CD line. This only
  * works on SunOS 4.1.x currently. To select this, define PPSPPS in
  * Config.local. The other option is to use a pulse-stretcher/level-converter
  * to convert the PPS pulse into a RS232 start pulse & feed this into another
  * tty port. To use this option, define PPSCLK in Config.local. The pps input,
  * by whichever method, is handled in ntp_loopfilter.c
+ *
  * The receiver uses a serial message protocol called Trimble Standard
  * Interface Protocol (it can support others but this driver only supports
  * TSIP). Messages in this protocol have the following form:
+ *
  * <DLE><id> ... <data> ... <DLE><ETX>
+ *
  * Any bytes within the <data> portion of value 10 hex (<DLE>) are doubled
  * on transmission and compressed back to one on reception. Otherwise
  * the values of data bytes can be anything. The serial interface is RS-422
  * asynchronous using 9600 baud, 8 data bits with odd party (**note** 9 bits
  * in total!), and 1 stop bit. The protocol supports byte, integer, single,
  * and double datatypes. Integers are two bytes, sent most significant first.
  * Singles are IEEE754 single precision floating point numbers (4 byte) sent
  * sign & exponent first. Doubles are IEEE754 double precision floating point
  * numbers (8 byte) sent sign & exponent first.
  * The receiver supports a large set of messages, only a small subset of
  * which are used here. From driver to receiver the following are used:
+ *
  *  ID    Description
+ *
  *  21    Request current time
  *  22    Mode Select
  *  2C    Set/Request operating parameters
  *  2F    Request UTC info
  *  35    Set/Request I/O options
  * From receiver to driver the following are recognised:
+ *
  *  ID    Description
+ *
  *  41    GPS Time
  *  44    Satellite selection, PDOP, mode
  *  46    Receiver health
  *  4B    Machine code/status
  *  4C    Report operating parameters (debug only)
  *  4F    UTC correction data (used to get leap second warnings)
  *  55    I/O options (debug only)
+ *
  * All others are accepted but ignored.
+ *
  */
 #define PI		3.1415926535898	/* lots of sig figs */
 #define D2R		PI/180.0
 /*-------------------------------------------------------------------
  * sendcmd, sendbyte, sendetx, sendflt, sendint implement the command
  * interface to the receiver.
+ *
  * CAVEAT: the sendflt, sendint routines are byte order dependend and
  * float implementation dependend - these must be converted to portable
  * versions !
+ *
  * CURRENT LIMITATION: float implementation. This runs only on systems
  * with IEEE754 floats as native floats
  */
 typedef struct trimble
+{
 	u_long last_msg;	/* last message received */
 	u_long last_reset;	/* last time a reset was issued */
 	u_char qtracking;	/* query tracking status */
 	u_long ctrack;		/* current tracking set */
 	u_long ltrack;		/* last tracking set */
 } trimble_t;
 union uval {
 	u_char  bd[8];
 	int     iv;
 	float   fv;
 	double  dv;
 };
 struct txbuf
+{
 	short idx;			/* index to first unused byte */
 	u_char *txt;			/* pointer to actual data buffer */
 };
 void	sendcmd		(struct txbuf *buf, int c);
 void	sendbyte	(struct txbuf *buf, int b);
 void	sendetx		(struct txbuf *buf, struct parseunit *parse);
 void	sendint		(struct txbuf *buf, int a);
 void	sendflt		(struct txbuf *buf, double a);
 void
 sendcmd(
 	struct txbuf *buf,
 	int c
+	)
+{
 	buf->txt[0] = DLE;
 	buf->txt[1] = (u_char)c;
 	buf->idx = 2;
+}
 void	sendcmd		(struct txbuf *buf, int c);
 void	sendbyte	(struct txbuf *buf, int b);
 void	sendetx		(struct txbuf *buf, struct parseunit *parse);
 void	sendint		(struct txbuf *buf, int a);
 void	sendflt		(struct txbuf *buf, double a);
 void
 sendbyte(
 	struct txbuf *buf,
 	int b
+	)
+{
 	if (b == DLE)
 	    buf->txt[buf->idx++] = DLE;
 	buf->txt[buf->idx++] = (u_char)b;
+}
 void
 sendetx(
 	struct txbuf *buf,
 	struct parseunit *parse
+	)
+{
 	buf->txt[buf->idx++] = DLE;
 	buf->txt[buf->idx++] = ETX;
 	if (write(parse->generic->io.fd, buf->txt, (unsigned long)buf->idx) != buf->idx)
+	{
 		ERR(ERR_BADIO)
 			msyslog(LOG_ERR, "PARSE receiver #%d: sendetx: failed to send cmd to clock: %m", CLK_UNIT(parse->peer));
+	}
 	else
+	{
 #ifdef DEBUG
 	  if (debug > 2)
+	  {
 		  char buffer[256];
 		  mkreadable(buffer, sizeof(buffer), (char *)buf->txt, (unsigned)buf->idx, 1);
 		  printf("PARSE receiver #%d: transmitted message (%d bytes) >%s<\n",
 			 CLK_UNIT(parse->peer),
 			 buf->idx, buffer);
+	  }
 #endif
 		clear_err(parse, ERR_BADIO);
+	}
+}
 void
 sendint(
 	struct txbuf *buf,
 	int a
+	)
+{
 	/* send 16bit int, msbyte first */
 	sendbyte(buf, (u_char)((a>>8) & 0xff));
 	sendbyte(buf, (u_char)(a & 0xff));
+}
 void
 sendflt(
 	struct txbuf *buf,
 	double a
+	)
+{
 	int i;
 	union uval uval;
 	uval.fv = (float) a;
 #ifdef WORDS_BIGENDIAN
 	for (i=0; i<=3; i++)
 #else
 	    for (i=3; i>=0; i--)
 #endif
 		sendbyte(buf, uval.bd[i]);
+}
 #define TRIM_POS_OPT	0x13	/* output position with high precision */
 #define TRIM_TIME_OPT	0x03	/* use UTC time stamps, on second */
 /*--------------------------------------------------
  * trimble TSIP setup routine
  */
 static int
 trimbletsip_setup(
 		  struct parseunit *parse,
 		  const char *reason
+		  )
+{
 	u_char buffer[256];
 	struct txbuf buf;
 	trimble_t *t = parse->localdata;
 	if (t && t->last_reset &&
 	    ((t->last_reset + TRIMBLE_RESET_HOLDOFF) > current_time)) {
 		return 1;	/* not yet */
+	}
 	if (t)
 		t->last_reset = current_time;
 	buf.txt = buffer;
 	sendcmd(&buf, CMD_CVERSION);	/* request software versions */
 	sendetx(&buf, parse);
 	sendcmd(&buf, CMD_COPERPARAM);	/* set operating parameters */
 	sendbyte(&buf, 4);	/* static */
 	sendflt(&buf, 5.0*D2R);	/* elevation angle mask = 10 deg XXX */
 	sendflt(&buf, 4.0);	/* s/n ratio mask = 6 XXX */
 	sendflt(&buf, 12.0);	/* PDOP mask = 12 */
 	sendflt(&buf, 8.0);	/* PDOP switch level = 8 */
 	sendetx(&buf, parse);
 	sendcmd(&buf, CMD_CMODESEL);	/* fix mode select */
 	sendbyte(&buf, 1);	/* time transfer mode */
 	sendetx(&buf, parse);
 	sendcmd(&buf, CMD_CMESSAGE);	/* request system message */
 	sendetx(&buf, parse);
 	sendcmd(&buf, CMD_CSUPER);	/* superpacket fix */
 	sendbyte(&buf, 0x2);	/* binary mode */
 	sendetx(&buf, parse);
 	sendcmd(&buf, CMD_CIOOPTIONS);	/* set I/O options */
 	sendbyte(&buf, TRIM_POS_OPT);	/* position output */
 	sendbyte(&buf, 0x00);	/* no velocity output */
 	sendbyte(&buf, TRIM_TIME_OPT);	/* UTC, compute on seconds */
 	sendbyte(&buf, 0x00);	/* no raw measurements */
 	sendetx(&buf, parse);
 	sendcmd(&buf, CMD_CUTCPARAM);	/* request UTC correction data */
 	sendetx(&buf, parse);
 	NLOG(NLOG_CLOCKINFO)
 		ERR(ERR_BADIO)
 		msyslog(LOG_ERR, "PARSE receiver #%d: trimbletsip_setup: RECEIVER RE-INITIALIZED (%s)", CLK_UNIT(parse->peer), reason);
 	return 0;
+}
 /*--------------------------------------------------
  * TRIMBLE TSIP check routine
  */
 static void
 trimble_check(
 	      struct peer *peer
+	      )
+{
 	struct parseunit *parse = peer->procptr->unitptr;
 	trimble_t *t = parse->localdata;
 	u_char buffer[256];
 	struct txbuf buf;
 	buf.txt = buffer;
 	if (t)
+	{
 		if (current_time > t->last_msg + TRIMBLETSIP_IDLE_TIME)
 			(void)trimbletsip_setup(parse, "message timeout");
+	}
 	poll_poll(parse->peer);	/* emit query string and re-arm timer */
 	if (t && t->qtracking)
+	{
 		u_long oldsats = t->ltrack & ~t->ctrack;
 		t->qtracking = 0;
 		t->ltrack = t->ctrack;
 		if (oldsats)
+		{
 			int i;
 			for (i = 0; oldsats; i++) {
 				if (oldsats & (1 << i))
+					{
 						sendcmd(&buf, CMD_CSTATTRACK);
 						sendbyte(&buf, i+1);	/* old sat */
 						sendetx(&buf, parse);
+					}
 				oldsats &= ~(1 << i);
+			}
+		}
 		sendcmd(&buf, CMD_CSTATTRACK);
 		sendbyte(&buf, 0x00);	/* current tracking set */
 		sendetx(&buf, parse);
+	}
+}
 /*--------------------------------------------------
  * TRIMBLE TSIP end routine
  */
 static void
 trimbletsip_end(
 	      struct parseunit *parse
+	      )
 {	trimble_t *t = parse->localdata;
 	if (t)
+	{
 		free(t);
 		parse->localdata = NULL;
+	}
 	parse->peer->procptr->nextaction = 0;
 	parse->peer->procptr->action = NULL;
+}
 /*--------------------------------------------------
  * TRIMBLE TSIP init routine
  */
 static int
 trimbletsip_init(
 	struct parseunit *parse
+	)
+{
 #if defined(VEOL) || defined(VEOL2)
 #ifdef HAVE_TERMIOS
 	struct termios tio;		/* NEEDED FOR A LONG TIME ! */
 #endif
 #ifdef HAVE_SYSV_TTYS
 	struct termio tio;		/* NEEDED FOR A LONG TIME ! */
 #endif
 	/*
 	 * allocate local data area
 	 */
 	if (!parse->localdata)