<html lang="en">
<head>
<title>Yes-or-No Questions - The GNU C Library</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="The GNU C Library">
<meta name="generator" content="makeinfo 4.13">
<link title="Top" rel="start" href="index.html#Top">
<link rel="up" href="Locales.html#Locales" title="Locales">
<link rel="prev" href="Formatting-Numbers.html#Formatting-Numbers" title="Formatting Numbers">
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">
<!--
This file documents the GNU C library.

This is Edition 0.12, last updated 2007-10-27,
of `The GNU C Library Reference Manual', for version
2.8 (Sourcery G++ Lite 2011.03-41).

Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002,
2003, 2007, 2008, 2010 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with the
Invariant Sections being ``Free Software Needs Free Documentation''
and ``GNU Lesser General Public License'', the Front-Cover texts being
``A GNU Manual'', and with the Back-Cover Texts as in (a) below.  A
copy of the license is included in the section entitled "GNU Free
Documentation License".

(a) The FSF's Back-Cover Text is: ``You have the freedom to
copy and modify this GNU manual.  Buying copies from the FSF
supports it in developing GNU and promoting software freedom.''-->
<meta http-equiv="Content-Style-Type" content="text/css">
<style type="text/css"><!--
  pre.display { font-family:inherit }
  pre.format  { font-family:inherit }
  pre.smalldisplay { font-family:inherit; font-size:smaller }
  pre.smallformat  { font-family:inherit; font-size:smaller }
  pre.smallexample { font-size:smaller }
  pre.smalllisp    { font-size:smaller }
  span.sc    { font-variant:small-caps }
  span.roman { font-family:serif; font-weight:normal; } 
  span.sansserif { font-family:sans-serif; font-weight:normal; } 
--></style>
<link rel="stylesheet" type="text/css" href="../cs.css">
</head>
<body>
<div class="node">
<a name="Yes-or-No-Questions"></a>
<a name="Yes_002dor_002dNo-Questions"></a>
<p>
Previous:&nbsp;<a rel="previous" accesskey="p" href="Formatting-Numbers.html#Formatting-Numbers">Formatting Numbers</a>,
Up:&nbsp;<a rel="up" accesskey="u" href="Locales.html#Locales">Locales</a>
<hr>
</div>

<h3 class="section">7.8 Yes-or-No Questions</h3>

<p>Some non GUI programs ask a yes-or-no question.  If the messages
(especially the questions) are translated into foreign languages, be
sure that you localize the answers too.  It would be very bad habit to
ask a question in one language and request the answer in another, often
English.

   <p>The GNU C library contains <code>rpmatch</code> to give applications easy
access to the corresponding locale definitions.

<!-- GNU -->
<!-- stdlib.h -->
<div class="defun">
&mdash; Function: int <b>rpmatch</b> (<var>const char *response</var>)<var><a name="index-rpmatch-799"></a></var><br>
<blockquote><p>The function <code>rpmatch</code> checks the string in <var>response</var> whether
or not it is a correct yes-or-no answer and if yes, which one.  The
check uses the <code>YESEXPR</code> and <code>NOEXPR</code> data in the
<code>LC_MESSAGES</code> category of the currently selected locale.  The
return value is as follows:

          <dl>
<dt><code>1</code><dd>The user entered an affirmative answer.

          <br><dt><code>0</code><dd>The user entered a negative answer.

          <br><dt><code>-1</code><dd>The answer matched neither the <code>YESEXPR</code> nor the <code>NOEXPR</code>
regular expression. 
</dl>

        <p>This function is not standardized but available beside in GNU libc at
least also in the IBM AIX library. 
</p></blockquote></div>

<p class="noindent">This function would normally be used like this:

<pre class="smallexample">       ...
       /* <span class="roman">Use a safe default.</span>  */
       _Bool doit = false;
     
       fputs (gettext ("Do you really want to do this? "), stdout);
       fflush (stdout);
       /* <span class="roman">Prepare the </span><code>getline</code><span class="roman"> call.</span>  */
       line = NULL;
       len = 0;
       while (getline (&amp;line, &amp;len, stdin) &gt;= 0)
         {
           /* <span class="roman">Check the response.</span>  */
           int res = rpmatch (line);
           if (res &gt;= 0)
             {
               /* <span class="roman">We got a definitive answer.</span>  */
               if (res &gt; 0)
                 doit = true;
               break;
             }
         }
       /* <span class="roman">Free what </span><code>getline</code><span class="roman"> allocated.</span>  */
       free (line);
</pre>
   <p>Note that the loop continues until an read error is detected or until a
definitive (positive or negative) answer is read.

   </body></html>

