← Back to branch summary

~ubuntu-branches/debian/squeeze/nas/squeeze

« back to all changes in this revision

Viewing changes to server/dia/gram.y

  • Committer: Bazaar Package Importer
  • Author(s): Steve McIntyre
  • Date: 2008-10-08 01:18:19 UTC
  • mfrom: (4.1.7 intrepid)
  • Revision ID: james.westby@ubuntu.com-20081008011819-wmr4h2w0298k8t7z
Tags: 1.9.1-5
http://bugs.debian.org/491766
http://bugs.debian.org/500437
http://bugs.debian.org/500533
http://bugs.debian.org/500973
* Fix pending l10n issues. Debconf translations:
* Swedish. Closes: #491766 (thanks to brother@bsnet.se)
* Arabic. Closes: #500437 (thanks to Ossama Khayat)
* Basque. Closes: #500533 (thanks to Piarres Beobide)
* Brazilian Portuguese. Closes: #500973 (thanks to Felipe
  Augusto van de Wiel)
* Many thanks again to Christian Perrier for his i18n efforts,
  co-ordinating the above.

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/dia/gram.y
1
 
/* $Id: gram.y,v 1.6 2003/12/23 02:00:04 jon Exp $ */
 
1
/* $Id: gram.y 246 2007-05-12 01:03:53Z jon $ */
2
2
/* $NCDId: @(#)gram.y,v 1.1 1996/04/24 17:01:03 greg Exp $ */
3
3
 
4
4
 
13
13
#include "aulog.h"
14
14
#include "misc.h"
15
15
 
16
 
static char     *ptr;
 
16
static char     *ptr;
17
17
static int parsebool(char *str);
18
18
extern int yylineno;
19
19
 
28
28
%token <num> INPUTSECTION OUTPUTSECTION ENDSECTION WORDSIZE FRAGSIZE MAXFRAGS
29
29
%token <num> MINFRAGS MAXRATE MINRATE NUMCHANS MIXER DEVICE NUMBER 
30
30
%token <num> CDEBUG VERBOSE
31
 
%token <num> READWRITE FORCERATE AUTOOPEN GAIN
32
 
%token <num> RELEASEDEVICE OUTDEVTYPE MIXERINIT
 
31
%token <num> READWRITE FORCERATE AUTOOPEN GAIN GAINSCALE
 
32
%token <num> RELEASEDEVICE KEEPMIXER OUTDEVTYPE MIXERINIT REINITMIXER
33
33
%token <ptr> STRING 
34
34
 
35
35
%type <ptr> string
38
38
%start auconfig 
39
39
 
40
40
%%
41
 
auconfig        : globstmts sectconfigs
42
 
                ;
43
 
 
44
 
globstmts       : /* Empty */
45
 
                | globstmts globstmt
46
 
                ;
47
 
 
48
 
globstmt        : VERBOSE
49
 
                        { NasConfig.DoVerbose = TRUE; }
50
 
                | CDEBUG number
51
 
                        { NasConfig.DoDebug = $2 ; }
 
41
auconfig        : globstmts sectconfigs
 
42
                ;
 
43
 
 
44
globstmts       : /* Empty */
 
45
                | globstmts globstmt
 
46
                ;
 
47
 
 
48
globstmt        : VERBOSE
 
49
                        { NasConfig.DoVerbose = TRUE; }
 
50
                | CDEBUG number
 
51
                        { NasConfig.DoDebug = $2 ; }
52
52
                | RELEASEDEVICE string
53
53
                        {
54
 
                          int j;
55
 
 
56
 
                          j = parsebool($2);
57
 
                          if (j == -1)
58
 
                            {
59
 
                                /* error - default to no */
60
 
                              NasConfig.DoDeviceRelease = FALSE;
61
 
                            }
62
 
                          else
63
 
                            NasConfig.DoDeviceRelease = j; 
64
 
                        }
 
54
                          int j;
 
55
 
 
56
                          j = parsebool($2);
 
57
                          if (j == -1) {
 
58
                                /* error - default to yes */
 
59
                              NasConfig.DoDeviceRelease = TRUE;
 
60
                          } else 
 
61
                              NasConfig.DoDeviceRelease = j; 
 
62
                        }
 
63
                | KEEPMIXER string
 
64
                        {
 
65
                          int j;
 
66
 
 
67
                          j = parsebool($2);
 
68
                          if (j == -1) {
 
69
                                /* error - default to yes */
 
70
                              NasConfig.DoKeepMixer = TRUE;
 
71
                          } else 
 
72
                              NasConfig.DoKeepMixer = j; 
 
73
                        }
65
74
                | MIXERINIT string
66
75
                        { ddaSetConfig(MIXERINIT, (void *)parsebool($2)); }  
 
76
                | REINITMIXER string
 
