_( -> GT_(

svn path=/trunk/; revision=3478

23 files changed, 519 insertions, 517 deletions

diff --git a/NEWS b/NEWS
index ab7af1f2..96b4c04d 100644
--- a/NEWS
+++ b/NEWS
@@ -15,6 +15,8 @@
 * Mike Warfield's fix for using a combined SSL cert and key in a single file.
 * DNS lookups moved to just before te mailserver socket open, so fetchmail
   now works OK even if started up without Internet access.
+* Switched from _( to GT_( as a gettext macro, in order to avoid a 
+  conflict with the SSL library.
 
 fetchmail-5.9.0 (Sun Aug 12 23:52:16 EDT 2001), 21062 lines:
 
@@ -56,7 +58,7 @@ fetchmail-5.8.15 (Tue Jul 31 02:07:03 EDT 2001), 21075 lines:
 * Man page bugs pointed out by Andrew Benham.
 * POP3 end of session RSET on keep removed.
 * In IMAP, handle BAD and NO responses to FETCH gracefully.
-* Parse "no {syslog|invisible|showdots} properly.
+* Parse "no {syslog|invisible|showdots}" properly.
 * Change AC_DEFINE to AC_DEFINE_UNQUOTED appropriately in configure.in
   (Debian bug #104484).
 * Fixed bug in fetchmailconf plugin/plugout code (Debian bug #105987).
diff --git a/driver.c b/driver.c
index d3ea352f..9f2a8915 100644
--- a/driver.c
+++ b/driver.c
@@ -150,7 +150,7 @@ char *principal;
     }
     if (rem != KSUCCESS)
     {
-	report(stderr, _("kerberos error %s\n"), (krb_get_err_text (rem)));
+	report(stderr, GT_("kerberos error %s\n"), (krb_get_err_text (rem)));
 	return (PS_AUTHFAIL);
     }
     return (0);
@@ -209,12 +209,12 @@ const char *canonical;  /* server name */
     if (retval) {
 #ifdef HEIMDAL
       if (err_ret && err_ret->e_text) {
-          report(stderr, _("krb5_sendauth: %s [server says '%*s'] \n"),
+          report(stderr, GT_("krb5_sendauth: %s [server says '%*s'] \n"),
                  error_message(retval),
                  err_ret->e_text);
 #else
       if (err_ret && err_ret->text.length) {
-          report(stderr, _("krb5_sendauth: %s [server says '%*s'] \n"),
+          report(stderr, GT_("krb5_sendauth: %s [server says '%*s'] \n"),
 		 error_message(retval),
 		 err_ret->text.length,
 		 err_ret->text.data);
@@ -295,7 +295,7 @@ static void send_size_warnings(struct query *ctl)
     if (open_warning_by_mail(ctl, (struct msgblk *)NULL))
 	return;
     stuff_warning(ctl,
-	   _("Subject: Fetchmail oversized-messages warning.\r\n"
+	   GT_("Subject: Fetchmail oversized-messages warning.\r\n"
 	     "\r\n"
 	     "The following oversized messages remain on the mail server %s:"),
 		  ctl->server.pollname);
@@ -313,7 +313,7 @@ static void send_size_warnings(struct query *ctl)
 	    nbr = current->val.status.mark;
 	    size = atoi(current->id);
 	    stuff_warning(ctl, 
-		    _("\t%d msg %d octets long skipped by fetchmail.\r\n"),
+		    GT_("\t%d msg %d octets long skipped by fetchmail.\r\n"),
 		    nbr, size);
 	}
 	current->val.status.num++;
@@ -397,7 +397,7 @@ static int fetch_messages(int mailserver_socket, struct query *ctl,
 	    if (outlevel > O_SILENT)
 	    {
 		report_build(stdout, 
-			     _("skipping message %s@%s:%d (%d octets)"),
+			     GT_("skipping message %s@%s:%d (%d octets)"),
 			     ctl->remotename, ctl->server.truename, num,
 			     msgsizes[num-1]);
 		switch (msgcodes[num-1])
@@ -413,11 +413,11 @@ static int fetch_messages(int mailserver_socket, struct query *ctl,
 		     * DELE succeeds but doesn't actually delete
 		     * the message.
 		     */
-		    report_build(stdout, _(" (length -1)"));
+		    report_build(stdout, GT_(" (length -1)"));
 		    break;
 		case MSGLEN_TOOLARGE:
 		    report_build(stdout, 
-				 _(" (oversized, %d octets)"),
+				 GT_(" (oversized, %d octets)"),
 				 msgsizes[num-1]);
 		    break;
 		}
@@ -432,7 +432,7 @@ static int fetch_messages(int mailserver_socket, struct query *ctl,
 	    if (err == PS_TRANSIENT)    /* server is probably Exchange */
 	    {
 		report_build(stdout,
-			     _("couldn't fetch headers, message %s@%s:%d (%d octets)"),
+			     GT_("couldn't fetch headers, message %s@%s:%d (%d octets)"),
 			     ctl->remotename, ctl->server.truename, num,
 			     msgsizes[num-1]);
 		continue;
@@ -449,13 +449,13 @@ static int fetch_messages(int mailserver_socket, struct query *ctl,
 
 	    if (outlevel > O_SILENT)
 	    {
-		report_build(stdout, _("reading message %s@%s:d of %d"),
+		report_build(stdout, GT_("reading message %s@%s:d of %d"),
 			     ctl->remotename, ctl->server.truename,
 			     num, count);
 
 		if (len > 0)
-		    report_build(stdout, _(" (%d %soctets)"),
-				 len, wholesize ? "" : _("header "));
+		    report_build(stdout, GT_(" (%d %soctets)"),
+				 len, wholesize ? "" : GT_("header "));
 		if (outlevel >= O_VERBOSE)
 		    report_complete(stdout, "\n");
 		else
@@ -513,7 +513,7 @@ static int fetch_messages(int mailserver_socket, struct query *ctl,
 			len = msgsizes[num-1] - msgblk.msglen;
 		    if (outlevel > O_SILENT && !wholesize)
 			report_complete(stdout,
-					_(" (%d body octets) "), len);
+					GT_(" (%d body octets) "), len);
 		}
 	    }
 
@@ -586,7 +586,7 @@ static int fetch_messages(int mailserver_socket, struct query *ctl,
 	    {
 		if (outlevel >= O_DEBUG)
 		    report(stdout,
-			   _("message %s@%s:%d was not the expected length (%d actual != %d expected)\n"),
+			   GT_("message %s@%s:%d was not the expected length (%d actual != %d expected)\n"),
 			   ctl->remotename, ctl->server.truename, num,
 			   msgblk.msglen, msgsizes[num-1]);
 	    }
@@ -628,7 +628,7 @@ static int fetch_messages(int mailserver_socket, struct query *ctl,
 	if (retained)
 	{
 	    if (outlevel > O_SILENT) 
-		report(stdout, _(" retained\n"));
+		report(stdout, GT_(" retained\n"));
 	}
 	else if (ctl->server.base_protocol->delete
 		 && !suppress_delete
@@ -636,7 +636,7 @@ static int fetch_messages(int mailserver_socket, struct query *ctl,
 	{
 	    (*deletions)++;
 	    if (outlevel > O_SILENT) 
-		report_complete(stdout, _(" flushed\n"));
+		report_complete(stdout, GT_(" flushed\n"));
 	    err = (ctl->server.base_protocol->delete)(mailserver_socket, ctl, num);
 	    if (err != 0)
 		return(err);
@@ -645,12 +645,12 @@ static int fetch_messages(int mailserver_socket, struct query *ctl,
 #endif /* POP3_ENABLE */
 	}
 	else if (outlevel > O_SILENT) 
-	    report_complete(stdout, _(" not flushed\n"));
+	    report_complete(stdout, GT_(" not flushed\n"));
 
 	/* perhaps this as many as we're ready to handle */
 	if (maxfetch && maxfetch <= *fetches && *fetches < count)
 	{
-	    report(stdout, _("fetchlimit %d reached; %d messages left on server %s account %s\n"),
+	    report(stdout, GT_("fetchlimit %d reached; %d messages left on server %s account %s\n"),
 		   maxfetch, count - *fetches, ctl->server.truename, ctl->remotename);
 	    return(PS_MAXFETCH);
 	}
@@ -710,7 +710,7 @@ const int maxfetch;		/* maximum number of messages to fetch */
 	{
 	    signal(SIGPIPE, SIG_IGN);
 	    report(stdout,
-		   _("SIGPIPE thrown from an MDA or a stream socket error\n"));
+		   GT_("SIGPIPE thrown from an MDA or a stream socket error\n"));
 	    err = PS_SOCKET;
 	    goto cleanUp;
 	}
@@ -718,23 +718,23 @@ const int maxfetch;		/* maximum number of messages to fetch */
 	{
 	    if (phase == OPEN_WAIT)
 		report(stdout,
-		       _("timeout after %d seconds waiting to connect to server %s.\n"),
+		       GT_("timeout after %d seconds waiting to connect to server %s.\n"),
 		       ctl->server.timeout, ctl->server.pollname);
 	    else if (phase == SERVER_WAIT)
 		report(stdout,
-		       _("timeout after %d seconds waiting for server %s.\n"),
+		       GT_("timeout after %d seconds waiting for server %s.\n"),
 		       ctl->server.timeout, ctl->server.pollname);
 	    else if (phase == FORWARDING_WAIT)
 		report(stdout,
-		       _("timeout after %d seconds waiting for %s.\n"),
+		       GT_("timeout after %d seconds waiting for %s.\n"),
 		       ctl->server.timeout,
 		       ctl->mda ? "MDA" : "SMTP");
 	    else if (phase == LISTENER_WAIT)
 		report(stdout,
-		       _("timeout after %d seconds waiting for listener to respond.\n"), ctl->server.timeout);
+		       GT_("timeout after %d seconds waiting for listener to respond.\n"), ctl->server.timeout);
 	    else
 		report(stdout, 
-		       _("timeout after %d seconds.\n"), ctl->server.timeout);
+		       GT_("timeout after %d seconds.\n"), ctl->server.timeout);
 
 	    /*
 	     * If we've exceeded our threshold for consecutive timeouts, 
@@ -746,14 +746,14 @@ const int maxfetch;		/* maximum number of messages to fetch */
 		&& !open_warning_by_mail(ctl, (struct msgblk *)NULL))
 	    {
 		stuff_warning(ctl,
-			      _("Subject: fetchmail sees repeated timeouts\r\n"));
+			      GT_("Subject: fetchmail sees repeated timeouts\r\n"));
 		stuff_warning(ctl,
-			      _("Fetchmail saw more than %d timeouts while attempting to get mail from %s@%s.\r\n"), 
+			      GT_("Fetchmail saw more than %d timeouts while attempting to get mail from %s@%s.\r\n"), 
 			      MAX_TIMEOUTS,
 			      ctl->remotename,
 			      ctl->server.truename);
 		stuff_warning(ctl, 
-    _("This could mean that your mailserver is stuck, or that your SMTP\r\n" \
+    GT_("This could mean that your mailserver is stuck, or that your SMTP\r\n" \
     "server is wedged, or that your mailbox file on the server has been\r\n" \
     "corrupted by a server error.  You can run `fetchmail -v -v' to\r\n" \
     "diagnose the problem.\r\n\r\n" \
@@ -789,7 +789,7 @@ const int maxfetch;		/* maximum number of messages to fetch */
 	if (ctl->preconnect && (err = system(ctl->preconnect)))
 	{
 	    report(stderr, 
-		   _("pre-connection command failed with status %d\n"), err);
+		   GT_("pre-connection command failed with status %d\n"), err);
 	    err = PS_SYNTAX;
 	    goto closeUp;
 	}
@@ -822,7 +822,7 @@ const int maxfetch;		/* maximum number of messages to fetch */
 		/* prevent core dump from ill-formed or duplicate entry */
 		if (!leadname)
 		{
-		    report(stderr, _("Lead server has no name.\n"));
+		    report(stderr, GT_("Lead server has no name.\n"));
 		    err = PS_DNS;
 		    set_timeout(0);
 		    phase = oldphase;
@@ -845,7 +845,7 @@ const int maxfetch;		/* maximum number of messages to fetch */
 		if (namerec == (struct hostent *)NULL)
 		{
 		    report(stderr,
-			   _("couldn't find canonical DNS name of %s\n"),
+			   GT_("couldn't find canonical DNS name of %s\n"),
 			   ctl->server.pollname);
 		    err = PS_DNS;
 		    set_timeout(0);
@@ -882,7 +882,7 @@ const int maxfetch;		/* maximum number of messages to fetch */
 	    int err_no = errno;
 #ifdef HAVE_RES_SEARCH
 	    if (err_no != 0 && h_errno != 0)
-		report(stderr, _("internal inconsistency\n"));
+		report(stderr, GT_("internal inconsistency\n"));
 #endif
 	    /*
 	     * Avoid generating a bogus error every poll cycle when we're
@@ -892,28 +892,28 @@ const int maxfetch;		/* maximum number of messages to fetch */
 	    if (!((err_no == EHOSTUNREACH || err_no == ENETUNREACH) 
 		  && run.poll_interval))
 	    {
-		report_build(stderr, _("%s connection to %s failed"), 
+		report_build(stderr, GT_("%s connection to %s failed"), 
 			     ctl->server.base_protocol->name, ctl->server.pollname);
 #ifdef HAVE_RES_SEARCH
 		if (h_errno != 0)
 		{
 		    if (h_errno == HOST_NOT_FOUND)
-			strcpy(errbuf, _("host is unknown."));
+			strcpy(errbuf, GT_("host is unknown."));
 #ifndef __BEOS__
 		    else if (h_errno == NO_ADDRESS)
-			strcpy(errbuf, _("name is valid but has no IP address."));
+			strcpy(errbuf, GT_("name is valid but has no IP address."));
 #endif
 		    else if (h_errno == NO_RECOVERY)
-			strcpy(errbuf, _("unrecoverable name server error."));
+			strcpy(errbuf, GT_("unrecoverable name server error."));
 		    else if (h_errno == TRY_AGAIN)
-			strcpy(errbuf, _("temporary name server error."));
+			strcpy(errbuf, GT_("temporary name server error."));
 		    else
 #ifdef HAVE_SNPRINTF
 			snprintf(errbuf, sizeof(errbuf),
 #else
 			sprintf(errbuf,
 #endif /* HAVE_SNPRINTF */
-			  _("unknown DNS error %d."), h_errno);
+			  GT_("unknown DNS error %d."), h_errno);
 		}
 		else
 #endif /* HAVE_RES_SEARCH */
@@ -931,7 +931,7 @@ const int maxfetch;		/* maximum number of messages to fetch */
 		if (open_warning_by_mail(ctl, (struct msgblk *)NULL) == 0)
 		{
 		    stuff_warning(ctl,
-			 _("Subject: Fetchmail unreachable-server warning.\r\n"
+			 GT_("Subject: Fetchmail unreachable-server warning.\r\n"
 			   "\r\n"
 			   "Fetchmail could not reach the mail server %s:")
 				  ctl->server.pollname);
@@ -956,7 +956,7 @@ const int maxfetch;		/* maximum number of messages to fetch */
 	if (ctl->use_ssl && SSLOpen(mailserver_socket,ctl->sslcert,ctl->sslkey,ctl->sslproto,ctl->sslcertck,
 	    ctl->sslcertpath,ctl->sslfingerprint,realhost,ctl->server.pollname) == -1) 
 	{
-	    report(stderr, _("SSL connection failed.\n"));
+	    report(stderr, GT_("SSL connection failed.\n"));
 	    goto closeUp;
 	}
 #endif
@@ -998,19 +998,19 @@ const int maxfetch;		/* maximum number of messages to fetch */
 	    if (err != 0)
 	    {
 		if (err == PS_LOCKBUSY)
-		    report(stderr, _("Lock-busy error on %s@%s\n"),
+		    report(stderr, GT_("Lock-busy error on %s@%s\n"),
 			  ctl->remotename,
 			  ctl->server.truename);
 		else if (err == PS_SERVBUSY)
-		    report(stderr, _("Server busy error on %s@%s\n"),
+		    report(stderr, GT_("Server busy error on %s@%s\n"),
 			  ctl->remotename,
 			  ctl->server.truename);
 		else if (err == PS_AUTHFAIL)
 		{
-		    report(stderr, _("Authorization failure on %s@%s%s\n"), 
+		    report(stderr, GT_("Authorization failure on %s@%s%s\n"), 
 			   ctl->remotename,
 			   ctl->server.truename,
-			   (ctl->wehaveauthed ? _(" (previously authorized)") : "")
+			   (ctl->wehaveauthed ? GT_(" (previously authorized)") : "")
 			);
 
 		    /*
@@ -1031,14 +1031,14 @@ const int maxfetch;		/* maximum number of messages to fetch */
 		    {
 			ctl->wehavesentauthnote = 1;
 			stuff_warning(ctl,
-				      _("Subject: fetchmail authentication failed on %s@%s\r\n"),
+				      GT_("Subject: fetchmail authentication failed on %s@%s\r\n"),
 			    ctl->remotename, ctl->server.truename);
 			stuff_warning(ctl,
-				      _("Fetchmail could not get mail from %s@%s.\r\n"), 
+				      GT_("Fetchmail could not get mail from %s@%s.\r\n"), 
 				      ctl->remotename,
 				      ctl->server.truename);
 			if (ctl->wehaveauthed)
-			    stuff_warning(ctl, _("\
+			    stuff_warning(ctl, GT_("\
 The attempt to get authorization failed.\r\n\
 Since we have already succeeded in getting authorization for this\r\n\
 connection, this is probably another failure mode (such as busy server)\r\n\
@@ -1053,7 +1053,7 @@ The fetchmail daemon will continue running and attempt to connect\r\n\
 at each cycle.  No future notifications will be sent until service\r\n\
 is restored."));
 			else
-			    stuff_warning(ctl, _("\
+			    stuff_warning(ctl, GT_("\
 The attempt to get authorization failed.\r\n\
 This probably means your password is invalid, but some servers have\r\n\
 other failure modes that fetchmail cannot distinguish from this\r\n\
@@ -1066,7 +1066,7 @@ is restored."));
 		    }
 		}
 		else
-		    report(stderr, _("Unknown login or authentication error on %s@%s\n"),
+		    report(stderr, GT_("Unknown login or authentication error on %s@%s\n"),
 			   ctl->remotename,
 			   ctl->server.truename);
 		    
@@ -1090,20 +1090,20 @@ is restored."));
 		{
 		    ctl->wehavesentauthnote = 0;
 		    report(stderr,
-			   _("Authorization OK on %s@%s\n"),
+			   GT_("Authorization OK on %s@%s\n"),
 			   ctl->remotename,
 			   ctl->server.truename);
 		    if (!open_warning_by_mail(ctl, (struct msgblk *)NULL))
 		    {
 			stuff_warning(ctl,
-			      _("Subject: fetchmail authentication OK on %s@%s\r\n"),
+			      GT_("Subject: fetchmail authentication OK on %s@%s\r\n"),
 				      ctl->remotename, ctl->server.truename);
 			stuff_warning(ctl,
-			      _("Fetchmail was able to log into %s@%s.\r\n"), 
+			      GT_("Fetchmail was able to log into %s@%s.\r\n"), 
 				      ctl->remotename,
 				      ctl->server.truename);
 			stuff_warning(ctl, 
-				      _("Service has been restored.\r\n"));
+				      GT_("Service has been restored.\r\n"));
 			close_warning_by_mail(ctl, (struct msgblk *)NULL);
 		    
 		    }
@@ -1134,9 +1134,9 @@ is restored."));
 		if (outlevel >= O_DEBUG)
 		{
 		    if (idp->id)
-			report(stdout, _("selecting or re-polling folder %s\n"), idp->id);
+			report(stdout, GT_("selecting or re-polling folder %s\n"), idp->id);
 		    else
-			report(stdout, _("selecting or re-polling default folder\n"));
+			report(stdout, GT_("selecting or re-polling default folder\n"));
 		}
 
 		/* compute # of messages and number of new messages waiting */
@@ -1152,7 +1152,7 @@ is restored."));
 #else
 		    (void) sprintf(buf,
 #endif /* HAVE_SNPRINTF */
-				   _("%s at %s (folder %s)"),
+				   GT_("%s at %s (folder %s)"),
 				   ctl->remotename, ctl->server.truename, idp->id);
 		else
 #ifdef HAVE_SNPRINTF
@@ -1160,33 +1160,33 @@ is restored."));
 #else
 		    (void) sprintf(buf,
 #endif /* HAVE_SNPRINTF */
-			       _("%s at %s"),
+			       GT_("%s at %s"),
 				   ctl->remotename, ctl->server.truename);
 		if (outlevel > O_SILENT)
 		{
 		    if (count == -1)		/* only used for ETRN */
-			report(stdout, _("Polling %s\n"), ctl->server.truename);
+			report(stdout, GT_("Polling %s\n"), ctl->server.truename);
 		    else if (count != 0)
 		    {
 			if (new != -1 && (count - new) > 0)
-			    report_build(stdout, _("%d %s (%d seen) for %s"),
-				  count, count > 1 ? _("messages") :
-				                     _("message"),
+			    report_build(stdout, GT_("%d %s (%d seen) for %s"),
+				  count, count > 1 ? GT_("messages") :
+				                     GT_("message"),
 				  count-new, buf);
 			else
-			    report_build(stdout, _("%d %s for %s"), 
-				  count, count > 1 ? _("messages") :
-				                     _("message"), buf);
+			    report_build(stdout, GT_("%d %s for %s"), 
+				  count, count > 1 ? GT_("messages") :
+				                     GT_("message"), buf);
 			if (bytes == -1)
 			    report_complete(stdout, ".\n");
 			else
-			    report_complete(stdout, _(" (%d octets).\n"), bytes);
+			    report_complete(stdout, GT_(" (%d octets).\n"), bytes);
 		    }
 		    else
 		    {
 			/* these are pointless in normal daemon mode */
 			if (pass == 1 && (run.poll_interval == 0 || outlevel >= O_VERBOSE))
-			    report(stdout, _("No mail for %s\n"), buf); 
+			    report(stdout, GT_("No mail for %s\n"), buf); 
 		    }
 		}
 
@@ -1332,31 +1332,31 @@ is restored."));
     switch (err)
     {
     case PS_SOCKET:
-	msg = _("socket");
+	msg = GT_("socket");
 	break;
     case PS_SYNTAX:
-	msg = _("missing or bad RFC822 header");
+	msg = GT_("missing or bad RFC822 header");
 	break;
     case PS_IOERR:
-	msg = _("MDA");
+	msg = GT_("MDA");
 	break;
     case PS_ERROR:
-	msg = _("client/server synchronization");
+	msg = GT_("client/server synchronization");
 	break;
     case PS_PROTOCOL:
-	msg = _("client/server protocol");
+	msg = GT_("client/server protocol");
 	break;
     case PS_LOCKBUSY:
-	msg = _("lock busy on server");
+	msg = GT_("lock busy on server");
 	break;
     case PS_SMTP:
-	msg = _("SMTP transaction");
+	msg = GT_("SMTP transaction");
 	break;
     case PS_DNS:
-	msg = _("DNS lookup");
+	msg = GT_("DNS lookup");
 	break;
     case PS_UNDEFINED:
-	report(stderr, _("undefined error\n"));
+	report(stderr, GT_("undefined error\n"));
 	break;
     }
     /* no report on PS_MAXFETCH or PS_UNDEFINED or PS_AUTHFAIL */
@@ -1367,9 +1367,9 @@ is restored."));
 	char	*stem;
 
 	if (phase == FORWARDING_WAIT || phase == LISTENER_WAIT)
-	    stem = _("%s error while delivering to SMTP host %s\n");
+	    stem = GT_("%s error while delivering to SMTP host %s\n");
 	else
-	    stem = _("%s error while fetching from %s\n");
+	    stem = GT_("%s error while fetching from %s\n");
 	report(stderr, stem, msg, ctl->server.pollname);
     }
 
@@ -1377,7 +1377,7 @@ closeUp:
     /* execute wrapup command, if any */
     if (ctl->postconnect && (err = system(ctl->postconnect)))
     {
-	report(stderr, _("post-connection command failed with status %d\n"), err);
+	report(stderr, GT_("post-connection command failed with status %d\n"), err);
 	if (err == PS_SUCCESS)
 	    err = PS_SYNTAX;
     }
@@ -1397,7 +1397,7 @@ const struct method *proto;	/* protocol method table */
 #ifndef KERBEROS_V4
     if (ctl->server.authenticate == A_KERBEROS_V4)
     {
-	report(stderr, _("Kerberos V4 support not linked.\n"));
+	report(stderr, GT_("Kerberos V4 support not linked.\n"));
 	return(PS_ERROR);
     }
 #endif /* KERBEROS_V4 */
@@ -1405,7 +1405,7 @@ const struct method *proto;	/* protocol method table */
 #ifndef KERBEROS_V5
     if (ctl->server.authenticate == A_KERBEROS_V5)
     {
-	report(stderr, _("Kerberos V5 support not linked.\n"));
+	report(stderr, GT_("Kerberos V5 support not linked.\n"));
 	return(PS_ERROR);
     }
 #endif /* KERBEROS_V5 */
@@ -1416,13 +1416,13 @@ const struct method *proto;	/* protocol method table */
 	/* check for unsupported options */
 	if (ctl->flush) {
 	    report(stderr,
-		    _("Option --flush is not supported with %s\n"),
+		    GT_("Option --flush is not supported with %s\n"),
 		    proto->name);
 	    return(PS_SYNTAX);
 	}
 	else if (ctl->fetchall) {
 	    report(stderr,
-		    _("Option --all is not supported with %s\n"),
+		    GT_("Option --all is not supported with %s\n"),
 		    proto->name);
 	    return(PS_SYNTAX);
 	}
@@ -1430,7 +1430,7 @@ const struct method *proto;	/* protocol method table */
     if (!proto->getsizes && NUM_SPECIFIED(ctl->limit))
     {
 	report(stderr,
-		_("Option --limit is not supported with %s\n"),
+		GT_("Option --limit is not supported with %s\n"),
 		proto->name);
 	return(PS_SYNTAX);
     }
diff --git a/env.c b/env.c
index 3e9c52c3..f83c0f02 100644
--- a/env.c
+++ b/env.c
@@ -52,7 +52,7 @@ void envquery(int argc, char **argv)
     if (!(pwp = getpwuid(getuid())))
     {
 	fprintf(stderr,
-		_("%s: You don't exist.  Go away.\n"),
+		GT_("%s: You don't exist.  Go away.\n"),
 		program_name);
 	exit(PS_UNDEFINED);
     }
@@ -118,7 +118,7 @@ char *host_fqdn(void)
 
     if (gethostname(tmpbuf, sizeof(tmpbuf)))
     {
-	fprintf(stderr, _("%s: can't determine your host!"),
+	fprintf(stderr, GT_("%s: can't determine your host!"),
 		program_name);
 	exit(PS_DNS);
     }
@@ -134,7 +134,7 @@ char *host_fqdn(void)
 	{
 	    /* exit with error message */
 	    fprintf(stderr,
-		    _("gethostbyname failed for %s\n"), tmpbuf);
+		    GT_("gethostbyname failed for %s\n"), tmpbuf);
 	    exit(PS_DNS);
 	}
 	return(xstrdup(hp->h_name));
diff --git a/etrn.c b/etrn.c
index 38944665..8912513e 100644
--- a/etrn.c
+++ b/etrn.c
@@ -42,13 +42,13 @@ static int etrn_getrange(int sock, struct query *ctl, const char *id,
 
     if ((ok = SMTP_ehlo(sock, fetchmailhost, &opts)))
     {
-	report(stderr, _("%s's SMTP listener does not support ESMTP\n"),
+	report(stderr, GT_("%s's SMTP listener does not support ESMTP\n"),
 	      ctl->server.pollname);
 	return(ok);
     }
     else if (!(opts & ESMTP_ETRN))
     {
-	report(stderr, _("%s's SMTP listener does not support ETRN\n"),
+	report(stderr, GT_("%s's SMTP listener does not support ETRN\n"),
 	      ctl->server.pollname);
 	return(PS_PROTOCOL);
     }
@@ -72,38 +72,38 @@ static int etrn_getrange(int sock, struct query *ctl, const char *id,
 	{
 	case 250:	/* OK, queuing for node <x> started */
 	    if (outlevel >= O_SILENT)
-		report(stdout, _("Queuing for %s started\n"), qnp->id);
+		report(stdout, GT_("Queuing for %s started\n"), qnp->id);
 	    break;
 
 	case 251:	/* OK, no messages waiting for node <x> */
 	    if (outlevel >= O_SILENT)
-		report(stdout, _("No messages waiting for %s\n"), qnp->id);
+		report(stdout, GT_("No messages waiting for %s\n"), qnp->id);
 	    return(PS_NOMAIL);
 
 	case 252:	/* OK, pending messages for node <x> started */
 	case 253:	/* OK, <n> pending messages for node <x> started */
 	    if (outlevel >= O_SILENT)
-		report(stdout, _("Pending messages for %s started\n"), qnp->id);
+		report(stdout, GT_("Pending messages for %s started\n"), qnp->id);
 	    break;
 
 	case 458:	/* Unable to queue messages for node <x> */
-	    report(stderr, _("Unable to queue messages for node %s\n"),qnp->id);
+	    report(stderr, GT_("Unable to queue messages for node %s\n"),qnp->id);
 	    return(PS_PROTOCOL);
 
 	case 459:	/* Node <x> not allowed: <reason> */
-	    report(stderr, _("Node %s not allowed: %s\n"), qnp->id, buf);
+	    report(stderr, GT_("Node %s not allowed: %s\n"), qnp->id, buf);
 	    return(PS_AUTHFAIL);
 
 	case 500:	/* Syntax Error */
-	    report(stderr, _("ETRN syntax error\n"));
+	    report(stderr, GT_("ETRN syntax error\n"));
 	    return(PS_PROTOCOL);
 
 	case 501:	/* Syntax Error in Parameters */
-	    report(stderr, _("ETRN syntax error in parameters\n"));
+	    report(stderr, GT_("ETRN syntax error in parameters\n"));
 	    return(PS_PROTOCOL);
 
 	default:
-	    report(stderr, _("Unknown ETRN error %d\n"), atoi(buf));
+	    report(stderr, GT_("Unknown ETRN error %d\n"), atoi(buf));
 	    return(PS_PROTOCOL);
 	}
     }
@@ -148,19 +148,19 @@ int doETRN (struct query *ctl)
     int status;
 
     if (ctl->keep) {
-	fprintf(stderr, _("Option --keep is not supported with ETRN\n"));
+	fprintf(stderr, GT_("Option --keep is not supported with ETRN\n"));
 	return(PS_SYNTAX);
     }
     if (ctl->flush) {
-	fprintf(stderr, _("Option --flush is not supported with ETRN\n"));
+	fprintf(stderr, GT_("Option --flush is not supported with ETRN\n"));
 	return(PS_SYNTAX);
     }
     if (ctl->mailboxes->id) {
-	fprintf(stderr, _("Option --remote is not supported with ETRN\n"));
+	fprintf(stderr, GT_("Option --remote is not supported with ETRN\n"));
 	return(PS_SYNTAX);
     }
     if (check_only) {
-	fprintf(stderr, _("Option --check is not supported with ETRN\n"));
+	fprintf(stderr, GT_("Option --check is not supported with ETRN\n"));
 	return(PS_SYNTAX);
     }
     peek_capable = FALSE;
diff --git a/fetchmail.c b/fetchmail.c
index 12ce98da..5cd7bc5e 100644
--- a/fetchmail.c
+++ b/fetchmail.c
@@ -158,7 +158,7 @@ int main(int argc, char **argv)
     {
 	int i;
 
-	report(stdout, _("fetchmail: invoked with"));
+	report(stdout, GT_("fetchmail: invoked with"));
 	for (i = 0; i < argc; i++)
 	    report(stdout, " %s", argv[i]);
 	report(stdout, "\n");
@@ -187,7 +187,7 @@ int main(int argc, char **argv)
 
     if (versioninfo)
     {
-	printf(_("This is fetchmail release %s"), VERSION);
+	printf(GT_("This is fetchmail release %s"), VERSION);
 #ifdef POP2_ENABLE
 	printf("+POP2");
 #endif /* POP2_ENABLE */
@@ -324,13 +324,13 @@ int main(int argc, char **argv)
     {
 	int havercfile = access(rcfile, 0);
 
-	printf(_("Taking options from command line%s%s\n"),
-				havercfile ? "" :  _(" and "),
+	printf(GT_("Taking options from command line%s%s\n"),
+				havercfile ? "" :  GT_(" and "),
 				havercfile ? "" : rcfile);
 
 	if (querylist == NULL)
 	    fprintf(stderr,
-		    _("No mailservers set up -- perhaps %s is missing?\n"),
+		    GT_("No mailservers set up -- perhaps %s is missing?\n"),
 		    rcfile);
 	else
 	    dump_params(&run, querylist, implicitmode);
@@ -351,7 +351,7 @@ int main(int argc, char **argv)
 
     /* if no mail servers listed and nothing in background, we're done */
     if (!(quitmode && argc == 2) && pid == 0 && querylist == NULL) {
-	(void)fputs(_("fetchmail: no mailservers have been specified.\n"),stderr);
+	(void)fputs(GT_("fetchmail: no mailservers have been specified.\n"),stderr);
 	exit(PS_SYNTAX);
     }
 
@@ -360,20 +360,20 @@ int main(int argc, char **argv)
     {
 	if (pid == 0) 
 	{
-	    fprintf(stderr,_("fetchmail: no other fetchmail is running\n"));
+	    fprintf(stderr,GT_("fetchmail: no other fetchmail is running\n"));
 	    if (argc == 2)
 		exit(PS_EXCLUDE);
 	}
 	else if (kill(pid, SIGTERM) < 0)
 	{
-	    fprintf(stderr,_("fetchmail: error killing %s fetchmail at %d; bailing out.\n"),
-		    bkgd ? _("background") : _("foreground"), pid);
+	    fprintf(stderr,GT_("fetchmail: error killing %s fetchmail at %d; bailing out.\n"),
+		    bkgd ? GT_("background") : GT_("foreground"), pid);
 	    exit(PS_EXCLUDE);
 	}
 	else
 	{
-	    fprintf(stderr,_("fetchmail: %s fetchmail at %d killed.\n"),
-		    bkgd ? _("background") : _("foreground"), pid);
+	    fprintf(stderr,GT_("fetchmail: %s fetchmail at %d killed.\n"),
+		    bkgd ? GT_("background") : GT_("foreground"), pid);
 	    lock_release();
 	    if (argc == 2)
 		exit(0);
@@ -388,20 +388,20 @@ int main(int argc, char **argv)
 	if (check_only)
 	{
 	    fprintf(stderr,
-		 _("fetchmail: can't check mail while another fetchmail to same host is running.\n"));
+		 GT_("fetchmail: can't check mail while another fetchmail to same host is running.\n"));
 	    return(PS_EXCLUDE);
         }
 	else if (!implicitmode)
 	{
 	    fprintf(stderr,
-		 _("fetchmail: can't poll specified hosts with another fetchmail running at %d.\n"),
+		 GT_("fetchmail: can't poll specified hosts with another fetchmail running at %d.\n"),
 		 pid);
 		return(PS_EXCLUDE);
 	}
 	else if (!bkgd)
 	{
 	    fprintf(stderr,
-		 _("fetchmail: another foreground fetchmail is running at %d.\n"),
+		 GT_("fetchmail: another foreground fetchmail is running at %d.\n"),
 		 pid);
 		return(PS_EXCLUDE);
 	}
@@ -413,14 +413,14 @@ int main(int argc, char **argv)
 	    else
 	    {
 		fprintf(stderr,
-			_("fetchmail: can't accept options while a background fetchmail is running.\n"));
+			GT_("fetchmail: can't accept options while a background fetchmail is running.\n"));
 		return(PS_EXCLUDE);
 	    }
 	}
 	else if (kill(pid, SIGUSR1) == 0)
 	{
 	    fprintf(stderr,
-		    _("fetchmail: background fetchmail at %d awakened.\n"),
+		    GT_("fetchmail: background fetchmail at %d awakened.\n"),
 		    pid);
 	    return(0);
 	}
@@ -432,7 +432,7 @@ int main(int argc, char **argv)
 	     * SIGUSR1/SIGHUP transmission.
 	     */
 	    fprintf(stderr,
-		    _("fetchmail: elder sibling at %d died mysteriously.\n"),
+		    GT_("fetchmail: elder sibling at %d died mysteriously.\n"),
 		    pid);
 	    return(PS_UNDEFINED);
 	}
@@ -447,13 +447,13 @@ int main(int argc, char **argv)
 	    if (!isatty(0))
 	    {
 		fprintf(stderr,
-			_("fetchmail: can't find a password for %s@%s.\n"),
+			GT_("fetchmail: can't find a password for %s@%s.\n"),
 			ctl->remotename, ctl->server.pollname);
 		return(PS_AUTHFAIL);
 	    }
 	    else
 	    {
-		char* password_prompt = _("Enter password for %s@%s: ");
+		char* password_prompt = GT_("Enter password for %s@%s: ");
 
 		xalloca(tmpbuf, char *, strlen(password_prompt) +
 			strlen(ctl->remotename) +
@@ -483,7 +483,7 @@ int main(int argc, char **argv)
 	    deal_with_sigchld();
 	else
 	    daemonize(run.logfile, terminate_run);
-	report(stdout, _("starting fetchmail %s daemon \n"), VERSION);
+	report(stdout, GT_("starting fetchmail %s daemon \n"), VERSION);
 
 	/*
 	 * We'll set up a handler for these when we're sleeping,
@@ -537,12 +537,12 @@ int main(int argc, char **argv)
 	{
 	    if (errno != ENOENT)
 		report(stderr, 
-		       _("couldn't time-check %s (error %d)\n"),
+		       GT_("couldn't time-check %s (error %d)\n"),
 		       rcfile, errno);
 	}
 	else if (rcstat.st_mtime > parsetime)
 	{
-	    report(stdout, _("restarting fetchmail (%s changed)\n"), rcfile);
+	    report(stdout, GT_("restarting fetchmail (%s changed)\n"), rcfile);
 	    /*
 	     * Matthias Andree: Isn't this prone to introduction of
 	     * "false" programs by interfering with PATH? Those
@@ -567,7 +567,7 @@ int main(int argc, char **argv)
 	     * correctly, Linux saves it but many other Unices don't.)
 	     */
 	    execvp(argv[0], argv);
-	    report(stderr, _("attempt to re-exec fetchmail failed\n"));
+	    report(stderr, GT_("attempt to re-exec fetchmail failed\n"));
 	}
 
 #if defined(HAVE_RES_SEARCH) && defined(USE_TCPIP_FOR_DNS)
@@ -595,7 +595,7 @@ int main(int argc, char **argv)
 		    if (ctl->wedged)
 		    {
 			report(stderr, 
-			       _("poll of %s skipped (failed authentication or too many timeouts)\n"),
+			       GT_("poll of %s skipped (failed authentication or too many timeouts)\n"),
 			       ctl->server.pollname);
 			continue;
 		    }
@@ -607,7 +607,7 @@ int main(int argc, char **argv)
 			{
 			    if (outlevel >= O_VERBOSE)
 				report(stdout,
-				       _("interval not reached, not querying %s\n"),
+				       GT_("interval not reached, not querying %s\n"),
 				       ctl->server.pollname);
 			    continue;
 			}
@@ -638,35 +638,35 @@ int main(int argc, char **argv)
 			switch(querystatus)
 			{
 			case PS_SUCCESS:
-			    report(stdout,_("Query status=0 (SUCCESS)\n"));break;
+			    report(stdout,GT_("Query status=0 (SUCCESS)\n"));break;
 			case PS_NOMAIL: 
-			    report(stdout,_("Query status=1 (NOMAIL)\n")); break;
+			    report(stdout,GT_("Query status=1 (NOMAIL)\n")); break;
 			case PS_SOCKET:
-			    report(stdout,_("Query status=2 (SOCKET)\n")); break;
+			    report(stdout,GT_("Query status=2 (SOCKET)\n")); break;
 			case PS_AUTHFAIL:
-			    report(stdout,_("Query status=3 (AUTHFAIL)\n"));break;
+			    report(stdout,GT_("Query status=3 (AUTHFAIL)\n"));break;
 			case PS_PROTOCOL:
-			    report(stdout,_("Query status=4 (PROTOCOL)\n"));break;
+			    report(stdout,GT_("Query status=4 (PROTOCOL)\n"));break;
 			case PS_SYNTAX:
-			    report(stdout,_("Query status=5 (SYNTAX)\n")); break;
+			    report(stdout,GT_("Query status=5 (SYNTAX)\n")); break;
 			case PS_IOERR:
-			    report(stdout,_("Query status=6 (IOERR)\n"));  break;
+			    report(stdout,GT_("Query status=6 (IOERR)\n"));  break;
 			case PS_ERROR:
-			    report(stdout,_("Query status=7 (ERROR)\n"));  break;
+			    report(stdout,GT_("Query status=7 (ERROR)\n"));  break;
 			case PS_EXCLUDE:
-			    report(stdout,_("Query status=8 (EXCLUDE)\n")); break;
+			    report(stdout,GT_("Query status=8 (EXCLUDE)\n")); break;
 			case PS_LOCKBUSY:
-			    report(stdout,_("Query status=9 (LOCKBUSY)\n"));break;
+			    report(stdout,GT_("Query status=9 (LOCKBUSY)\n"));break;
 			case PS_SMTP:
-			    report(stdout,_("Query status=10 (SMTP)\n")); break;
+			    report(stdout,GT_("Query status=10 (SMTP)\n")); break;
 			case PS_DNS:
-			    report(stdout,_("Query status=11 (DNS)\n")); break;
+			    report(stdout,GT_("Query status=11 (DNS)\n")); break;
 			case PS_BSMTP:
-			    report(stdout,_("Query status=12 (BSMTP)\n")); break;
+			    report(stdout,GT_("Query status=12 (BSMTP)\n")); break;
 			case PS_MAXFETCH:
-			    report(stdout,_("Query status=13 (MAXFETCH)\n"));break;
+			    report(stdout,GT_("Query status=13 (MAXFETCH)\n"));break;
 			default:
-			    report(stdout,_("Query status=%d\n"),querystatus);
+			    report(stdout,GT_("Query status=%d\n"),querystatus);
 			    break;
 			}
 
@@ -712,14 +712,14 @@ int main(int argc, char **argv)
 			unwedged++;
 	    if (!unwedged)
 	    {
-		report(stderr, _("All connections are wedged.  Exiting.\n"));
+		report(stderr, GT_("All connections are wedged.  Exiting.\n"));
 		/* FIXME: someday, send notification mail */
 		exit(PS_AUTHFAIL);
 	    }
 
 	    if (outlevel >= O_VERBOSE)
 		report(stdout, 
-		       _("fetchmail: sleeping at %s\n"), timestamp());
+		       GT_("fetchmail: sleeping at %s\n"), timestamp());
 
 	    /*
 	     * OK, now pause until it's time for the next poll cycle.
@@ -731,23 +731,23 @@ int main(int argc, char **argv)
 	    {
 #ifdef SYS_SIGLIST_DECLARED
 		report(stdout, 
-		       _("awakened by %s\n"), sys_siglist[lastsig]);
+		       GT_("awakened by %s\n"), sys_siglist[lastsig]);
 #else
 		report(stdout, 
-		       _("awakened by signal %d\n"), lastsig);
+		       GT_("awakened by signal %d\n"), lastsig);
 #endif
 		for (ctl = querylist; ctl; ctl = ctl->next)
 		    ctl->wedged = FALSE;
 	    }
 
 	    if (outlevel >= O_VERBOSE)
-		report(stdout, _("awakened at %s\n"), timestamp());
+		report(stdout, GT_("awakened at %s\n"), timestamp());
 	}
     } while
 	(run.poll_interval);
 
     if (outlevel >= O_VERBOSE)
-	report(stdout, _("normal termination, status %d\n"),
+	report(stdout, GT_("normal termination, status %d\n"),
 		successes ? PS_SUCCESS : querystatus);
 
     terminate_run(0);
@@ -890,7 +890,7 @@ static int load_params(int argc, char **argv, int optind)
     if (stat(rcfile, &rcstat) != -1)
 	parsetime = rcstat.st_mtime;
     else if (errno != ENOENT)
-	report(stderr, _("couldn't time-check the run-control file\n"));
+	report(stderr, GT_("couldn't time-check the run-control file\n"));
 
     /* this builds the host list */
     if ((st = prc_parse_file(rcfile, !versioninfo)) != 0)
@@ -923,7 +923,7 @@ static int load_params(int argc, char **argv, int optind)
 		{
 		    /* Is this correct? */
 		    if (predeclared && outlevel == O_VERBOSE)
-			fprintf(stderr,_("Warning: multiple mentions of host %s in config file\n"),argv[optind]);
+			fprintf(stderr,GT_("Warning: multiple mentions of host %s in config file\n"),argv[optind]);
 		    ctl->active = TRUE;
 		    predeclared = TRUE;
 		}
@@ -1048,7 +1048,7 @@ static int load_params(int argc, char **argv, int optind)
 	    DEFAULT(ctl->server.checkalias, FALSE);
 	    if (ctl->use_ssl) 
 	    {
-		report(stderr, _("SSL support is not compiled in.\n"));
+		report(stderr, GT_("SSL support is not compiled in.\n"));
 		exit(PS_SYNTAX);
 	    }
 #undef DEFAULT
@@ -1078,7 +1078,7 @@ static int load_params(int argc, char **argv, int optind)
 	    if (ctl->localnames && ctl->localnames->next && ctl->server.dns)
 	    {
 		ctl->server.dns = FALSE;
-		report(stderr, _("fetchmail: warning: no DNS available to check multidrop fetches from %s\n"), ctl->server.pollname);
+		report(stderr, GT_("fetchmail: warning: no DNS available to check multidrop fetches from %s\n"), ctl->server.pollname);
 	    }
 #endif /* !HAVE_GETHOSTBYNAME || !HAVE_RES_SEARCH */
 
@@ -1101,7 +1101,7 @@ static int load_params(int argc, char **argv, int optind)
 		     ctl->server.via = xstrdup(hes_p->po_host);
 		} else {
 		     report(stderr,
-			    _("couldn't find HESIOD pobox for %s\n"),
+			    GT_("couldn't find HESIOD pobox for %s\n"),
 			    ctl->remotename);
 		}
 	    }
@@ -1127,14 +1127,14 @@ static int load_params(int argc, char **argv, int optind)
 	    if (ctl->server.port < 0)
 	    {
 		(void) fprintf(stderr,
-			       _("%s configuration invalid, port number cannot be negative\n"),
+			       GT_("%s configuration invalid, port number cannot be negative\n"),
 			       ctl->server.pollname);
 		exit(PS_SYNTAX);
 	    }
 	    if (ctl->server.protocol == P_RPOP && ctl->server.port >= 1024)
 	    {
 		(void) fprintf(stderr,
-			       _("%s configuration invalid, RPOP requires a privileged port\n"),
+			       GT_("%s configuration invalid, RPOP requires a privileged port\n"),
 			       ctl->server.pollname);
 		exit(PS_SYNTAX);
 	    }
@@ -1150,7 +1150,7 @@ static int load_params(int argc, char **argv, int optind)
 				(atoi(++cp) == SMTP_PORT))
 		    {
 			(void) fprintf(stderr,
-				       _("%s configuration invalid, LMTP can't use default SMTP port\n"),
+				       GT_("%s configuration invalid, LMTP can't use default SMTP port\n"),
 				       ctl->server.pollname);
 			exit(PS_SYNTAX);
 		    }
@@ -1165,7 +1165,7 @@ static int load_params(int argc, char **argv, int optind)
 	    if (ctl->fetchall && ctl->keep && run.poll_interval && !nodetach)
 	    {
 		(void) fprintf(stderr,
-			       _("Both fetchall and keep on in daemon mode is a mistake!\n"));
+			       GT_("Both fetchall and keep on in daemon mode is a mistake!\n"));
 		exit(PS_SYNTAX);
 	    }
 	}
@@ -1215,7 +1215,7 @@ static void terminate_poll(int sig)
      */
 
     if (sig != 0)
-        report(stdout, _("terminated with signal %d\n"), sig);
+        report(stdout, GT_("terminated with signal %d\n"), sig);
     else
     {
 	struct query *ctl;
@@ -1303,7 +1303,7 @@ static int query_host(struct query *ctl)
      */
     if (outlevel >= O_VERBOSE || (run.logfile && outlevel > O_SILENT))
     {
-	report(stdout, _("%s querying %s (protocol %s) at %s: poll started\n"),
+	report(stdout, GT_("%s querying %s (protocol %s) at %s: poll started\n"),
 	       VERSION,
 	       ctl->server.pollname,
 	       showproto(ctl->server.protocol),
@@ -1324,7 +1324,7 @@ static int query_host(struct query *ctl)
 #ifdef POP2_ENABLE
 	st = doPOP2(ctl);
 #else
-	report(stderr, _("POP2 support is not configured.\n"));
+	report(stderr, GT_("POP2 support is not configured.\n"));
 	st = PS_PROTOCOL;
 #endif /* POP2_ENABLE */
 	break;
@@ -1334,7 +1334,7 @@ static int query_host(struct query *ctl)
 #ifdef POP3_ENABLE
 	st = doPOP3(ctl);
 #else
-	report(stderr, _("POP3 support is not configured.\n"));
+	report(stderr, GT_("POP3 support is not configured.\n"));
 	st = PS_PROTOCOL;
 #endif /* POP3_ENABLE */
 	break;
@@ -1342,35 +1342,35 @@ static int query_host(struct query *ctl)
 #ifdef IMAP_ENABLE
 	st = doIMAP(ctl);
 #else
-	report(stderr, _("IMAP support is not configured.\n"));
+	report(stderr, GT_("IMAP support is not configured.\n"));
 	st = PS_PROTOCOL;
 #endif /* IMAP_ENABLE */
     case P_ETRN:
 #ifndef ETRN_ENABLE
-	report(stderr, _("ETRN support is not configured.\n"));
+	report(stderr, GT_("ETRN support is not configured.\n"));
 	st = PS_PROTOCOL;
 #else
 #ifdef HAVE_GETHOSTBYNAME
 	st = doETRN(ctl);
 #else
-	report(stderr, _("Cannot support ETRN without gethostbyname(2).\n"));
+	report(stderr, GT_("Cannot support ETRN without gethostbyname(2).\n"));
 	st = PS_PROTOCOL;
 #endif /* HAVE_GETHOSTBYNAME */
 #endif /* ETRN_ENABLE */
     case P_ODMR:
 #ifndef ODMR_ENABLE
-	report(stderr, _("ODMR support is not configured.\n"));
+	report(stderr, GT_("ODMR support is not configured.\n"));
 	st = PS_PROTOCOL;
 #else
 #ifdef HAVE_GETHOSTBYNAME
 	st = doODMR(ctl);
 #else
-	report(stderr, _("Cannot support ODMR without gethostbyname(2).\n"));
+	report(stderr, GT_("Cannot support ODMR without gethostbyname(2).\n"));
 	st = PS_PROTOCOL;
 #endif /* HAVE_GETHOSTBYNAME */
 #endif /* ODMR_ENABLE */
     default:
-	report(stderr, _("unsupported protocol selected.\n"));
+	report(stderr, GT_("unsupported protocol selected.\n"));
 	st = PS_PROTOCOL;
     }
 
@@ -1380,7 +1380,7 @@ static int query_host(struct query *ctl)
      */
     if (outlevel >= O_VERBOSE || (run.logfile && outlevel > O_SILENT))
     {
-	report(stdout, _("%s querying %s (protocol %s) at %s: poll completed\n"),
+	report(stdout, GT_("%s querying %s (protocol %s) at %s: poll completed\n"),
 	       VERSION,
 	       ctl->server.pollname,
 	       showproto(ctl->server.protocol),
@@ -1397,61 +1397,61 @@ static void dump_params (struct runctl *runp,
     struct query *ctl;
 
     if (runp->poll_interval)
-	printf(_("Poll interval is %d seconds\n"), runp->poll_interval);
+	printf(GT_("Poll interval is %d seconds\n"), runp->poll_interval);
     if (runp->logfile)
-	printf(_("Logfile is %s\n"), runp->logfile);
+	printf(GT_("Logfile is %s\n"), runp->logfile);
     if (strcmp(runp->idfile, IDFILE_NAME))
-	printf(_("Idfile is %s\n"), runp->idfile);
+	printf(GT_("Idfile is %s\n"), runp->idfile);
 #if defined(HAVE_SYSLOG)
     if (runp->use_syslog)
-	printf(_("Progress messages will be logged via syslog\n"));
+	printf(GT_("Progress messages will be logged via syslog\n"));
 #endif
     if (runp->invisible)
-	printf(_("Fetchmail will masquerade and will not generate Received\n"));
+	printf(GT_("Fetchmail will masquerade and will not generate Received\n"));
     if (runp->showdots)
-	printf(_("Fetchmail will show progress dots even in logfiles.\n"));
+	printf(GT_("Fetchmail will show progress dots even in logfiles.\n"));
     if (runp->postmaster)
-	printf(_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
+	printf(GT_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
 	       runp->postmaster);
 
     if (!runp->bouncemail)
-	printf(_("Fetchmail will direct error mail to the postmaster.\n"));
+	printf(GT_("Fetchmail will direct error mail to the postmaster.\n"));
     else if (outlevel >= O_VERBOSE)
-	printf(_("Fetchmail will direct error mail to the sender.\n"));
+	printf(GT_("Fetchmail will direct error mail to the sender.\n"));
 
     for (ctl = querylist; ctl; ctl = ctl->next)
     {
 	if (!ctl->active || (implicit && ctl->server.skip))
 	    continue;
 
-	printf(_("Options for retrieving from %s@%s:\n"),
+	printf(GT_("Options for retrieving from %s@%s:\n"),
 	       ctl->remotename, visbuf(ctl->server.pollname));
 
 	if (ctl->server.via && MAILBOX_PROTOCOL(ctl))
-	    printf(_("  Mail will be retrieved via %s\n"), ctl->server.via);
+	    printf(GT_("  Mail will be retrieved via %s\n"), ctl->server.via);
 
 	if (ctl->server.interval)
-	    printf(_("  Poll of this server will occur every %d intervals.\n"),
+	    printf(GT_("  Poll of this server will occur every %d intervals.\n"),
 		   ctl->server.interval);
 	if (ctl->server.truename)
-	    printf(_("  True name of server is %s.\n"), ctl->server.truename);
+	    printf(GT_("  True name of server is %s.\n"), ctl->server.truename);
 	if (ctl->server.skip || outlevel >= O_VERBOSE)
-	    printf(_("  This host %s be queried when no host is specified.\n"),
-		   ctl->server.skip ? _("will not") : _("will"));
+	    printf(GT_("  This host %s be queried when no host is specified.\n"),
+		   ctl->server.skip ? GT_("will not") : GT_("will"));
 	if (!NO_PASSWORD(ctl))
 	{
 	    if (!ctl->password)
-		printf(_("  Password will be prompted for.\n"));
+		printf(GT_("  Password will be prompted for.\n"));
 	    else if (outlevel >= O_VERBOSE)
 	    {
 		if (ctl->server.protocol == P_APOP)
-		    printf(_("  APOP secret = \"%s\".\n"),
+		    printf(GT_("  APOP secret = \"%s\".\n"),
 			   visbuf(ctl->password));
 		else if (ctl->server.protocol == P_RPOP)
-		    printf(_("  RPOP id = \"%s\".\n"),
+		    printf(GT_("  RPOP id = \"%s\".\n"),
 			   visbuf(ctl->password));
 		else
-		    printf(_("  Password = \"%s\".\n"),
+		    printf(GT_("  Password = \"%s\".\n"),
 							visbuf(ctl->password));
 	    }
 	}
@@ -1464,189 +1464,189 @@ static void dump_params (struct runctl *runp,
 #endif /* INET6_ENABLE */
 	    && (ctl->server.authenticate == A_KERBEROS_V4 ||
 		ctl->server.authenticate == A_KERBEROS_V5))
-	    printf(_("  Protocol is KPOP with Kerberos %s authentication"),
+	    printf(GT_("  Protocol is KPOP with Kerberos %s authentication"),
 		   ctl->server.authenticate == A_KERBEROS_V5 ? "V" : "IV");
 	else
-	    printf(_("  Protocol is %s"), showproto(ctl->server.protocol));
+	    printf(GT_("  Protocol is %s"), showproto(ctl->server.protocol));
 #if INET6_ENABLE
 	if (ctl->server.service)
-	    printf(_(" (using service %s)"), ctl->server.service);
+	    printf(GT_(" (using service %s)"), ctl->server.service);
 	if (ctl->server.netsec)
-	    printf(_(" (using network security options %s)"), ctl->server.netsec);
+	    printf(GT_(" (using network security options %s)"), ctl->server.netsec);
 #else /* INET6_ENABLE */
 	if (ctl->server.port)
-	    printf(_(" (using port %d)"), ctl->server.port);
+	    printf(GT_(" (using port %d)"), ctl->server.port);
 #endif /* INET6_ENABLE */
 	else if (outlevel >= O_VERBOSE)
-	    printf(_(" (using default port)"));
+	    printf(GT_(" (using default port)"));
 	if (ctl->server.uidl && MAILBOX_PROTOCOL(ctl))
-	    printf(_(" (forcing UIDL use)"));
+	    printf(GT_(" (forcing UIDL use)"));
 	putchar('.');
 	putchar('\n');
 	switch (ctl->server.authenticate)
 	{
 	case A_ANY:
-	    printf(_("  All available authentication methods will be tried.\n"));
+	    printf(GT_("  All available authentication methods will be tried.\n"));
 	    break;
 	case A_PASSWORD:
-	    printf(_("  Password authentication will be forced.\n"));
+	    printf(GT_("  Password authentication will be forced.\n"));
 	    break;
 	case A_NTLM:
-	    printf(_("  NTLM authentication will be forced.\n"));
+	    printf(GT_("  NTLM authentication will be forced.\n"));
 	    break;
 	case A_OTP:
-	    printf(_("  OTP authentication will be forced.\n"));
+	    printf(GT_("  OTP authentication will be forced.\n"));
 	    break;
 	case A_CRAM_MD5:
-	    printf(_("  CRAM-Md5 authentication will be forced.\n"));
+	    printf(GT_("  CRAM-Md5 authentication will be forced.\n"));
 	    break;
 	case A_GSSAPI:
-	    printf(_("  GSSAPI authentication will be forced.\n"));
+	    printf(GT_("  GSSAPI authentication will be forced.\n"));
 	    break;
 	case A_KERBEROS_V4:
-	    printf(_("  Kerberos V4 authentication will be forced.\n"));
+	    printf(GT_("  Kerberos V4 authentication will be forced.\n"));
 	    break;
 	case A_KERBEROS_V5:
-	    printf(_("  Kerberos V5 authentication will be forced.\n"));
+	    printf(GT_("  Kerberos V5 authentication will be forced.\n"));
 	    break;
 	case A_SSH:
-	    printf(_("  End-to-end encryption assumed.\n"));
+	    printf(GT_("  End-to-end encryption assumed.\n"));
 	    break;
 	}
 	if (ctl->server.principal != (char *) NULL)
-	    printf(_("  Mail service principal is: %s\n"), ctl->server.principal);
+	    printf(GT_("  Mail service principal is: %s\n"), ctl->server.principal);
 #ifdef	SSL_ENABLE
 	if (ctl->use_ssl)
-	    printf(_("  SSL encrypted sessions enabled.\n"));
+	    printf(GT_("  SSL encrypted sessions enabled.\n"));
 	if (ctl->sslcertck) {
-	    printf(_("  SSL server certificate checking enabled.\n"));
+	    printf(GT_("  SSL server certificate checking enabled.\n"));
 	    if (ctl->sslcertpath != NULL)
-		printf(_("  SSL trusted certificate directory: %s\n"), ctl->sslcertpath);
+		printf(GT_("  SSL trusted certificate directory: %s\n"), ctl->sslcertpath);
 	}
 	if (ctl->sslfingerprint != NULL)
-		printf(_("  SSL key fingerprint (checked against the server key): %s\n"), ctl->sslfingerprint);
+		printf(GT_("  SSL key fingerprint (checked against the server key): %s\n"), ctl->sslfingerprint);
 #endif
 	if (ctl->server.timeout > 0)
-	    printf(_("  Server nonresponse timeout is %d seconds"), ctl->server.timeout);
+	    printf(GT_("  Server nonresponse timeout is %d seconds"), ctl->server.timeout);
 	if (ctl->server.timeout ==  CLIENT_TIMEOUT)
-	    printf(_(" (default).\n"));
+	    printf(GT_(" (default).\n"));
 	else
 	    printf(".\n");
 
 	if (MAILBOX_PROTOCOL(ctl)) 
 	{
 	    if (!ctl->mailboxes->id)
-		printf(_("  Default mailbox selected.\n"));
+		printf(GT_("  Default mailbox selected.\n"));
 	    else
 	    {
 		struct idlist *idp;
 
-		printf(_("  Selected mailboxes are:"));
+		printf(GT_("  Selected mailboxes are:"));
 		for (idp = ctl->mailboxes; idp; idp = idp->next)
 		    printf(" %s", idp->id);
 		printf("\n");
 	    }
-	    printf(_("  %s messages will be retrieved (--all %s).\n"),
-		   ctl->fetchall ? _("All") : _("Only new"),
+	    printf(GT_("  %s messages will be retrieved (--all %s).\n"),
+		   ctl->fetchall ? GT_("All") : GT_("Only new"),
 		   ctl->fetchall ? "on" : "off");
-	    printf(_("  Fetched messages %s be kept on the server (--keep %s).\n"),
-		   ctl->keep ? _("will") : _("will not"),
+	    printf(GT_("  Fetched messages %s be kept on the server (--keep %s).\n"),
+		   ctl->keep ? GT_("will") : GT_("will not"),
 		   ctl->keep ? "on" : "off");
-	    printf(_("  Old messages %s be flushed before message retrieval (--flush %s).\n"),
-		   ctl->flush ? _("will") : _("will not"),
+	    printf(GT_("  Old messages %s be flushed before message retrieval (--flush %s).\n"),
+		   ctl->flush ? GT_("will") : GT_("will not"),
 		   ctl->flush ? "on" : "off");
-	    printf(_("  Rewrite of server-local addresses is %s (--norewrite %s).\n"),
-		   ctl->rewrite ? _("enabled") : _("disabled"),
+	    printf(GT_("  Rewrite of server-local addresses is %s (--norewrite %s).\n"),
+		   ctl->rewrite ? GT_("enabled") : GT_("disabled"),
 		   ctl->rewrite ? "off" : "on");
-	    printf(_("  Carriage-return stripping is %s (stripcr %s).\n"),
-		   ctl->stripcr ? _("enabled") : _("disabled"),
+	    printf(GT_("  Carriage-return stripping is %s (stripcr %s).\n"),
+		   ctl->stripcr ? GT_("enabled") : GT_("disabled"),
 		   ctl->stripcr ? "on" : "off");
-	    printf(_("  Carriage-return forcing is %s (forcecr %s).\n"),
-		   ctl->forcecr ? _("enabled") : _("disabled"),
+	    printf(GT_("  Carriage-return forcing is %s (forcecr %s).\n"),
+		   ctl->forcecr ? GT_("enabled") : GT_("disabled"),
 		   ctl->forcecr ? "on" : "off");
-	    printf(_("  Interpretation of Content-Transfer-Encoding is %s (pass8bits %s).\n"),
-		   ctl->pass8bits ? _("disabled") : _("enabled"),
+	    printf(GT_("  Interpretation of Content-Transfer-Encoding is %s (pass8bits %s).\n"),
+		   ctl->pass8bits ? GT_("disabled") : GT_("enabled"),
 		   ctl->pass8bits ? "on" : "off");
-	    printf(_("  MIME decoding is %s (mimedecode %s).\n"),
-		   ctl->mimedecode ? _("enabled") : _("disabled"),
+	    printf(GT_("  MIME decoding is %s (mimedecode %s).\n"),
+		   ctl->mimedecode ? GT_("enabled") : GT_("disabled"),
 		   ctl->mimedecode ? "on" : "off");
-	    printf(_("  Idle after poll is %s (idle %s).\n"),
-		   ctl->idle ? _("enabled") : _("disabled"),
+	    printf(GT_("  Idle after poll is %s (idle %s).\n"),
+		   ctl->idle ? GT_("enabled") : GT_("disabled"),
 		   ctl->idle ? "on" : "off");
-	    printf(_("  Nonempty Status lines will be %s (dropstatus %s)\n"),
-		   ctl->dropstatus ? _("discarded") : _("kept"),
+	    printf(GT_("  Nonempty Status lines will be %s (dropstatus %s)\n"),
+		   ctl->dropstatus ? GT_("discarded") : GT_("kept"),
 		   ctl->dropstatus ? "on" : "off");
-	    printf(_("  Delivered-To lines will be %s (dropdelivered %s)\n"),
-		   ctl->dropdelivered ? _("discarded") : _("kept"),
+	    printf(GT_("  Delivered-To lines will be %s (dropdelivered %s)\n"),
+		   ctl->dropdelivered ? GT_("discarded") : GT_("kept"),
 		   ctl->dropdelivered ? "on" : "off");
 	    if (NUM_NONZERO(ctl->limit))
 	    {
 		if (NUM_NONZERO(ctl->limit))
-		    printf(_("  Message size limit is %d octets (--limit %d).\n"), 
+		    printf(GT_("  Message size limit is %d octets (--limit %d).\n"), 
 			   ctl->limit, ctl->limit);
 		else if (outlevel >= O_VERBOSE)
-		    printf(_("  No message size limit (--limit 0).\n"));
+		    printf(GT_("  No message size limit (--limit 0).\n"));
 		if (run.poll_interval > 0)
-		    printf(_("  Message size warning interval is %d seconds (--warnings %d).\n"), 
+		    printf(GT_("  Message size warning interval is %d seconds (--warnings %d).\n"), 
 			   ctl->warnings, ctl->warnings);
 		else if (outlevel >= O_VERBOSE)
-		    printf(_("  Size warnings on every poll (--warnings 0).\n"));
+		    printf(GT_("  Size warnings on every poll (--warnings 0).\n"));
 	    }
 	    if (NUM_NONZERO(ctl->fetchlimit))
-		printf(_("  Received-message limit is %d (--fetchlimit %d).\n"),
+		printf(GT_("  Received-message limit is %d (--fetchlimit %d).\n"),
 		       ctl->fetchlimit, ctl->fetchlimit);
 	    else if (outlevel >= O_VERBOSE)
-		printf(_("  No received-message limit (--fetchlimit 0).\n"));
+		printf(GT_("  No received-message limit (--fetchlimit 0).\n"));
 	    if (NUM_NONZERO(ctl->batchlimit))
-		printf(_("  SMTP message batch limit is %d.\n"), ctl->batchlimit);
+		printf(GT_("  SMTP message batch limit is %d.\n"), ctl->batchlimit);
 	    else if (outlevel >= O_VERBOSE)
-		printf(_("  No SMTP message batch limit (--batchlimit 0).\n"));
+		printf(GT_("  No SMTP message batch limit (--batchlimit 0).\n"));
 	    if (MAILBOX_PROTOCOL(ctl))
 	    {
 		if (NUM_NONZERO(ctl->expunge))
-		    printf(_("  Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
+		    printf(GT_("  Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
 		else if (outlevel >= O_VERBOSE)
-		    printf(_("  No forced expunges (--expunge 0).\n"));
+		    printf(GT_("  No forced expunges (--expunge 0).\n"));
 	    }
 	}
 	else	/* ODMR or ETRN */
 	{
 	    struct idlist *idp;
 
-	    printf(_("  Domains for which mail will be fetched are:"));
+	    printf(GT_("  Domains for which mail will be fetched are:"));
 	    for (idp = ctl->domainlist; idp; idp = idp->next)
 	    {
 		printf(" %s", idp->id);
 		if (!idp->val.status.mark)
-		    printf(_(" (default)"));
+		    printf(GT_(" (default)"));
 	    }
 	    printf("\n");
 	}
 	if (ctl->bsmtp)
-	    printf(_("  Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
+	    printf(GT_("  Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
 	else if (ctl->mda && MAILBOX_PROTOCOL(ctl))
-	    printf(_("  Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
+	    printf(GT_("  Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
 	else
 	{
 	    struct idlist *idp;
 
 	    if (ctl->smtphunt)
 	    {
-		printf(_("  Messages will be %cMTP-forwarded to:"), 
+		printf(GT_("  Messages will be %cMTP-forwarded to:"), 
 		       ctl->listener);
 		for (idp = ctl->smtphunt; idp; idp = idp->next)
 		{
 		    printf(" %s", idp->id);
 		    if (!idp->val.status.mark)
-			printf(_(" (default)"));
+			printf(GT_(" (default)"));
 		}
 		printf("\n");
 	    }
 	    if (ctl->smtpaddress)
-		printf(_("  Host part of MAIL FROM line will be %s\n"),
+		printf(GT_("  Host part of MAIL FROM line will be %s\n"),
 		       ctl->smtpaddress);
 	    if (ctl->smtpname)
-		printf(_("  Address to be put in RCPT TO lines shipped to SMTP will be %s\n"),
+		printf(GT_("  Address to be put in RCPT TO lines shipped to SMTP will be %s\n"),
 		       ctl->smtpname);
 	}
 	if (MAILBOX_PROTOCOL(ctl))
@@ -1655,27 +1655,27 @@ static void dump_params (struct runctl *runp,
 		{
 		    struct idlist *idp;
 
-		    printf(_("  Recognized listener spam block responses are:"));
+		    printf(GT_("  Recognized listener spam block responses are:"));
 		    for (idp = ctl->antispam; idp; idp = idp->next)
 			printf(" %d", idp->val.status.num);
 		    printf("\n");
 		}
 		else if (outlevel >= O_VERBOSE)
-		    printf(_("  Spam-blocking disabled\n"));
+		    printf(GT_("  Spam-blocking disabled\n"));
 	}
 	if (ctl->preconnect)
-	    printf(_("  Server connection will be brought up with \"%s\".\n"),
+	    printf(GT_("  Server connection will be brought up with \"%s\".\n"),
 		   visbuf(ctl->preconnect));
 	else if (outlevel >= O_VERBOSE)
-	    printf(_("  No pre-connection command.\n"));
+	    printf(GT_("  No pre-connection command.\n"));
 	if (ctl->postconnect)
-	    printf(_("  Server connection will be taken down with \"%s\".\n"),
+	    printf(GT_("  Server connection will be taken down with \"%s\".\n"),
 		   visbuf(ctl->postconnect));
 	else if (outlevel >= O_VERBOSE)
-	    printf(_("  No post-connection command.\n"));
+	    printf(GT_("  No post-connection command.\n"));
 	if (MAILBOX_PROTOCOL(ctl)) {
 		if (!ctl->localnames)
-		    printf(_("  No localnames declared for this host.\n"));
+		    printf(GT_("  No localnames declared for this host.\n"));
 		else
 		{
 		    struct idlist *idp;
@@ -1685,11 +1685,11 @@ static void dump_params (struct runctl *runp,
 			++count;
 
 		    if (count > 1 || ctl->wildcard)
-			printf(_("  Multi-drop mode: "));
+			printf(GT_("  Multi-drop mode: "));
 		    else
-			printf(_("  Single-drop mode: "));
+			printf(GT_("  Single-drop mode: "));
 
-		    printf(_("%d local name(s) recognized.\n"), count);
+		    printf(GT_("%d local name(s) recognized.\n"), count);
 		    if (outlevel >= O_VERBOSE)
 		    {
 			for (idp = ctl->localnames; idp; idp = idp->next)
@@ -1703,37 +1703,37 @@ static void dump_params (struct runctl *runp,
 
 		    if (count > 1 || ctl->wildcard)
 		    {
-			printf(_("  DNS lookup for multidrop addresses is %s.\n"),
-			       ctl->server.dns ? _("enabled") : _("disabled"));
+			printf(GT_("  DNS lookup for multidrop addresses is %s.\n"),
+			       ctl->server.dns ? GT_("enabled") : GT_("disabled"));
 			if (ctl->server.dns)
 			{
-			    printf(_("  Server aliases will be compared with multidrop addresses by "));
+			    printf(GT_("  Server aliases will be compared with multidrop addresses by "));
 	       		    if (ctl->server.checkalias)
-				printf(_("IP address.\n"));
+				printf(GT_("IP address.\n"));
 			    else
-				printf(_("name.\n"));
+				printf(GT_("name.\n"));
 			}
 			if (ctl->server.envelope == STRING_DISABLED)
-			    printf(_("  Envelope-address routing is disabled\n"));
+			    printf(GT_("  Envelope-address routing is disabled\n"));
 			else
 			{
-			    printf(_("  Envelope header is assumed to be: %s\n"),
-				   ctl->server.envelope ? ctl->server.envelope:_("Received"));
+			    printf(GT_("  Envelope header is assumed to be: %s\n"),
+				   ctl->server.envelope ? ctl->server.envelope:GT_("Received"));
 			    if (ctl->server.envskip > 1 || outlevel >= O_VERBOSE)
-				printf(_("  Number of envelope header to be parsed: %d\n"),
+				printf(GT_("  Number of envelope header to be parsed: %d\n"),
 				       ctl->server.envskip);
 			    if (ctl->server.qvirtual)
-				printf(_("  Prefix %s will be removed from user id\n"),
+				printf(GT_("  Prefix %s will be removed from user id\n"),
 				       ctl->server.qvirtual);
 			    else if (outlevel >= O_VERBOSE) 
-				printf(_("  No prefix stripping\n"));
+				printf(GT_("  No prefix stripping\n"));
 			}
 
 			if (ctl->server.akalist)
 			{
 			    struct idlist *idp;
 
-			    printf(_("  Predeclared mailserver aliases:"));
+			    printf(GT_("  Predeclared mailserver aliases:"));
 			    for (idp = ctl->server.akalist; idp; idp = idp->next)
 				printf(" %s", idp->id);
 			    putchar('\n');
@@ -1742,7 +1742,7 @@ static void dump_params (struct runctl *runp,
 			{
 			    struct idlist *idp;
 
-			    printf(_("  Local domains:"));
+			    printf(GT_("  Local domains:"));
 			    for (idp = ctl->server.localdomains; idp; idp = idp->next)
 				printf(" %s", idp->id);
 			    putchar('\n');
@@ -1752,28 +1752,28 @@ static void dump_params (struct runctl *runp,
 	}
 #if defined(linux) || defined(__FreeBSD__)
 	if (ctl->server.interface)
-	    printf(_("  Connection must be through interface %s.\n"), ctl->server.interface);
+	    printf(GT_("  Connection must be through interface %s.\n"), ctl->server.interface);
 	else if (outlevel >= O_VERBOSE)
-	    printf(_("  No interface requirement specified.\n"));
+	    printf(GT_("  No interface requirement specified.\n"));
 	if (ctl->server.monitor)
-	    printf(_("  Polling loop will monitor %s.\n"), ctl->server.monitor);
+	    printf(GT_("  Polling loop will monitor %s.\n"), ctl->server.monitor);
 	else if (outlevel >= O_VERBOSE)
-	    printf(_("  No monitor interface specified.\n"));
+	    printf(GT_("  No monitor interface specified.\n"));
 #endif
 
 	if (ctl->server.plugin)
-	    printf(_("  Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
+	    printf(GT_("  Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
 	else if (outlevel >= O_VERBOSE)
-	    printf(_("  No plugin command specified.\n"));
+	    printf(GT_("  No plugin command specified.\n"));
 	if (ctl->server.plugout)
-	    printf(_("  Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
+	    printf(GT_("  Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
 	else if (outlevel >= O_VERBOSE)
-	    printf(_("  No plugout command specified.\n"));
+	    printf(GT_("  No plugout command specified.\n"));
 
 	if (ctl->server.protocol > P_POP2 && MAILBOX_PROTOCOL(ctl))
 	{
 	    if (!ctl->oldsaved)
-		printf(_("  No UIDs saved from this host.\n"));
+		printf(GT_("  No UIDs saved from this host.\n"));
 	    else
 	    {
 		struct idlist *idp;
@@ -1782,7 +1782,7 @@ static void dump_params (struct runctl *runp,
 		for (idp = ctl->oldsaved; idp; idp = idp->next)
 		    ++count;
 
-		printf(_("  %d UIDs saved.\n"), count);
+		printf(GT_("  %d UIDs saved.\n"), count);
 		if (outlevel >= O_VERBOSE)
 		    for (idp = ctl->oldsaved; idp; idp = idp->next)
 			printf("\t%s\n", idp->id);
@@ -1790,12 +1790,12 @@ static void dump_params (struct runctl *runp,
 	}
 
         if (ctl->tracepolls)
-            printf(_("  Poll trace information will be added to the Received header.\n"));
+            printf(GT_("  Poll trace information will be added to the Received header.\n"));
         else if (outlevel >= O_VERBOSE)
-            printf(_("  No poll trace information will be added to the Received header.\n.\n"));
+            printf(GT_("  No poll trace information will be added to the Received header.\n.\n"));
 
 	if (ctl->properties)
-	    printf(_("  Pass-through properties \"%s\".\n"),
+	    printf(GT_("  Pass-through properties \"%s\".\n"),
 		   visbuf(ctl->properties));
     }
 }
diff --git a/fetchmail.h b/fetchmail.h
index 87e08e57..b8963ce8 100644
--- a/fetchmail.h
+++ b/fetchmail.h
@@ -539,7 +539,7 @@ char *xstrdup(const char *);
 #endif
 #endif
 #define	xalloca(ptr, t, n)	if (!(ptr = (t) alloca(n)))\
-       {report(stderr, _("alloca failed")); exit(PS_UNDEFINED);}
+       {report(stderr, GT_("alloca failed")); exit(PS_UNDEFINED);}
 #if FALSE
 /*
  * This is a hack to help xgettext which cannot find strings in
diff --git a/getpass.c b/getpass.c
index b0858a23..6e4b93cf 100644
--- a/getpass.c
+++ b/getpass.c
@@ -69,7 +69,7 @@ char *prompt;
     char *getpass();
     return getpass(prompt);
 #else
-    fputs(_("ERROR: no support for getpassword() routine\n"),stderr);
+    fputs(GT_("ERROR: no support for getpassword() routine\n"),stderr);
     exit(1);
 #endif
 #else
@@ -191,7 +191,7 @@ static void restore_tty_state(void)
 static RETSIGTYPE sigint_handler(int signum)
 {
     restore_tty_state();
-    report(stderr, _("\nCaught SIGINT... bailing out.\n"));
+    report(stderr, GT_("\nCaught SIGINT... bailing out.\n"));
     exit(1);
 }
 
diff --git a/i18n.h b/i18n.h
index d3c482a3..1dd3bd17 100644
--- a/i18n.h
+++ b/i18n.h
@@ -4,9 +4,9 @@
 #ifdef ENABLE_NLS
 #undef __OPTIMIZE__
 #include <libintl.h>
-#define _(String) gettext((String))
-#define N_(String) (String)
+#define GT_(String) gettext((String))
+#define NGT_(String) (String)
 #else
-#define _(String) (String)
-#define N_(String) (String)
+#define GT_(String) (String)
+#define NGT_(String) (String)
 #endif
diff --git a/imap.c b/imap.c
index afa9816d..ed63c076 100644
--- a/imap.c
+++ b/imap.c
@@ -248,20 +248,20 @@ static int imap_getauth(int sock, struct query *ctl, char *greeting)
 	{
 	    imap_version = IMAP4rev1;
 	    if (outlevel >= O_DEBUG)
-		report(stdout, _("Protocol identified as IMAP4 rev 1\n"));
+		report(stdout, GT_("Protocol identified as IMAP4 rev 1\n"));
 	}
 	else
 	{
 	    imap_version = IMAP4;
 	    if (outlevel >= O_DEBUG)
-		report(stdout, _("Protocol identified as IMAP4 rev 0\n"));
+		report(stdout, GT_("Protocol identified as IMAP4 rev 0\n"));
 	}
     }
     else if (ok == PS_ERROR)
     {
 	imap_version = IMAP2;
 	if (outlevel >= O_DEBUG)
-	    report(stdout, _("Protocol identified as IMAP2 or IMAP2BIS\n"));
+	    report(stdout, GT_("Protocol identified as IMAP2 or IMAP2BIS\n"));
     }
     else
 	return(ok);
@@ -285,7 +285,7 @@ static int imap_getauth(int sock, struct query *ctl, char *greeting)
     {
 	do_idle = TRUE;
 	if (outlevel >= O_VERBOSE)
-	    report(stdout, _("will idle after poll\n"));
+	    report(stdout, GT_("will idle after poll\n"));
     }
 
     /* 
@@ -374,7 +374,7 @@ static int imap_getauth(int sock, struct query *ctl, char *greeting)
     if (ctl->server.authenticate == A_OTP)
     {
 	report(stderr, 
-	   _("Required OTP capability not compiled into fetchmail\n"));
+	   GT_("Required OTP capability not compiled into fetchmail\n"));
     }
 #endif /* OPIE_ENABLE */
 
@@ -396,7 +396,7 @@ static int imap_getauth(int sock, struct query *ctl, char *greeting)
     if (ctl->server.authenticate == A_NTLM)
     {
 	report(stderr, 
-	   _("Required NTLM capability not compiled into fetchmail\n"));
+	   GT_("Required NTLM capability not compiled into fetchmail\n"));
     }
 #endif /* NTLM_ENABLE */
 
@@ -405,7 +405,7 @@ static int imap_getauth(int sock, struct query *ctl, char *greeting)
     if ((imap_version >= IMAP4rev1) && (!strstr(capabilities, "LOGIN")))
     {
 	report(stderr, 
-	       _("Required LOGIN capability not supported by server\n"));
+	       GT_("Required LOGIN capability not supported by server\n"));
     }
 #endif /* __UNUSED__ */
 
@@ -493,7 +493,7 @@ static int imap_getrange(int sock,
 	    ok = imap_idle(sock);
 	if (ok || gen_transact(sock, "NOOP"))
 	{
-	    report(stderr, _("re-poll failed\n"));
+	    report(stderr, GT_("re-poll failed\n"));
 	    return(ok);
 	}
 	else if (count == -1)	/* no EXISTS response to NOOP/IDLE */
@@ -501,7 +501,7 @@ static int imap_getrange(int sock,
 	    count = 0;
 	}
 	if (outlevel >= O_DEBUG)
-	    report(stdout, _("%d messages waiting after re-poll\n"), count);
+	    report(stdout, GT_("%d messages waiting after re-poll\n"), count);
     }
     else
     {
@@ -510,11 +510,11 @@ static int imap_getrange(int sock,
 			  folder ? folder : "INBOX");
 	if (ok != 0)
 	{
-	    report(stderr, _("mailbox selection failed\n"));
+	    report(stderr, GT_("mailbox selection failed\n"));
 	    return(ok);
 	}
 	else if (outlevel >= O_DEBUG)
-	    report(stdout, _("%d messages waiting after first poll\n"), count);
+	    report(stdout, GT_("%d messages waiting after first poll\n"), count);
 
 	/* no messages?  then we may need to idle until we get some */
 	if (count == 0 && do_idle)
@@ -537,7 +537,7 @@ static int imap_getrange(int sock,
 	    ok = gen_recv(sock, buf, sizeof(buf));
 	    if (ok != 0)
 	    {
-		report(stderr, _("search for unseen messages failed\n"));
+		report(stderr, GT_("search for unseen messages failed\n"));
 		return(PS_PROTOCOL);
 	    }
 	    else if ((cp = strstr(buf, "* SEARCH")))
@@ -561,7 +561,7 @@ static int imap_getrange(int sock,
 
 			if (outlevel >= O_DEBUG)
 			    report(stdout, 
-				   _("%u is unseen\n"), 
+				   GT_("%u is unseen\n"), 
 				   unseen_messages[unseen]);
 		
 			unseen++;
diff --git a/interface.c b/interface.c
index 682b788d..3b52c97b 100644
--- a/interface.c
+++ b/interface.c
@@ -96,7 +96,7 @@ void interface_init(void)
     }
 }
 
-static int _get_ifinfo_(int socket_fd, FILE *stats_file, const char *ifname,
+static int _get_ifinfoGT_(int socket_fd, FILE *stats_file, const char *ifname,
 		ifinfo_t *ifinfo)
 /* get active network interface information - return non-zero upon success */
 {
@@ -176,7 +176,7 @@ static int get_ifinfo(const char *ifname, ifinfo_t *ifinfo)
 
 	    if (sp)
 		*sp = '\0';
-	    result = _get_ifinfo_(socket_fd, stats_file, ifname, ifinfo);
+	    result = _get_ifinfoGT_(socket_fd, stats_file, ifname, ifinfo);
 	    if (sp)
 		*sp = '/';
 	}
@@ -252,7 +252,7 @@ get_ifinfo(const char *ifname, ifinfo_t *ifinfo)
 	{
 		if (!openkvm())
 		{
-			report(stderr, 0, _("Unable to open kvm interface. Make sure fetchmail is SGID kmem."));
+			report(stderr, 0, GT_("Unable to open kvm interface. Make sure fetchmail is SGID kmem."));
 			if (if_egid)
 				setegid(if_rgid);
 			exit(1);
@@ -397,7 +397,7 @@ get_ifinfo(const char *ifname, ifinfo_t *ifinfo)
 	
     if (i == 0 || i == sizeof(iname))
     {
-	report(stderr, _("Unable to parse interface name from %s"), ifname);
+	report(stderr, GT_("Unable to parse interface name from %s"), ifname);
 	return 0;
     }
 
@@ -419,19 +419,19 @@ get_ifinfo(const char *ifname, ifinfo_t *ifinfo)
     if (sysctl(mib, 6, NULL, &needed, NULL, 0) == -1)
     {
  	report(stderr, 
-	    _("get_ifinfo: sysctl (iflist estimate) failed"));
+	    GT_("get_ifinfo: sysctl (iflist estimate) failed"));
 	exit(1);
     }
     if ((buf = malloc(needed)) == NULL)
     {
  	report(stderr, 
-	    _("get_ifinfo: malloc failed"));
+	    GT_("get_ifinfo: malloc failed"));
 	exit(1);
     }
     if (sysctl(mib, 6, buf, &needed, NULL, 0) == -1)
     {
  	report(stderr, 
-	    _("get_ifinfo: sysctl (iflist) failed"));
+	    GT_("get_ifinfo: sysctl (iflist) failed"));
 	exit(1);
     }
 
@@ -449,7 +449,7 @@ get_ifinfo(const char *ifname, ifinfo_t *ifinfo)
 	if (ifm->ifm_version != RTM_VERSION) 
 	{
  	    report(stderr, 
-		_("Routing message version %d not understood."),
+		GT_("Routing message version %d not understood."),
 		ifm->ifm_version);
 	    exit(1);
 	}
@@ -481,7 +481,7 @@ get_ifinfo(const char *ifname, ifinfo_t *ifinfo)
     if (ifindex < 0)
     {
 	/* we did not find an interface with a matching name */
-	report(stderr, _("No interface found with name %s"), iname);
+	report(stderr, GT_("No interface found with name %s"), iname);
 	goto get_ifinfo_end;
     }
 
@@ -539,7 +539,7 @@ get_ifinfo(const char *ifname, ifinfo_t *ifinfo)
 
     if (rc == 0)
     {
-	report(stderr, _("No IP address found for %s"), iname);
+	report(stderr, GT_("No IP address found for %s"), iname);
     }
 
 get_ifinfo_end:
@@ -591,7 +591,7 @@ void interface_parse(char *buf, struct hostdata *hp)
 	if (!(cp1 = strchr(buf, '/')))
 	{
 		(void) report(stderr,
-			      _("missing IP interface address\n"));
+			      GT_("missing IP interface address\n"));
 		exit(PS_SYNTAX);
 	}
 	*cp1++ = '\000';
@@ -607,13 +607,13 @@ void interface_parse(char *buf, struct hostdata *hp)
 	if (!inet_aton(cp1, &hp->interface_pair->interface_address))
 	{
 		(void) report(stderr,
-			      _("invalid IP interface address\n"));
+			      GT_("invalid IP interface address\n"));
 		exit(PS_SYNTAX);
 	}
 	if (!inet_aton(cp2, &hp->interface_pair->interface_mask))
 	{
 		(void) report(stderr,
-			      _("invalid IP interface mask\n"));
+			      GT_("invalid IP interface mask\n"));
 		exit(PS_SYNTAX);
 	}
 	/* apply the mask now to the IP address (range) required */
@@ -652,7 +652,7 @@ void interface_note_activity(struct hostdata *hp)
 
 #ifdef	ACTIVITY_DEBUG
 	(void) report(stdout, 
-		      _("activity on %s -noted- as %d\n"), 
+		      GT_("activity on %s -noted- as %d\n"), 
 		      hp->monitor, hp->monitor_io);
 #endif
 }
@@ -667,7 +667,7 @@ int interface_approve(struct hostdata *hp, flag domonitor)
 		/* get interface info */
 		if (!get_ifinfo(hp->interface, &ifinfo)) {
 			(void) report(stdout, 
-				      _("skipping poll of %s, %s down\n"),
+				      GT_("skipping poll of %s, %s down\n"),
 				      hp->pollname, hp->interface);
 			return(FALSE);
 		}
@@ -686,7 +686,7 @@ int interface_approve(struct hostdata *hp, flag domonitor)
 			) )
 		{
 			(void) report(stdout,
-				_("skipping poll of %s, %s IP address excluded\n"),
+				GT_("skipping poll of %s, %s IP address excluded\n"),
 				hp->pollname, hp->interface);
 			return(FALSE);
 		}
@@ -698,7 +698,7 @@ int interface_approve(struct hostdata *hp, flag domonitor)
 
 #ifdef	ACTIVITY_DEBUG
 	(void) report(stdout, 
-		      _("activity on %s checked as %d\n"), 
+		      GT_("activity on %s checked as %d\n"), 
 		      hp->monitor, hp->monitor_io);
 #endif
 	/* if monitoring, check link for activity if it is up */
@@ -724,14 +724,14 @@ int interface_approve(struct hostdata *hp, flag domonitor)
 	    if (diff >= 0 && diff <= MONITOR_SLOP)
 	    {
 		(void) report(stdout, 
-			      _("skipping poll of %s, %s inactive\n"),
+			      GT_("skipping poll of %s, %s inactive\n"),
 			      hp->pollname, hp->monitor);
 		return(FALSE);
 	    }
 	}
 
 #ifdef ACTIVITY_DEBUG
-       report(stdout, _("activity on %s was %d, is %d\n"),
+       report(stdout, GT_("activity on %s was %d, is %d\n"),
              hp->monitor, hp->monitor_io,
              ifinfo.rx_packets + ifinfo.tx_packets);
 #endif
diff --git a/lock.c b/lock.c
index a9fcb2ae..2aa7a051 100644
--- a/lock.c
+++ b/lock.c
@@ -78,7 +78,7 @@ int lock_state(void)
 	bkgd = (fscanf(lockfp, "%d %d", &pid, &st) == 2);
 
 	if (kill(pid, 0) == -1) {
-	    fprintf(stderr,_("fetchmail: removing stale lockfile\n"));
+	    fprintf(stderr,GT_("fetchmail: removing stale lockfile\n"));
 	    pid = 0;
 	    unlink(lockfile);
 	}
@@ -119,7 +119,7 @@ void lock_or_die(void)
       }
       else
       {
-	  fprintf(stderr,	_("fetchmail: lock creation failed.\n"));
+	  fprintf(stderr,	GT_("fetchmail: lock creation failed.\n"));
 	  exit(PS_EXCLUDE);
       }
     }
diff --git a/netrc.c b/netrc.c
index 70f3361d..b8c7ae5e 100644
--- a/netrc.c
+++ b/netrc.c
@@ -214,11 +214,11 @@ parse_netrc (file)
 	    {
 #ifdef HAVE_ERROR
 		error_at_line (0, file, ln,
-			       _("warning: found \"%s\" before any host names"),
+			       GT_("warning: found \"%s\" before any host names"),
 			       premature_token);
 #else
 		fprintf (stderr,
-			 _("%s:%d: warning: found \"%s\" before any host names\n"),
+			 GT_("%s:%d: warning: found \"%s\" before any host names\n"),
 			 file, ln, premature_token);
 #endif
 		premature_token = NULL;
@@ -257,7 +257,7 @@ parse_netrc (file)
 
 		else
 		{
-		    fprintf (stderr, _("%s:%d: warning: unknown token \"%s\"\n"),
+		    fprintf (stderr, GT_("%s:%d: warning: unknown token \"%s\"\n"),
 			     file, ln, tok);
 		}
 	    }
diff --git a/odmr.c b/odmr.c
index 29281443..1f13c1b3 100644
--- a/odmr.c
+++ b/odmr.c
@@ -50,13 +50,13 @@ static int odmr_getrange(int sock, struct query *ctl, const char *id,
 
     if ((ok = SMTP_ehlo(sock, fetchmailhost, &opts)))
     {
-	report(stderr, _("%s's SMTP listener does not support ESMTP\n"),
+	report(stderr, GT_("%s's SMTP listener does not support ESMTP\n"),
 	      ctl->server.pollname);
 	return(ok);
     }
     else if (!(opts & ESMTP_ATRN))
     {
-	report(stderr, _("%s's SMTP listener does not support ATRN\n"),
+	report(stderr, GT_("%s's SMTP listener does not support ATRN\n"),
 	      ctl->server.pollname);
 	return(PS_PROTOCOL);
     }
@@ -94,32 +94,32 @@ static int odmr_getrange(int sock, struct query *ctl, const char *id,
     {
     case 250:	/* OK, turnaround is about to happe */
 	if (outlevel >= O_SILENT)
-	    report(stdout, _("Turnaround now...\n"));
+	    report(stdout, GT_("Turnaround now...\n"));
 	break;
 
     case 450:	/* ATRN request refused */
 	if (outlevel >= O_SILENT)
-	    report(stdout, _("ATRN request refused.\n"));
+	    report(stdout, GT_("ATRN request refused.\n"));
 	return(PS_PROTOCOL);
 
     case 451:	/* Unable to process ATRN request now */
-	report(stderr, _("Unable to process ATRN request now\n"));
+	report(stderr, GT_("Unable to process ATRN request now\n"));
 	return(PS_EXCLUDE);
 
     case 453:	/* You have no mail */
-	report(stderr, _("You have no mail.\n"));
+	report(stderr, GT_("You have no mail.\n"));
 	return(PS_NOMAIL);
 
     case 502:	/* Command not implemented */
-	report(stderr, _("Command not implemented\n"));
+	report(stderr, GT_("Command not implemented\n"));
 	return(PS_PROTOCOL);
 
     case 530:	/* Authentication required */
-	report(stderr, _("Authentication required.\n"));
+	report(stderr, GT_("Authentication required.\n"));
 	return(PS_AUTHFAIL);
 
     default:
-	report(stderr, _("Unknown ODMR error %d\n"), atoi(buf));
+	report(stderr, GT_("Unknown ODMR error %d\n"), atoi(buf));
 	return(PS_PROTOCOL);
     }
 
@@ -222,19 +222,19 @@ int doODMR (struct query *ctl)
     int status;
 
     if (ctl->keep) {
-	fprintf(stderr, _("Option --keep is not supported with ODMR\n"));
+	fprintf(stderr, GT_("Option --keep is not supported with ODMR\n"));
 	return(PS_SYNTAX);
     }
     if (ctl->flush) {
-	fprintf(stderr, _("Option --flush is not supported with ODMR\n"));
+	fprintf(stderr, GT_("Option --flush is not supported with ODMR\n"));
 	return(PS_SYNTAX);
     }
     if (ctl->mailboxes->id) {
-	fprintf(stderr, _("Option --remote is not supported with ODMR\n"));
+	fprintf(stderr, GT_("Option --remote is not supported with ODMR\n"));
 	return(PS_SYNTAX);
     }
     if (check_only) {
-	fprintf(stderr, _("Option --check is not supported with ODMR\n"));
+	fprintf(stderr, GT_("Option --check is not supported with ODMR\n"));
 	return(PS_SYNTAX);
     }
     peek_capable = FALSE;
diff --git a/options.c b/options.c
index 9a166e54..cfe74bbd 100644
--- a/options.c
+++ b/options.c
@@ -194,7 +194,7 @@ static int xatoi(char *s, int *errflagptr)
 
     /* any invalid chars in string? */
     if ( (endptr == s) || (*endptr != '\0') ) {
-    	(void) fprintf(stderr, _("String '%s' is not a valid number string.\n"), s);
+    	(void) fprintf(stderr, GT_("String '%s' is not a valid number string.\n"), s);
 	(*errflagptr)++;
 	return 0;
     }
@@ -203,8 +203,8 @@ static int xatoi(char *s, int *errflagptr)
     if ( (((value == LONG_MAX) || (value == LONG_MIN)) && (errno == ERANGE)) ||
 				(value > INT_MAX) || (value < INT_MIN)) {
 
-    	(void) fprintf(stderr, _("Value of string '%s' is %s than %d.\n"), s,
-					(value < 0) ? _("smaller"): _("larger"),
+    	(void) fprintf(stderr, GT_("Value of string '%s' is %s than %d.\n"), s,
+					(value < 0) ? GT_("smaller"): GT_("larger"),
 					(value < 0) ? INT_MIN : INT_MAX);
 	(*errflagptr)++;
 	return 0;
@@ -238,7 +238,7 @@ static int xatoi(char *s, int *errflagptr)
 
     /* check for trailing garbage */
     if (i != len) {
-    	(void) fprintf(stderr, _("String '%s' is not a valid number string.\n"), s);
+    	(void) fprintf(stderr, GT_("String '%s' is not a valid number string.\n"), s);
     	(*errflagptr)++;
 	return 0;
     }
@@ -376,7 +376,7 @@ struct query *ctl;	/* option record to be initialized */
 	    else if (strcasecmp(optarg,"odmr") == 0)
 		ctl->server.protocol = P_ODMR;
 	    else {
-		fprintf(stderr,_("Invalid protocol `%s' specified.\n"), optarg);
+		fprintf(stderr,GT_("Invalid protocol `%s' specified.\n"), optarg);
 		errflag++;
 	    }
 	    break;
@@ -420,7 +420,7 @@ struct query *ctl;	/* option record to be initialized */
 	    else if (strcmp(optarg, "any") == 0)
 		ctl->server.authenticate = A_ANY;
 	    else {
-		fprintf(stderr,_("Invalid authentication `%s' specified.\n"), optarg);
+		fprintf(stderr,GT_("Invalid authentication `%s' specified.\n"), optarg);
 		errflag++;
 	    }
 	    break;
@@ -550,7 +550,7 @@ struct query *ctl;	/* option record to be initialized */
 #if NET_SECURITY
 	    ctl->server.netsec = (void *)optarg;
 #else
-	    fprintf(stderr, _("fetchmail: network security support is disabled\n"));
+	    fprintf(stderr, GT_("fetchmail: network security support is disabled\n"));
 	    errflag++;
 #endif /* NET_SECURITY */
 	    break;
@@ -643,72 +643,72 @@ struct query *ctl;	/* option record to be initialized */
     if (errflag || ocount > 1 || helpflag) {
 	/* squawk if syntax errors were detected */
 #define P(s)	fputs(s, helpflag ? stdout : stderr)
-	P(_("usage:  fetchmail [options] [server ...]\n"));
-	P(_("  Options are as follows:\n"));
-	P(_("  -?, --help        display this option help\n"));
-	P(_("  -V, --version     display version info\n"));
-
-	P(_("  -c, --check       check for messages without fetching\n"));
-	P(_("  -s, --silent      work silently\n"));
-	P(_("  -v, --verbose     work noisily (diagnostic output)\n"));
-	P(_("  -d, --daemon      run as a daemon once per n seconds\n"));
-	P(_("  -N, --nodetach    don't detach daemon process\n"));
-	P(_("  -q, --quit        kill daemon process\n"));
-	P(_("  -L, --logfile     specify logfile name\n"));
-	P(_("      --syslog      use syslog(3) for most messages when running as a daemon\n"));
-	P(_("      --invisible   don't write Received & enable host spoofing\n"));
-	P(_("  -f, --fetchmailrc specify alternate run control file\n"));
-	P(_("  -i, --idfile      specify alternate UIDs file\n"));
-	P(_("      --postmaster  specify recipient of last resort\n"));
-	P(_("      --nobounce    redirect bounces from user to postmaster.\n"));
+	P(GT_("usage:  fetchmail [options] [server ...]\n"));
+	P(GT_("  Options are as follows:\n"));
+	P(GT_("  -?, --help        display this option help\n"));
+	P(GT_("  -V, --version     display version info\n"));
+
+	P(GT_("  -c, --check       check for messages without fetching\n"));
+	P(GT_("  -s, --silent      work silently\n"));
+	P(GT_("  -v, --verbose     work noisily (diagnostic output)\n"));
+	P(GT_("  -d, --daemon      run as a daemon once per n seconds\n"));
+	P(GT_("  -N, --nodetach    don't detach daemon process\n"));
+	P(GT_("  -q, --quit        kill daemon process\n"));
+	P(GT_("  -L, --logfile     specify logfile name\n"));
+	P(GT_("      --syslog      use syslog(3) for most messages when running as a daemon\n"));
+	P(GT_("      --invisible   don't write Received & enable host spoofing\n"));
+	P(GT_("  -f, --fetchmailrc specify alternate run control file\n"));
+	P(GT_("  -i, --idfile      specify alternate UIDs file\n"));
+	P(GT_("      --postmaster  specify recipient of last resort\n"));
+	P(GT_("      --nobounce    redirect bounces from user to postmaster.\n"));
 #if (defined(linux) && !INET6_ENABLE) || defined(__FreeBSD__)
-	P(_("  -I, --interface   interface required specification\n"));
-	P(_("  -M, --monitor     monitor interface for activity\n"));
+	P(GT_("  -I, --interface   interface required specification\n"));
+	P(GT_("  -M, --monitor     monitor interface for activity\n"));
 #endif
 #if defined( SSL_ENABLE )
-	P(_("      --ssl         enable ssl encrypted session\n"));
-	P(_("      --sslkey      ssl private key file\n"));
-	P(_("      --sslcert     ssl client certificate\n"));
-	P(_("      --sslproto    force ssl protocol (ssl2/ssl3/tls1)\n"));
+	P(GT_("      --ssl         enable ssl encrypted session\n"));
+	P(GT_("      --sslkey      ssl private key file\n"));
+	P(GT_("      --sslcert     ssl client certificate\n"));
+	P(GT_("      --sslproto    force ssl protocol (ssl2/ssl3/tls1)\n"));
 #endif
-	P(_("      --plugin      specify external command to open connection\n"));
-	P(_("      --plugout     specify external command to open smtp connection\n"));
-
-	P(_("  -p, --protocol    specify retrieval protocol (see man page)\n"));
-	P(_("  -U, --uidl        force the use of UIDLs (pop3 only)\n"));
-	P(_("  -P, --port        TCP/IP service port to connect to\n"));
-	P(_("      --auth        authentication type (password/kerberos/ssh)\n"));
-	P(_("  -t, --timeout     server nonresponse timeout\n"));
-	P(_("  -E, --envelope    envelope address header\n"));
-	P(_("  -Q, --qvirtual    prefix to remove from local user id\n"));
-	P(_("      --principal   mail service principal\n"));
-        P(_("      --tracepolls  add poll-tracing information to Received header\n"));
-
-	P(_("  -u, --username    specify users's login on server\n"));
-	P(_("  -a, --all         retrieve old and new messages\n"));
-	P(_("  -K, --nokeep      delete new messages after retrieval\n"));
-	P(_("  -k, --keep        save new messages after retrieval\n"));
-	P(_("  -F, --flush       delete old messages from server\n"));
-	P(_("  -n, --norewrite   don't rewrite header addresses\n"));
-	P(_("  -l, --limit       don't fetch messages over given size\n"));
-	P(_("  -w, --warnings    interval between warning mail notification\n"));
+	P(GT_("      --plugin      specify external command to open connection\n"));
+	P(GT_("      --plugout     specify external command to open smtp connection\n"));
+
+	P(GT_("  -p, --protocol    specify retrieval protocol (see man page)\n"));
+	P(GT_("  -U, --uidl        force the use of UIDLs (pop3 only)\n"));
+	P(GT_("  -P, --port        TCP/IP service port to connect to\n"));
+	P(GT_("      --auth        authentication type (password/kerberos/ssh)\n"));
+	P(GT_("  -t, --timeout     server nonresponse timeout\n"));
+	P(GT_("  -E, --envelope    envelope address header\n"));
+	P(GT_("  -Q, --qvirtual    prefix to remove from local user id\n"));
+	P(GT_("      --principal   mail service principal\n"));
+        P(GT_("      --tracepolls  add poll-tracing information to Received header\n"));
+
+	P(GT_("  -u, --username    specify users's login on server\n"));
+	P(GT_("  -a, --all         retrieve old and new messages\n"));
+	P(GT_("  -K, --nokeep      delete new messages after retrieval\n"));
+	P(GT_("  -k, --keep        save new messages after retrieval\n"));
+	P(GT_("  -F, --flush       delete old messages from server\n"));
+	P(GT_("  -n, --norewrite   don't rewrite header addresses\n"));
+	P(GT_("  -l, --limit       don't fetch messages over given size\n"));
+	P(GT_("  -w, --warnings    interval between warning mail notification\n"));
 
 #if NET_SECURITY
-	P(_("  -T, --netsec      set IP security request\n"));
+	P(GT_("  -T, --netsec      set IP security request\n"));
 #endif /* NET_SECURITY */
-	P(_("  -S, --smtphost    set SMTP forwarding host\n"));
-	P(_("      --fetchdomains fetch mail for specified domains\n"));
-	P(_("  -D, --smtpaddress set SMTP delivery domain to use\n"));
-	P(_("      --smtpname    set SMTP full name username@domain\n"));
-	P(_("  -Z, --antispam,   set antispam response values\n"));
-	P(_("  -b, --batchlimit  set batch limit for SMTP connections\n"));
-	P(_("  -B, --fetchlimit  set fetch limit for server connections\n"));
-	P(_("  -e, --expunge     set max deletions between expunges\n"));
-        P(_("  -m, --mda         set MDA to use for forwarding\n"));
-        P(_("      --bsmtp       set output BSMTP file\n"));
-        P(_("      --lmtp        use LMTP (RFC2033) for delivery\n"));
-	P(_("  -r, --folder      specify remote folder name\n"));
-	P(_("      --showdots    show progress dots even in logfiles\n"));
+	P(GT_("  -S, --smtphost    set SMTP forwarding host\n"));
+	P(GT_("      --fetchdomains fetch mail for specified domains\n"));
+	P(GT_("  -D, --smtpaddress set SMTP delivery domain to use\n"));
+	P(GT_("      --smtpname    set SMTP full name username@domain\n"));
+	P(GT_("  -Z, --antispam,   set antispam response values\n"));
+	P(GT_("  -b, --batchlimit  set batch limit for SMTP connections\n"));
+	P(GT_("  -B, --fetchlimit  set fetch limit for server connections\n"));
+	P(GT_("  -e, --expunge     set max deletions between expunges\n"));
+        P(GT_("  -m, --mda         set MDA to use for forwarding\n"));
+        P(GT_("      --bsmtp       set output BSMTP file\n"));
+        P(GT_("      --lmtp        use LMTP (RFC2033) for delivery\n"));
+	P(GT_("  -r, --folder      specify remote folder name\n"));
+	P(GT_("      --showdots    show progress dots even in logfiles\n"));
 #undef P
 
 	if (helpflag)
diff --git a/pop3.c b/pop3.c
index 36173b4d..fac2b185 100644
--- a/pop3.c
+++ b/pop3.c
@@ -293,7 +293,7 @@ static int pop3_getauth(int sock, struct query *ctl, char *greeting)
 	    continue;
 	if (*start == 0) {
 	    report(stderr,
-		   _("Required APOP timestamp not found in greeting\n"));
+		   GT_("Required APOP timestamp not found in greeting\n"));
 	    return(PS_AUTHFAIL);
 	}
 
@@ -302,7 +302,7 @@ static int pop3_getauth(int sock, struct query *ctl, char *greeting)
 	    continue;
 	if (*end == 0 || end == start + 1) {
 	    report(stderr, 
-		   _("Timestamp syntax error in greeting\n"));
+		   GT_("Timestamp syntax error in greeting\n"));
 	    return(PS_AUTHFAIL);
 	}
 	else
@@ -324,7 +324,7 @@ static int pop3_getauth(int sock, struct query *ctl, char *greeting)
 	break;
 
     default:
-	report(stderr, _("Undefined protocol request in POP3_auth\n"));
+	report(stderr, GT_("Undefined protocol request in POP3_auth\n"));
 	ok = PS_ERROR;
     }
 
@@ -332,7 +332,7 @@ static int pop3_getauth(int sock, struct query *ctl, char *greeting)
     {
 	/* maybe we detected a lock-busy condition? */
         if (ok == PS_LOCKBUSY)
-	    report(stderr, _("lock busy!  Is another session active?\n")); 
+	    report(stderr, GT_("lock busy!  Is another session active?\n")); 
 
 	return(ok);
     }
@@ -440,7 +440,7 @@ static int pop3_slowuidl( int sock,  struct query *ctl, int *countp, int *newp)
 		}
 	    } else {
 		report(stderr, 
-		       _("Messages inserted into list on server. Cannot handle this.\n"));
+		       GT_("Messages inserted into list on server. Cannot handle this.\n"));
 		return -1;
 	    }
 	} 
@@ -511,7 +511,7 @@ static int pop3_getrange(int sock,
 	{
 	    if (sscanf(buf, "%d", &last) == 0)
 	    {
-		report(stderr, _("protocol error\n"));
+		report(stderr, GT_("protocol error\n"));
 		return(PS_ERROR);
 	    }
 	    *newp = (*countp - last);
@@ -524,7 +524,7 @@ static int pop3_getrange(int sock,
 		/* don't worry, yet! do it the slow way */
 		if((ok = pop3_slowuidl( sock, ctl, countp, newp))!=0)
 		{
-		    report(stderr, _("protocol error while fetching UIDLs\n"));
+		    report(stderr, GT_("protocol error while fetching UIDLs\n"));
 		    return(PS_ERROR);
 		}
 	    }
@@ -777,7 +777,7 @@ int doPOP3 (struct query *ctl)
 {
 #ifndef MBOX
     if (ctl->mailboxes->id) {
-	fprintf(stderr,_("Option --remote is not supported with POP3\n"));
+	fprintf(stderr,GT_("Option --remote is not supported with POP3\n"));
 	return(PS_SYNTAX);
     }
 #endif /* MBOX */
diff --git a/rcfile_y.y b/rcfile_y.y
index 523be003..7af94c63 100644
--- a/rcfile_y.y
+++ b/rcfile_y.y
@@ -117,7 +117,7 @@ statement	: SET LOGFILE optmap STRING	{run.logfile = xstrdup($4);}
 
 /* detect and complain about the most common user error */
 		| define_server serverspecs userspecs serv_option
-			{yyerror(_("server option after user options"));}
+			{yyerror(GT_("server option after user options"));}
 		;
 
 define_server	: POLL STRING		{reset_server($2, FALSE);}
@@ -162,7 +162,7 @@ serv_option	: AKA alias_list
 					    current.server.protocol = P_POP3;
 					    current.server.sdps = TRUE;
 #else
-					    yyerror(_("SDPS not enabled."));
+					    yyerror(GT_("SDPS not enabled."));
 #endif /* SDPS_ENABLE */
 					}
 		| UIDL			{current.server.uidl = FLAG_TRUE;}
@@ -210,27 +210,27 @@ serv_option	: AKA alias_list
 					    int requestlen;
 
 		    			    if (net_security_strtorequest($2, &request, &requestlen))
-						yyerror(_("invalid security request"));
+						yyerror(GT_("invalid security request"));
 					    else {
 						current.server.netsec = xstrdup($2);
 					        free(request);
 					    }
 #else
-					    yyerror(_("network-security support disabled"));
+					    yyerror(GT_("network-security support disabled"));
 #endif /* NET_SECURITY */
 					}
 		| INTERFACE STRING	{
 #if (defined(linux) && !defined(INET6_ENABLE)) || defined(__FreeBSD__)
 					interface_parse($2, &current.server);
 #else /* (defined(linux) && !defined(INET6_ENABLE)) || defined(__FreeBSD__) */
-					fprintf(stderr, _("fetchmail: interface option is only supported under Linux (without IPv6) and FreeBSD\n"));
+					fprintf(stderr, GT_("fetchmail: interface option is only supported under Linux (without IPv6) and FreeBSD\n"));
 #endif /* (defined(linux) && !defined(INET6_ENABLE)) || defined(__FreeBSD__) */
 					}
 		| MONITOR STRING	{
 #if (defined(linux) && !defined(INET6_ENABLE)) || defined(__FreeBSD__)
 					current.server.monitor = xstrdup($2);
 #else /* (defined(linux) && !defined(INET6_ENABLE)) || defined(__FreeBSD__) */
-					fprintf(stderr, _("fetchmail: monitor option is only supported under Linux (without IPv6) and FreeBSD\n"));
+					fprintf(stderr, GT_("fetchmail: monitor option is only supported under Linux (without IPv6) and FreeBSD\n"));
 #endif /* (defined(linux) && !defined(INET6_ENABLE) || defined(__FreeBSD__)) */
 					}
 		| PLUGIN STRING		{ current.server.plugin = xstrdup($2); }
@@ -381,8 +381,8 @@ static struct query *hosttail;	/* where to add new elements */
 void yyerror (const char *s)
 /* report a syntax error */
 {
-    report_at_line(stderr, 0, rcfile, prc_lineno, _("%s at %s"), s, 
-		   (yytext && yytext[0]) ? yytext : _("end of input"));
+    report_at_line(stderr, 0, rcfile, prc_lineno, GT_("%s at %s"), s, 
+		   (yytext && yytext[0]) ? yytext : GT_("end of input"));
     prc_errflag++;
 }
 
@@ -419,14 +419,14 @@ int prc_filecheck(const char *pathname, const flag securecheck)
 
     if ((statbuf.st_mode & S_IFLNK) == S_IFLNK)
     {
-	fprintf(stderr, _("File %s must not be a symbolic link.\n"), pathname);
+	fprintf(stderr, GT_("File %s must not be a symbolic link.\n"), pathname);
 	return(PS_IOERR);
     }
 
 #ifndef __BEOS__
     if (statbuf.st_mode & ~(S_IFREG | S_IREAD | S_IWRITE | S_IEXEC | S_IXGRP))
     {
-	fprintf(stderr, _("File %s must have no more than -rwx--x--- (0710) permissions.\n"), 
+	fprintf(stderr, GT_("File %s must have no more than -rwx--x--- (0710) permissions.\n"), 
 		pathname);
 	return(PS_IOERR);
     }
@@ -438,7 +438,7 @@ int prc_filecheck(const char *pathname, const flag securecheck)
     if (statbuf.st_uid != getuid())
 #endif /* HAVE_GETEUID */
     {
-	fprintf(stderr, _("File %s must be owned by you.\n"), pathname);
+	fprintf(stderr, GT_("File %s must be owned by you.\n"), pathname);
 	return(PS_IOERR);
     }
 #endif
diff --git a/report.c b/report.c
index 3947eb23..50637d7b 100644
--- a/report.c
+++ b/report.c
@@ -98,7 +98,7 @@ char *strerror (errnum)
 
   if (errnum > 0 && errnum <= sys_nerr)
     return sys_errlist[errnum];
-  return _("Unknown system error");
+  return GT_("Unknown system error");
 }
 # endif	/* HAVE_STRERROR */
 #endif	/* _LIBC */
@@ -125,7 +125,7 @@ report (FILE *errfp, message, va_alist)
   if (partial_message_size_used != 0)
     {
       partial_message_size_used = 0;
-      report (errfp, 0, _("%s (log message incomplete)"), partial_message);
+      report (errfp, 0, GT_("%s (log message incomplete)"), partial_message);
     }
 
 #if defined(HAVE_SYSLOG)
@@ -283,7 +283,7 @@ report_build (FILE *errfp, message, va_alist)
   if (partial_message_size_used >= partial_message_size)
     {
       partial_message_size_used = 0;
-      report (stderr, _("partial error message buffer overflow"));
+      report (stderr, GT_("partial error message buffer overflow"));
     }
 #endif
   va_end (args);
@@ -311,7 +311,7 @@ report_build (FILE *errfp, message, va_alist)
   if ((partial_message_size_used = strlen (partial_message)) >= partial_message_size)
     {
       partial_message_size_used = 0;
-      report (stderr, _("partial error message buffer overflow"));
+      report (stderr, GT_("partial error message buffer overflow"));
     }
 #endif
 #endif
@@ -383,7 +383,7 @@ report_complete (FILE *errfp, message, va_alist)
   if (partial_message_size_used >= partial_message_size)
     {
       partial_message_size_used = 0;
-      report (stderr, _("partial error message buffer overflow"));
+      report (stderr, GT_("partial error message buffer overflow"));
     }
 #endif
   va_end (args);
@@ -411,7 +411,7 @@ report_complete (FILE *errfp, message, va_alist)
   if ((partial_message_size_used = strlen (partial_message)) >= partial_message_size)
     {
       partial_message_size_used = 0;
-      report (stderr, _("partial error message buffer overflow"));
+      report (stderr, GT_("partial error message buffer overflow"));
     }
 #endif
 #endif
diff --git a/rfc822.c b/rfc822.c
index 7e110707..b71233aa 100644
--- a/rfc822.c
+++ b/rfc822.c
@@ -54,7 +54,7 @@ const unsigned char *host;	/* server hostname */
 
 #ifndef TESTMAIN
     if (outlevel >= O_DEBUG)
-	report_build(stdout, _("About to rewrite %s"), buf);
+	report_build(stdout, GT_("About to rewrite %s"), buf);
 
     /* make room to hack the address; buf must be malloced */
     for (cp = buf; *cp; cp++)
@@ -190,7 +190,7 @@ const unsigned char *host;	/* server hostname */
 
 #ifndef TESTMAIN
     if (outlevel >= O_DEBUG)
-	report_complete(stdout, _("Rewritten version is %s\n"), buf);
+	report_complete(stdout, GT_("Rewritten version is %s\n"), buf);
 #endif /* TESTMAIN */
     return(buf);
 }
diff --git a/sink.c b/sink.c
index aab220e6..43015f44 100644
--- a/sink.c
+++ b/sink.c
@@ -186,7 +186,7 @@ int smtp_open(struct query *ctl)
 	ctl->destaddr = ctl->smtpaddress ? ctl->smtpaddress : ( ctl->smtphost && ctl->smtphost[0] != '/' ? ctl->smtphost : "localhost");
 
     if (outlevel >= O_DEBUG && ctl->smtp_socket != -1)
-	report(stdout, _("forwarding to %s\n"), ctl->smtphost);
+	report(stdout, GT_("forwarding to %s\n"), ctl->smtphost);
 
     return(ctl->smtp_socket);
 }
@@ -321,10 +321,10 @@ static int send_bouncemail(struct query *ctl, struct msgblk *msg,
 	    (int)getpid(), (int)getppid(), time((time_t *)NULL));
 
     if (outlevel >= O_VERBOSE)
-	report(stdout, _("SMTP: (bounce-message body)\n"));
+	report(stdout, GT_("SMTP: (bounce-message body)\n"));
     else
 	/* this will usually go to sylog... */
-	report(stderr, _("mail from %s bounced to %s\n"),
+	report(stderr, GT_("mail from %s bounced to %s\n"),
 	       daemon_name, bounce_to);
 
     /* bouncemail headers */
@@ -426,7 +426,7 @@ static int handle_smtp_report(struct query *ctl, struct msgblk *msg)
      */
     SMTP_rset(ctl->smtp_socket);    /* stay on the safe side */
     if (outlevel >= O_DEBUG)
-	report(stdout, _("Saved error is still %d\n"), smtperr);
+	report(stdout, GT_("Saved error is still %d\n"), smtperr);
 #endif /* __UNUSED */
 
     /*
@@ -471,7 +471,7 @@ static int handle_smtp_report(struct query *ctl, struct msgblk *msg)
      * an error when the return code is less specific.
      */
     if (smtperr >= 400)
-	report(stderr, _("%cMTP error: %s\n"), 
+	report(stderr, GT_("%cMTP error: %s\n"), 
 	      ctl->listener,
 	      responses[0]);
 
@@ -589,7 +589,7 @@ int open_sink(struct query *ctl, struct msgblk *msg,
 
 	if (ferror(sinkfp))
 	{
-	    report(stderr, _("BSMTP file open or preamble write failed\n"));
+	    report(stderr, GT_("BSMTP file open or preamble write failed\n"));
 	    return(PS_BSMTP);
 	}
     }
@@ -714,7 +714,7 @@ int open_sink(struct query *ctl, struct msgblk *msg,
 		    idp->val.status.mark = XMIT_RCPTBAD;
 		    if (outlevel >= O_VERBOSE)
 			report(stderr, 
-			      _("%cMTP listener doesn't like recipient address `%s'\n"),
+			      GT_("%cMTP listener doesn't like recipient address `%s'\n"),
 			      ctl->listener, addr);
 		}
 	    }
@@ -731,7 +731,7 @@ int open_sink(struct query *ctl, struct msgblk *msg,
 	    if (!run.postmaster[0])
 	    {
 		if (outlevel >= O_VERBOSE)
-		    report(stderr, _("no address matches; no postmaster set.\n"));
+		    report(stderr, GT_("no address matches; no postmaster set.\n"));
 		SMTP_rset(ctl->smtp_socket);	/* required by RFC1870 */
 		return(PS_REFUSED);
 	    }
@@ -748,13 +748,13 @@ int open_sink(struct query *ctl, struct msgblk *msg,
 
 	    if (SMTP_rcpt(ctl->smtp_socket, addr) != SM_OK)
 	    {
-		report(stderr, _("can't even send to %s!\n"), run.postmaster);
+		report(stderr, GT_("can't even send to %s!\n"), run.postmaster);
 		SMTP_rset(ctl->smtp_socket);	/* required by RFC1870 */
 		return(PS_REFUSED);
 	    }
 
 	    if (outlevel >= O_VERBOSE)
-		report(stderr, _("no address matches; forwarding to %s.\n"), run.postmaster);
+		report(stderr, GT_("no address matches; forwarding to %s.\n"), run.postmaster);
 	}
 
 	/* 
@@ -775,7 +775,7 @@ int open_sink(struct query *ctl, struct msgblk *msg,
      */
     else if (!ctl->mda)
     {
-	report(stderr, _("%cMTP connect to %s failed\n"),
+	report(stderr, GT_("%cMTP connect to %s failed\n"),
 	       ctl->listener,
 	       ctl->smtphost ? ctl->smtphost : "localhost");
 
@@ -796,7 +796,7 @@ int open_sink(struct query *ctl, struct msgblk *msg,
 	 */
 	ctl->mda = FALLBACK_MDA;
 
-	report(stderr, _("can't raise the listener; falling back to %s"),
+	report(stderr, GT_("can't raise the listener; falling back to %s"),
 			 FALLBACK_MDA);
 #endif
     }
@@ -918,7 +918,7 @@ int open_sink(struct query *ctl, struct msgblk *msg,
 
 
 	if (outlevel >= O_DEBUG)
-	    report(stdout, _("about to deliver with: %s\n"), before);
+	    report(stdout, GT_("about to deliver with: %s\n"), before);
 
 #ifdef HAVE_SETEUID
 	/*
@@ -941,7 +941,7 @@ int open_sink(struct query *ctl, struct msgblk *msg,
 
 	if (!sinkfp)
 	{
-	    report(stderr, _("MDA open failed\n"));
+	    report(stderr, GT_("MDA open failed\n"));
 	    return(PS_IOERR);
 	}
 
@@ -1006,7 +1006,7 @@ int close_sink(struct query *ctl, struct msgblk *msg, flag forward)
 	if (rc)
 	{
 	    report(stderr, 
-		   _("MDA returned nonzero status %d\n"), rc);
+		   GT_("MDA returned nonzero status %d\n"), rc);
 	    return(FALSE);
 	}
     }
@@ -1022,7 +1022,7 @@ int close_sink(struct query *ctl, struct msgblk *msg, flag forward)
 	if (error)
 	{
 	    report(stderr, 
-		   _("Message termination or close of BSMTP file failed\n"));
+		   GT_("Message termination or close of BSMTP file failed\n"));
 	    return(FALSE);
 	}
     }
@@ -1038,7 +1038,7 @@ int close_sink(struct query *ctl, struct msgblk *msg, flag forward)
 	    }
 	    else
 	    {
-		report(stderr, _("SMTP listener refused delivery\n"));
+		report(stderr, GT_("SMTP listener refused delivery\n"));
 	        SMTP_rset(ctl->smtp_socket);    /* stay on the safe side */
 		return(TRUE);
 	    }
@@ -1068,10 +1068,10 @@ int close_sink(struct query *ctl, struct msgblk *msg, flag forward)
 		 * comply.
 		 */
 		if (atoi(smtp_response) == 503)
-		    report(stderr, _("LMTP delivery error on EOM\n"));
+		    report(stderr, GT_("LMTP delivery error on EOM\n"));
 		else
 		    report(stderr,
-			  _("Unexpected non-503 response to LMTP EOM: %s\n"),
+			  GT_("Unexpected non-503 response to LMTP EOM: %s\n"),
 			  smtp_response);
 
 		/*
@@ -1209,7 +1209,7 @@ va_dcl
 void close_warning_by_mail(struct query *ctl, struct msgblk *msg)
 /* sign and send mailed warnings */
 {
-    stuff_warning(ctl, _("--\r\n\t\t\t\tThe Fetchmail Daemon\r\n"));
+    stuff_warning(ctl, GT_("--\r\n\t\t\t\tThe Fetchmail Daemon\r\n"));
     close_sink(ctl, msg, TRUE);
 }
 
diff --git a/socket.c b/socket.c
index 3ae38016..c108b9b2 100644
--- a/socket.c
+++ b/socket.c
@@ -97,7 +97,7 @@ char *const *parse_plugin(const char *plugin, const char *host, const char *serv
 	plugin_copy = malloc(plugin_copy_len + 1);
 	if (!plugin_copy)
 	{
-		report(stderr, _("fetchmail: malloc failed\n"));
+		report(stderr, GT_("fetchmail: malloc failed\n"));
 		return NULL;
 	}
 
@@ -123,7 +123,7 @@ char *const *parse_plugin(const char *plugin, const char *host, const char *serv
 	argvec = malloc(s);
 	if (!argvec)
 	{
-		report(stderr, _("fetchmail: malloc failed\n"));
+		report(stderr, GT_("fetchmail: malloc failed\n"));
 		return NULL;
 	}
 	memset(argvec, 0, s);
@@ -155,13 +155,13 @@ static int handle_plugin(const char *host,
      */
     if (socketpair(AF_UNIX,SOCK_STREAM,0,fds))
     {
-	report(stderr, _("fetchmail: socketpair failed\n"));
+	report(stderr, GT_("fetchmail: socketpair failed\n"));
 	return -1;
     }
     switch (fork()) {
 	case -1:
 		/* error */
-		report(stderr, _("fetchmail: fork failed\n"));
+		report(stderr, GT_("fetchmail: fork failed\n"));
 		return -1;
 		break;
 	case 0:	/* child */
@@ -169,16 +169,16 @@ static int handle_plugin(const char *host,
 		** detection */
 		(void) close(fds[1]);
 		if ( (dup2(fds[0],0) == -1) || (dup2(fds[0],1) == -1) ) {
-			report(stderr, _("dup2 failed\n"));
+			report(stderr, GT_("dup2 failed\n"));
 			exit(1);
 		}
 		/* fds[0] is now connected to 0 and 1; close it */
 		(void) close(fds[0]);
 		if (outlevel >= O_VERBOSE)
-		    report(stderr, _("running %s (host %s service %s)\n"), plugin, host, service);
+		    report(stderr, GT_("running %s (host %s service %s)\n"), plugin, host, service);
 		argvec = parse_plugin(plugin,host,service);
 		execvp(*argvec, argvec);
-		report(stderr, _("execvp(%s) failed\n"), *argvec);
+		report(stderr, GT_("execvp(%s) failed\n"), *argvec);
 		exit(0);
 		break;
 	default:	/* parent */
@@ -260,7 +260,7 @@ int SockOpen(const char *host, const char *service, const char *options,
     req.ai_socktype = SOCK_STREAM;
 
     if (getaddrinfo(host, service, &req, &ai0)) {
-	report(stderr, _("fetchmail: getaddrinfo(%s.%s)\n"), host,service);
+	report(stderr, GT_("fetchmail: getaddrinfo(%s.%s)\n"), host,service);
 	return -1;
     }
 
@@ -385,7 +385,7 @@ int SockOpen(const char *host, int clientPort, const char *options,
 	{
 	    h_errno = errno = 0;
 	    report(stderr, 
-		   _("fetchmail: illegal address length received for host %s\n"),host);
+		   GT_("fetchmail: illegal address length received for host %s\n"),host);
 	    return -1;
 	}
 	/*
@@ -683,25 +683,25 @@ int SSL_verify_callback( int ok_return, X509_STORE_CTX *ctx, int strict )
 		
 		if (outlevel == O_VERBOSE) {
 			if ((i = X509_NAME_get_text_by_NID(issuer, NID_organizationName, buf, sizeof(buf))) != -1) {
-				report(stdout, _("Issuer Organization: %s\n"), buf);
+				report(stdout, GT_("Issuer Organization: %s\n"), buf);
 				if (i >= sizeof(buf) - 1)
-					report(stdout, _("Warning: Issuer Organization Name too long (possibly truncated).\n"));
+					report(stdout, GT_("Warning: Issuer Organization Name too long (possibly truncated).\n"));
 			} else
-				report(stdout, _("Unknown Organization\n"));
+				report(stdout, GT_("Unknown Organization\n"));
 			if ((i = X509_NAME_get_text_by_NID(issuer, NID_commonName, buf, sizeof(buf))) != -1) {
-				report(stdout, _("Issuer CommonName: %s\n"), buf);
+				report(stdout, GT_("Issuer CommonName: %s\n"), buf);
 				if (i >= sizeof(buf) - 1)
-					report(stdout, _("Warning: Issuer CommonName too long (possibly truncated).\n"));
+					report(stdout, GT_("Warning: Issuer CommonName too long (possibly truncated).\n"));
 			} else
-				report(stdout, _("Unknown Issuer CommonName\n"));
+				report(stdout, GT_("Unknown Issuer CommonName\n"));
 		}
 		if ((i = X509_NAME_get_text_by_NID(subj, NID_commonName, buf, sizeof(buf))) != -1) {
 			if (outlevel == O_VERBOSE)
-				report(stdout, _("Server CommonName: %s\n"), buf);
+				report(stdout, GT_("Server CommonName: %s\n"), buf);
 			if (i >= sizeof(buf) - 1) {
 				/* Possible truncation. In this case, this is a DNS name, so this
 				 * is really bad. We do not tolerate this even in the non-strict case. */
-				report(stderr, _("Bad certificate: Subject CommonName too long!\n"));
+				report(stderr, GT_("Bad certificate: Subject CommonName too long!\n"));
 				return (0);
 			}
 			if (_ssl_server_cname != NULL) {
@@ -717,20 +717,20 @@ int SSL_verify_callback( int ok_return, X509_STORE_CTX *ctx, int strict )
 				}	
 				if (0 != strcasecmp(p1, p2)) {
 					report(stderr,
-					    _("Server CommonName mismatch: %s != %s\n"),
+					    GT_("Server CommonName mismatch: %s != %s\n"),
 					    buf, _ssl_server_cname );
 					if (ok_return && strict)
 						return (0);
 				}
 			} else if (ok_return && strict) {
-				report(stderr, _("Server name not set, could not verify certificate!\n"));
+				report(stderr, GT_("Server name not set, could not verify certificate!\n"));
 				return (0);
 			}
 		} else {
 			if (outlevel == O_VERBOSE)
-				report(stdout, _("Unknown Server CommonName\n"));
+				report(stdout, GT_("Unknown Server CommonName\n"));
 			if (ok_return && strict) {
-				report(stderr, _("Server name not specified in certificate!\n"));
+				report(stderr, GT_("Server name not specified in certificate!\n"));
 				return (0);
 			}
 		}
@@ -740,11 +740,11 @@ int SSL_verify_callback( int ok_return, X509_STORE_CTX *ctx, int strict )
 			_check_fp = 0;
 			digest_tp = EVP_md5();
 			if (digest_tp == NULL) {
-				report(stderr, _("EVP_md5() failed!\n"));
+				report(stderr, GT_("EVP_md5() failed!\n"));
 				return (0);
 			}
 			if (!X509_digest(x509_cert, digest_tp, digest, &dsz)) {
-				report(stderr, _("Out of memory!\n"));
+				report(stderr, GT_("Out of memory!\n"));
 				return (0);
 			}
 			tp = text;
@@ -756,17 +756,17 @@ int SSL_verify_callback( int ok_return, X509_STORE_CTX *ctx, int strict )
 				esz = sprintf(tp, i > 0 ? ":%02X" : "%02X", digest[i]);
 #endif
 				if (esz >= te - tp) {
-					report(stderr, _("Digest text buffer too small!\n"));
+					report(stderr, GT_("Digest text buffer too small!\n"));
 					return (0);
 				}
 				tp += esz;
 			}
-			report(stdout, _("%s key fingerprint: %s\n"), _server_label, text);
+			report(stdout, GT_("%s key fingerprint: %s\n"), _server_label, text);
 			if (_check_digest != NULL) {
 				if (strcmp(text, _check_digest) == 0)
-					report(stdout, _("%s fingerprints match.\n"), _server_label);
+					report(stdout, GT_("%s fingerprints match.\n"), _server_label);
 				else {
-					report(stderr, _("%s fingerprints do not match!\n"), _server_label);
+					report(stderr, GT_("%s fingerprints do not match!\n"), _server_label);
 					return (0);
 				}
 			}
@@ -774,13 +774,13 @@ int SSL_verify_callback( int ok_return, X509_STORE_CTX *ctx, int strict )
 	}
 
 	if (err != X509_V_OK && (strict || outlevel == O_VERBOSE)) {
-		report(strict ? stderr : stdout, _("Warning: server certificate verification: %s\n"), X509_verify_cert_error_string(err));
+		report(strict ? stderr : stdout, GT_("Warning: server certificate verification: %s\n"), X509_verify_cert_error_string(err));
 		/* We gave the error code, but maybe we can add some more details for debugging */
 		switch (err) {
 		case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
 			X509_NAME_oneline(issuer, buf, sizeof(buf));
 			buf[sizeof(buf) - 1] = '\0';
-			report(stdout, _("unknown issuer (first %d characters): %s\n"), sizeof(buf), buf);
+			report(stdout, GT_("unknown issuer (first %d characters): %s\n"), sizeof(buf), buf);
 			break;
 		}
 	}
@@ -812,7 +812,7 @@ int SSLOpen(int sock, char *mycert, char *mykey, char *myproto, int certck, char
 	SSLeay_add_ssl_algorithms();
 	
 	if( sock < 0 || sock > FD_SETSIZE ) {
-		report(stderr, _("File descriptor out of range for SSL") );
+		report(stderr, GT_("File descriptor out of range for SSL") );
 		return( -1 );
 	}
 
@@ -827,7 +827,7 @@ int SSLOpen(int sock, char *mycert, char *mykey, char *myproto, int certck, char
 			} else if(!strcmp("tls1",myproto)) {
 				_ctx = SSL_CTX_new(TLSv1_client_method());
 			} else {
-				fprintf(stderr,_("Invalid SSL protocol '%s' specified, using default (SSLv23).\n"), myproto);
+				fprintf(stderr,GT_("Invalid SSL protocol '%s' specified, using default (SSLv23).\n"), myproto);
 				myproto = NULL;
 			}
 		}
@@ -887,7 +887,7 @@ int SSLOpen(int sock, char *mycert, char *mykey, char *myproto, int certck, char
 
 	/* Paranoia: was the callback not called as we expected? */
 	if ((fingerprint != NULL || certck) && !_depth0ck) {
-		report(stderr, _("Certificate/fingerprint verification was somehow skipped!\n"));
+		report(stderr, GT_("Certificate/fingerprint verification was somehow skipped!\n"));
 		
 		if( NULL != ( ssl = SSLGetContext( sock ) ) ) {
 			/* Clean up the SSL stack */
diff --git a/transact.c b/transact.c
index 10db25fb..73629a63 100644
--- a/transact.c
+++ b/transact.c
@@ -66,7 +66,7 @@ static void map_name(const char *name, struct query *ctl, struct idlist **xmit_n
     if (lname != (char *)NULL)
     {
 	if (outlevel >= O_DEBUG)
-	    report(stdout, _("mapped %s to local %s\n"), name, lname);
+	    report(stdout, GT_("mapped %s to local %s\n"), name, lname);
 	save_str(xmit_names, lname, XMIT_ACCEPT);
 	accept_count++;
     }
@@ -123,7 +123,7 @@ static void find_server_names(const char *hdr,
 			strcasecmp(rhs, idp->id) == 0)
 		    {
 			if (outlevel >= O_DEBUG)
-			    report(stdout, _("passed through %s matching %s\n"), 
+			    report(stdout, GT_("passed through %s matching %s\n"), 
 				  cp, idp->id);
 			save_str(xmit_names, cp, XMIT_ACCEPT);
 			accept_count++;
@@ -190,7 +190,7 @@ static char *parse_received(struct query *ctl, char *bufp)
      * does this when the mail has a single recipient.
      */
     if (outlevel >= O_DEBUG)
-	report(stdout, _("analyzing Received line:\n%s"), bufp);
+	report(stdout, GT_("analyzing Received line:\n%s"), bufp);
 
     /* search for whitepace-surrounded "by" followed by valid address */
     for (base = bufp;  ; base = ok + 2)
@@ -229,13 +229,13 @@ static char *parse_received(struct query *ctl, char *bufp)
 	{
 	    if (outlevel >= O_DEBUG)
 		report(stdout, 
-		      _("line accepted, %s is an alias of the mailserver\n"), rbuf);
+		      GT_("line accepted, %s is an alias of the mailserver\n"), rbuf);
 	}
 	else
 	{
 	    if (outlevel >= O_DEBUG)
 		report(stdout, 
-		      _("line rejected, %s is not an alias of the mailserver\n"), 
+		      GT_("line rejected, %s is not an alias of the mailserver\n"), 
 		      rbuf);
 	    return(NULL);
 	}
@@ -306,7 +306,7 @@ static char *parse_received(struct query *ctl, char *bufp)
     if (!ok)
     {
 	if (outlevel >= O_DEBUG)
-	    report(stdout, _("no Received address found\n"));
+	    report(stdout, GT_("no Received address found\n"));
 	return(NULL);
     }
     else
@@ -315,7 +315,7 @@ static char *parse_received(struct query *ctl, char *bufp)
 	    char *lf = rbuf + strlen(rbuf)-1;
 	    *lf = '\0';
 	    if (outlevel >= O_DEBUG)
-		report(stdout, _("found Received address `%s'\n"), rbuf+2);
+		report(stdout, GT_("found Received address `%s'\n"), rbuf+2);
 	    *lf = '\n';
 	}
 	return(rbuf);
@@ -820,7 +820,7 @@ int readheaders(int sock,
     {
 	if (outlevel > O_SILENT)
 	    report(stdout,
-		   _("message delimiter found while scanning headers\n"));
+		   GT_("message delimiter found while scanning headers\n"));
     }
 
     /*
@@ -958,7 +958,7 @@ int readheaders(int sock,
 	    save_str(&msgblk.recipients, run.postmaster, XMIT_ACCEPT);
 	    if (outlevel >= O_DEBUG)
 		report(stdout,
-		      _("no local matches, forwarding to %s\n"),
+		      GT_("no local matches, forwarding to %s\n"),
 		      run.postmaster);
 	}
     }
@@ -973,7 +973,7 @@ int readheaders(int sock,
     {
 	if (outlevel >= O_DEBUG)
 	    report(stdout,
-		   _("forwarding and deletion suppressed due to DNS errors\n"));
+		   GT_("forwarding and deletion suppressed due to DNS errors\n"));
 	free(msgblk.headers);
 	msgblk.headers = NULL;
 	free_str_list(&msgblk.recipients);
@@ -1122,7 +1122,7 @@ int readheaders(int sock,
 
     if (n == -1)
     {
-	report(stdout, _("writing RFC822 msgblk.headers\n"));
+	report(stdout, GT_("writing RFC822 msgblk.headers\n"));
 	release_sink(ctl);
 	free(msgblk.headers);
 	msgblk.headers = NULL;
@@ -1143,13 +1143,13 @@ int readheaders(int sock,
 	if (no_local_matches)
 	{
 	    if (reject_count != 1)
-		strcat(errhd, _("no recipient addresses matched declared local names"));
+		strcat(errhd, GT_("no recipient addresses matched declared local names"));
 	    else
 	    {
 		for (idp = msgblk.recipients; idp; idp = idp->next)
 		    if (idp->val.status.mark == XMIT_REJECT)
 			break;
-		sprintf(errhd+strlen(errhd), _("recipient address %s didn't match any local name"), idp->id);
+		sprintf(errhd+strlen(errhd), GT_("recipient address %s didn't match any local name"), idp->id);
 	    }
 	}
 
@@ -1157,14 +1157,14 @@ int readheaders(int sock,
 	{
 	    if (errhd[sizeof("X-Fetchmail-Warning: ")])
 		strcat(errhd, "; ");
-	    strcat(errhd, _("message has embedded NULs"));
+	    strcat(errhd, GT_("message has embedded NULs"));
 	}
 
 	if (bad_addresses)
 	{
 	    if (errhd[sizeof("X-Fetchmail-Warning: ")])
 		strcat(errhd, "; ");
-	    strcat(errhd, _("SMTP listener rejected local recipient addresses: "));
+	    strcat(errhd, GT_("SMTP listener rejected local recipient addresses: "));
 	    errlen = strlen(errhd);
 	    for (idp = msgblk.recipients; idp; idp = idp->next)
 		if (idp->val.status.mark == XMIT_RCPTBAD)
@@ -1293,7 +1293,7 @@ int readbody(int sock, struct query *ctl, flag forward, int len)
 
 	    if (n < 0)
 	    {
-		report(stdout, _("writing message text\n"));
+		report(stdout, GT_("writing message text\n"));
 		release_sink(ctl);
 		return(PS_IOERR);
 	    }
diff --git a/uid.c b/uid.c
index 57837bab..a33f21b6 100644
--- a/uid.c
+++ b/uid.c
@@ -94,7 +94,7 @@ void initialize_saved_lists(struct query *hostlist, const char *idfile)
    if (lstat(idfile, &statbuf) < 0) {
      if (errno == ENOTDIR) 
     {
-      report(stderr, _("lstat: %s: %s\n"), idfile, strerror(errno));
+      report(stderr, GT_("lstat: %s: %s\n"), idfile, strerror(errno));
       exit(PS_IOERR);
     }
    }
@@ -209,23 +209,23 @@ void initialize_saved_lists(struct query *hostlist, const char *idfile)
 	for (ctl = hostlist; ctl; ctl = ctl->next)
 	    if (ctl->server.uidl)
 	    {
-		report_build(stdout, _("Old UID list from %s:"), 
+		report_build(stdout, GT_("Old UID list from %s:"), 
 			     ctl->server.pollname);
 		for (idp = ctl->oldsaved; idp; idp = idp->next)
 		    report_build(stdout, " %s", idp->id);
 		if (!idp)
-		    report_build(stdout, _(" <empty>"));
+		    report_build(stdout, GT_(" <empty>"));
 		report_complete(stdout, "\n");
 		uidlcount++;
 	    }
 
 	if (uidlcount)
 	{
-	    report_build(stdout, _("Scratch list of UIDs:"));
+	    report_build(stdout, GT_("Scratch list of UIDs:"));
 	    for (idp = scratchlist; idp; idp = idp->next)
 		report_build(stdout, " %s", idp->id);
 	    if (!idp)
-		report_build(stdout, _(" <empty>"));
+		report_build(stdout, GT_(" <empty>"));
 	    report_complete(stdout, "\n");
 	}
     }
@@ -448,11 +448,11 @@ void uid_swap_lists(struct query *ctl)
     {
 	struct idlist *idp;
 
-	report_build(stdout, _("New UID list from %s:"), ctl->server.pollname);
+	report_build(stdout, GT_("New UID list from %s:"), ctl->server.pollname);
 	for (idp = ctl->newsaved; idp; idp = idp->next)
 	    report_build(stdout, " %s = %d", idp->id, idp->val.status.mark);
 	if (!idp)
-	    report_build(stdout, _(" <empty>"));
+	    report_build(stdout, GT_(" <empty>"));
 	report_complete(stdout, "\n");
     }
 
@@ -476,13 +476,13 @@ void uid_swap_lists(struct query *ctl)
     {
 	/* old state of mailbox may now be irrelevant */
 	if (outlevel >= O_DEBUG)
-	    report(stdout, _("swapping UID lists\n"));
+	    report(stdout, GT_("swapping UID lists\n"));
 	free_str_list(&ctl->oldsaved);
 	ctl->oldsaved = ctl->newsaved;
 	ctl->newsaved = (struct idlist *) NULL;
     }
     else if (outlevel >= O_DEBUG)
-	report(stdout, _("not swapping UID lists, no UIDs seen this query\n"));
+	report(stdout, GT_("not swapping UID lists, no UIDs seen this query\n"));
 }
 
 void write_saved_lists(struct query *hostlist, const char *idfile)
@@ -506,13 +506,13 @@ void write_saved_lists(struct query *hostlist, const char *idfile)
     if (!idcount && !scratchlist)
     {
 	if (outlevel >= O_DEBUG)
-	    report(stdout, _("Deleting fetchids file.\n"));
+	    report(stdout, GT_("Deleting fetchids file.\n"));
 	unlink(idfile);
     }
     else
     {
 	if (outlevel >= O_DEBUG)
-	    report(stdout, _("Writing fetchids file.\n"));
+	    report(stdout, GT_("Writing fetchids file.\n"));
 	if ((tmpfp = fopen(idfile, "w")) != (FILE *)NULL) {
 	    for (ctl = hostlist; ctl; ctl = ctl->next) {
 		for (idp = ctl->oldsaved; idp; idp = idp->next)
diff --git a/xmalloc.c b/xmalloc.c
index 4cd9d40e..74365586 100644
--- a/xmalloc.c
+++ b/xmalloc.c
@@ -29,7 +29,7 @@ xmalloc (int n)
     p = (XMALLOCTYPE *) malloc(n);
     if (p == (XMALLOCTYPE *) 0)
     {
-	report(stderr, _("malloc failed\n"));
+	report(stderr, GT_("malloc failed\n"));
 	exit(PS_UNDEFINED);
     }
     return(p);
@@ -43,7 +43,7 @@ xrealloc (XMALLOCTYPE *p, int n)
     p = (XMALLOCTYPE *) realloc(p, n);
     if (p == (XMALLOCTYPE *) 0)
     {
-	report(stderr, _("realloc failed\n"));
+	report(stderr, GT_("realloc failed\n"));
 	exit(PS_UNDEFINED);
     }
     return p;