(start_scd): Do not register an event signal if we
[gnupg.git] / intl / eval-plural.h
1 /* Plural expression evaluation.
2    Copyright (C) 2000-2002 Free Software Foundation, Inc.
3
4    This program is free software; you can redistribute it and/or modify it
5    under the terms of the GNU Library General Public License as published
6    by the Free Software Foundation; either version 2, or (at your option)
7    any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Library General Public License for more details.
13
14    You should have received a copy of the GNU Library General Public
15    License along with this program; if not, write to the Free Software
16    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
17    USA.  */
18
19 #ifndef STATIC
20 #define STATIC static
21 #endif
22
23 /* Evaluate the plural expression and return an index value.  */
24 STATIC unsigned long int plural_eval PARAMS ((struct expression *pexp,
25                                               unsigned long int n))
26      internal_function;
27
28 STATIC
29 unsigned long int
30 internal_function
31 plural_eval (pexp, n)
32      struct expression *pexp;
33      unsigned long int n;
34 {
35   switch (pexp->nargs)
36     {
37     case 0:
38       switch (pexp->operation)
39         {
40         case var:
41           return n;
42         case num:
43           return pexp->val.num;
44         default:
45           break;
46         }
47       /* NOTREACHED */
48       break;
49     case 1:
50       {
51         /* pexp->operation must be lnot.  */
52         unsigned long int arg = plural_eval (pexp->val.args[0], n);
53         return ! arg;
54       }
55     case 2:
56       {
57         unsigned long int leftarg = plural_eval (pexp->val.args[0], n);
58         if (pexp->operation == lor)
59           return leftarg || plural_eval (pexp->val.args[1], n);
60         else if (pexp->operation == land)
61           return leftarg && plural_eval (pexp->val.args[1], n);
62         else
63           {
64             unsigned long int rightarg = plural_eval (pexp->val.args[1], n);
65
66             switch (pexp->operation)
67               {
68               case mult:
69                 return leftarg * rightarg;
70               case divide:
71 #if !INTDIV0_RAISES_SIGFPE
72                 if (rightarg == 0)
73                   raise (SIGFPE);
74 #endif
75                 return leftarg / rightarg;
76               case module:
77 #if !INTDIV0_RAISES_SIGFPE
78                 if (rightarg == 0)
79                   raise (SIGFPE);
80 #endif
81                 return leftarg % rightarg;
82               case plus:
83                 return leftarg + rightarg;
84               case minus:
85                 return leftarg - rightarg;
86               case less_than:
87                 return leftarg < rightarg;
88               case greater_than:
89                 return leftarg > rightarg;
90               case less_or_equal:
91                 return leftarg <= rightarg;
92               case greater_or_equal:
93                 return leftarg >= rightarg;
94               case equal:
95                 return leftarg == rightarg;
96               case not_equal:
97                 return leftarg != rightarg;
98               default:
99                 break;
100               }
101           }
102         /* NOTREACHED */
103         break;
104       }
105     case 3:
106       {
107         /* pexp->operation must be qmop.  */
108         unsigned long int boolarg = plural_eval (pexp->val.args[0], n);
109         return plural_eval (pexp->val.args[boolarg ? 1 : 2], n);
110       }
111     }
112   /* NOTREACHED */
113   return 0;
114 }