77
                        { ddaSetConfig(REINITMIXER, (void *)parsebool($2)); }  
67
78
                | OUTDEVTYPE string
68
79
                        { ddaSetConfig(OUTDEVTYPE, (void *)$2); }  
69
 
                ;
70
 
 
71
 
sectconfigs     : /* Empty */
72
 
                | sectconfigs sectconfig
73
 
                ;
74
 
 
75
 
sectconfig      : inputconfig
76
 
                | outputconfig
77
 
                ;
78
 
 
79
 
inputconfig     : inputword stmts ENDSECTION
80
 
                ;
81
 
 
82
 
inputword       : INPUTSECTION
83
 
                        { ddaSetConfig(CONF_SET_SECTION, (void *)INPUTSECTION); }
84
 
                ;
85
 
 
86
 
outputconfig    : outputword stmts ENDSECTION
87
 
                ;
88
 
 
89
 
outputword      : OUTPUTSECTION
90
 
                        { ddaSetConfig(CONF_SET_SECTION, (void *)OUTPUTSECTION); }
91
 
                ;
92
 
 
93
 
stmts           : /* Empty */
94
 
                | stmts stmt
95
 
                ;
96
 
 
97
 
stmt            : error
98
 
                | AUTOOPEN string
99
 
                        {
100
 
                          ddaSetConfig(AUTOOPEN, (void *)parsebool($2));
101
 
                        }
102
 
                | FORCERATE string
103
 
                        {
104
 
                          ddaSetConfig(FORCERATE, (void *)parsebool($2));
105
 
                        }
106
 
                | READWRITE string
107
 
                        {
108
 
                          ddaSetConfig(READWRITE, (void *)parsebool($2));
109
 
                        }
110
 
                | MIXER string
111
 
                        {
112
 
                          ddaSetConfig(MIXER, (void *)$2);
113
 
                        }
114
 
                | DEVICE string
115
 
                        {
116
 
                          ddaSetConfig(DEVICE, (void *)$2);
117
 
                        }
118
 
                | WORDSIZE number
119
 
                        {
120
 
                          ddaSetConfig(WORDSIZE, (void *)$2);
121
 
                        }
122
 
                | FRAGSIZE number
123
 
                        { 
124
 
                          ddaSetConfig(FRAGSIZE, (void *)$2);
125
 
                        }
126
 
                | MINFRAGS number
127
 
                        {
128
 
                          ddaSetConfig(MINFRAGS, (void *)$2);
129
 
                        }
130
 
                | MAXFRAGS number
131
 
                        {
132
 
                          ddaSetConfig(MAXFRAGS, (void *)$2);
133
 
                        }
134
 
                | NUMCHANS number
135
 
                        {
136
 
                          ddaSetConfig(NUMCHANS, (void *)$2);
137
 
                        }
138
 
                | MAXRATE number
139
 
                        { ddaSetConfig(MAXRATE, (void *)$2); }
140
 
                | MINRATE number
141
 
                        { ddaSetConfig(MINRATE, (void *)$2); }
142
 
                | GAIN number
143
 
                        { ddaSetConfig(GAIN, (void *)$2); }
144
 
                ;
145
 
 
146
 
string          : STRING                { ptr = (char *)malloc(strlen($1)+1);
147
 
                                          strcpy(ptr, $1);
148
 
                                          RemoveDQuote(ptr);
149
 
                                          $$ = ptr;
150
 
                                        }
151
 
                ;
152
 
number          : NUMBER                { $$ = $1; }
153
 
                ;
 
80
                ;
 
81
 
 
82
sectconfigs     : /* Empty */
 
83
                | sectconfigs sectconfig
 
84
                ;
 
85
 
 
86
sectconfig      : inputconfig
 
87
                | outputconfig
 
88
                ;
 
89
 
 
90
inputconfig     : inputword stmts ENDSECTION
 
91
                ;
 
92
 
 
93
inputword       : INPUTSECTION
 
94
                        { ddaSetConfig(CONF_SET_SECTION, (void *)INPUTSECTION); }
 
95
                ;
 
96
 
 
97
outputconfig    : outputword stmts ENDSECTION
 
98
                ;
 
99
 
 
100
outputword      : OUTPUTSECTION
 
101
                        { ddaSetConfig(CONF_SET_SECTION, (void *)OUTPUTSECTION); }
 
102
                ;
 
103
 
 
104
stmts           : /* Empty */
 
105
                | stmts stmt
 
106
                ;
 
107
 
 
108
stmt            : error
 
109
                | AUTOOPEN string
 
110
                        {
 
111
                          ddaSetConfig(AUTOOPEN, (void *)parsebool($2));
 
112
                        }
 
113
                | FORCERATE string
 
114
                        {
 
115
                          ddaSetConfig(FORCERATE, (void *)parsebool($2));
 
116
                        }
 
