← Back to branch summary

~ubuntu-branches/ubuntu/maverick/bubblemon/maverick

« back to all changes in this revision

Viewing changes to intl/eval-plural.h

  • Committer: Bazaar Package Importer
  • Author(s): Jose Carlos Medeiros
  • Date: 2007-09-21 16:01:51 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20070921160151-o8g6zsamxofhi4ig
Tags: 2.0.7-1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
}