117
                | READWRITE string
 
118
                        {
 
119
                          ddaSetConfig(READWRITE, (void *)parsebool($2));
 
120
                        }
 
121
                | MIXER string
 
122
                        {
 
123
                          ddaSetConfig(MIXER, (void *)$2);
 
124
                        }
 
125
                | DEVICE string
 
126
                        {
 
127
                          ddaSetConfig(DEVICE, (void *)$2);
 
128
                        }
 
129
                | WORDSIZE number
 
130
                        {
 
131
                          ddaSetConfig(WORDSIZE, (void *)$2);
 
132
                        }
 
133
                | FRAGSIZE number
 
134
                        { 
 
135
                          ddaSetConfig(FRAGSIZE, (void *)$2);
 
136
                        }
 
137
                | MINFRAGS number
 
138
                        {
 
139
                          ddaSetConfig(MINFRAGS, (void *)$2);
 
140
                        }
 
141
                | MAXFRAGS number
 
142
                        {
 
143
                          ddaSetConfig(MAXFRAGS, (void *)$2);
 
144
                        }
 
145
                | NUMCHANS number
 
146
                        {
 
147
                          ddaSetConfig(NUMCHANS, (void *)$2);
 
148
                        }
 
149
                | MAXRATE number
 
150
                        { ddaSetConfig(MAXRATE, (void *)$2); }
 
151
                | MINRATE number
 
152
                        { ddaSetConfig(MINRATE, (void *)$2); }
 
153
                | GAIN number
 
154
                        { ddaSetConfig(GAIN, (void *)$2); }
 
155
                | GAINSCALE number
 
156
                        { ddaSetConfig(GAINSCALE, (void *)$2); }
 
157
                ;
 
158
 
 
159
string          : STRING                { ptr = (char *)malloc(strlen($1)+1);
 
160
                                          strcpy(ptr, $1);
 
161
                                          RemoveDQuote(ptr);
 
162
                                          $$ = ptr;
 
163
                                        }
 
164
                ;
 
165
number          : NUMBER                { $$ = $1; }
 
166
                ;
154
167
 
155
168
%%
156
169
 
157
170
RemoveDQuote(str)
158
171
char *str;
159
172
{
160
 
    register char *i, *o;
161
 
    register n;
162
 
    register count;
 
173
    char *i, *o;
 
174
    int n;
 
175
    int count;
163
176
 
164
 
    for (i=str+1, o=str; *i && *i != '\"'; o++)
165
 
    {
166
 
        if (*i == '\\')
167
 
        {
168
 
            switch (*++i)
169
 
            {
170
 
            case 'n':
171
 
                *o = '\n';
172
 
                i++;
173
 
                break;
174
 
            case 'b':
175
 
                *o = '\b';
176
 
                i++;
177
 
                break;
178
 
            case 'r':
179
 
                *o = '\r';
180
 
                i++;
181
 
                break;
182
 
            case 't':
183
 
                *o = '\t';
184
 
                i++;
185
 
                break;
186
 
            case 'f':
187
 
                *o = '\f';
188
 
                i++;
189
 
                break;
190
 
            case '0':
191
 
                if (*++i == 'x')
192
 
                    goto hex;
193
 
                else
194
 
                    --i;
195
 
            case '1': case '2': case '3':
196
 
            case '4': case '5': case '6': case '7':
197
 
                n = 0;
198
 
                count = 0;
199
 
                while (*i >= '0' && *i <= '7' && count < 3)
200
 
                {
201
 
                    n = (n<<3) + (*i++ - '0');
202
 
                    count++;
203
 
                }
204
 
                *o = n;
205
 
                break;
206
 
            hex:
207
 
            case 'x':
208
 
                n = 0;
209
 
                count = 0;
210
 
                while (i++, count++ < 2)
211
 
                {
212
 
                    if (*i >= '0' && *i <= '9')
213
 
                        n = (n<<4) + (*i - '0');
214
 
                    else if (*i >= 'a' && *i <= 'f')
215
 
                        n = (n<<4) + (*i - 'a') + 10;
216
 
                    else if (*i >= 'A' && *i <= 'F')
217
 
                        n = (n<<4) + (*i - 'A') + 10;
218
 
                    else
219
 
                        break;
220
 
                }
221
 
                *o = n;
222
 
                break;
223
 
            case '\n':
224
 
                i++;    /* punt */
225
 
                o--;    /* to account for o++ at end of loop */
226
 
                break;
227
 
            case '\"':
228
 
            case '\'':
229
 
            case '\\':
230
 
            default:
231
 
                *o = *i++;
232
 
                break;
233
 
            }
234
 
        }
235
 
        else
236
 
            *o = *i++;
 
177
    for (i = str + 1, o = str; *i && *i != '\"'; o++) {
 
178
        if (*i == '\\') {
 
179
            switch (*++i) {
 
180
            case 'n':
 
181
                *o = '\n';
 
182
                i++;
 
183
                break;
 
184
            case 'b':
 
185
                *o = '\b';
 
186
                i++;
 
187
                break;
 
188
            case 'r':
 
189
                *o = '\r';
 
190
                i++;
 
191
                break;
 
192
            case 't':
 
193
                *o = '\t';
 
194
                i++;
 
195
                break;
 
196
            case 'f':
 
197
                *o = '\f';
 
198
                i++;
 
199
                break;
 
200
            case '0':
 
201
                if (*++i == 'x')
 
202
                    goto hex;
 
203
                else
 
204
                    --i;
 
205
            case '1':
 
206
            case '2':
 
207
            case '3':
 
208
            case '4':
 
209
            case '5':
 
210
            case '6':
 
211
            case '7':
 
212
                n = 0;
 
213
                count = 0;
 
214
                while (*i >= '0' && *i <= '7' && count < 3) {
 
215
                    n = (n << 3) + (*i++ - '0');
 
216
                    count++;
 
217
                }
 
218
                *o = n;
 
219
                break;
 
220
              hex:
 
221
            case 'x':
 
222
                n = 0;
 
223
                count = 0;
 
224
                while (i++, count++ < 2) {
 
225
                    if (*i >= '0' && *i <= '9')
 
226
                        n = (n << 4) + (*i - '0');
 
227
                    else if (*i >= 'a' && *i <= 'f')
 
228
                        n = (n << 4) + (*i - 'a') + 10;
 
229
                    else if (*i >= 'A' && *i <= 'F')
 
230
                        n = (n << 4) + (*i - 'A') + 10;
 
231
                    else
 
232
                        break;
 
233
                }
 
234
                *o = n;
 
235
                break;
 
236
            case '\n':
 
237
                i++;            /* punt */
 
238
                o--;            /* to account for o++ at end of loop */
 
239
                break;
 
240
            case '\"':
 
241
            case '\'':
 
242
            case '\\':
 
243
            default:
 
244
                *o = *i++;
 
245
                break;
 
246
            }
 
247
        } else
 
248
            *o = *i++;
237
249
    }
238
250
    *o = '\0';
239
251
}
240
252
 
241
 
static int parsebool(char *str)
 
253
static int
 
254
parsebool(char *str)
242
255
{
243
 
  char *s;
244
 
 
245
 
  s = str;
246
 
 
247
 
  if (s == NULL)
248
 
    return(-1);
249
 
 
250
 
  while(*s)
251
 
    {
252
 
      *s = (char)tolower(*s);
253
 
      s++;
254
 
    }
255
 
 
256
 
  if (((char *)strstr("false", str) != NULL) ||
257
 
      ((char *)strstr("no", str) != NULL)    ||
258
 
      ((char *)strstr("0", str) != NULL)     ||
259
 
      ((char *)strstr("off", str) != NULL))
260
 
    {
261
 
      return(FALSE);
262
 
    }
263
 
  else if (((char *)strstr("true", str) != NULL) ||
264
 
           ((char *)strstr("yes", str) != NULL)  ||
265
 
           ((char *)strstr("1", str) != NULL)    ||
266
 
           ((char *)strstr("on", str) != NULL))
267
 
    {
268
 
      return(TRUE);
269
 
    }
270
 
  else
271
 
    {
272
 
      fprintf(stderr, "parsebool(): error parsing '%s', \n\t%s\n",
273
 
              str,
274
 
              "Value must be yes or no, true or false, or on or off.");
275
 
      return(-1);
 
256
    char *s;
 
257
 
 
258
    s = str;
 
259
 
 
260
    if (s == NULL)
 
261
        return (-1);
 
262
 
 
263
    while (*s) {
 
264
        *s = (char) tolower(*s);
 
265
        s++;
 
266
    }
 
267
 
 
268
    if (((char *) strstr("false", str) != NULL) ||
 
269
        ((char *) strstr("no", str) != NULL) ||
 
270
        ((char *) strstr("0", str) != NULL) ||
 
271
        ((char *) strstr("off", str) != NULL)) {
 
272
        return (FALSE);
 
273
    } else if (((char *) strstr("true", str) != NULL) ||
 
274
               ((char *) strstr("yes", str) != NULL) ||
 
275
               ((char *) strstr("1", str) != NULL) ||
 
276
               ((char *) strstr("on", str) != NULL)) {
 
277
        return (TRUE);
 
278
    } else {
 
279
        fprintf(stderr, "parsebool(): error parsing '%s', \n\t%s\n",
 
280
                str,
 
281
                "Value must be yes or no, true or false, or on or off.");
 
282
        return (-1);
276
283
    }
277
284
}