← Back to branch summary

~ubuntu-branches/ubuntu/wily/octave/wily

« back to all changes in this revision

Viewing changes to liboctave/lo-utils.cc

  • Committer: Package Import Robot
  • Author(s): Sébastien Villemot
  • Date: 2013-05-14 12:42:41 UTC
  • mfrom: (5.1.3 experimental)
  • Revision ID: package-import@ubuntu.com-20130514124241-dqow8bc0l4r3yj93
Tags: 3.6.4-2
* Adapt for Texinfo 5
  - add_info_dir_categories: use @dircategory in the patch
  - texinfo5.diff: new patch, fixes compatibility issues with Texinfo 5
* Upgrade to FLTK 1.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
liboctave/lo-utils.cc
195
195
  return retval;
196
196
}
197
197
 
 
198
// Note that the caller is responsible for repositioning the stream on
 
199
// failure.
 
200
 
198
201
static inline double
199
 
read_inf_nan_na (std::istream& is, char c0, char sign = '+')
 
202
read_inf_nan_na (std::istream& is, char c0)
200
203
{
201
204
  double d = 0.0;
202
205
 
209
212
          {
210
213
            char c2 = is.get ();
211
214
            if (c2 == 'f' || c2 == 'F')
212
 
              d = sign == '-' ? -octave_Inf : octave_Inf;
 
215
              d = octave_Inf;
213
216
            else
214
 
              {
215
 
                is.putback (c2);
216
 
                is.putback (c1);
217
 
                is.putback (c0);
218
 
                is.setstate (std::ios::failbit);
219
 
              }
 
217
              is.setstate (std::ios::failbit);
220
218
          }
221
219
        else
222
 
          {
223
 
            is.putback (c1);
224
 
            is.putback (c0);
225
 
            is.setstate (std::ios::failbit);
226
 
          }
 
220
          is.setstate (std::ios::failbit);
227
221
      }
228
222
      break;
229
223
 
236
230
            if (c2 == 'n' || c2 == 'N')
237
231
              d = octave_NaN;
238
232
            else
239
 
              {
240
 
                is.putback (c2);
241
 
                d = octave_NA;
242
 
              }
 
233
              d = octave_NA;
243
234
          }
244
235
        else
245
 
          {
246
 
            is.putback (c1);
247
 
            is.putback (c0);
248
 
            is.setstate (std::ios::failbit);
249
 
          }
 
236
          is.setstate (std::ios::failbit);
250
237
      }
251
238
      break;
252
239
 
265
252
{
266
253
  double d = 0.0;
267
254
 
 
255
  // FIXME -- resetting stream position is likely to fail unless we are
 
256
  // reading from a file.
 
257
  std::ios::streampos pos = is.tellg ();
 
258
 
268
259
  char c1 = ' ';
269
260
 
270
261
  while (isspace (c1))
271
262
    c1 = is.get ();
272
263
 
 
264
  bool neg = false;
 
265
 
273
266
  switch (c1)
274
267
    {
275
268
    case '-':
276
 
      {
277
 
        char c2 = 0;
278
 
        c2 = is.get ();
279
 
        if (c2 == 'i' || c2 == 'I' || c2 == 'n' || c2 == 'N')
280
 
          d = read_inf_nan_na (is, c2, c1);
281
 
        else
282
 
          {
283
 
            is.putback (c2);
284
 
            is.putback (c1);
285
 
            is >> d;
286
 
          }
287
 
      }
288
 
      break;
 
269
      neg = true;
 
270
      // fall through...
289
271
 
290
272
    case '+':
291
273
      {
292
274
        char c2 = 0;
293
275
        c2 = is.get ();
294
276
        if (c2 == 'i' || c2 == 'I' || c2 == 'n' || c2 == 'N')
295
 
          d = read_inf_nan_na (is, c2, c1);
 
277
          d = read_inf_nan_na (is, c2);
296
278
        else
297
279
          {
298
280
            is.putback (c2);
299
 
            is.putback (c1);
300
281
            is >> d;
301
282
          }
 
283
 
 
284
        if (neg && ! is.fail ())
 
285
          d = -d;
302
286
      }
303
287
      break;
304
288
 
310
294
    default:
311
295
      is.putback (c1);
312
296
      is >> d;
 
297
      break;
 
298
    }
 
299
 
 
300
  std::ios::iostate status = is.rdstate ();
 
301
  if (status & std::ios::failbit)
 
302
    {
 
303
      is.clear ();
 
304
      is.seekg (pos);
 
305
      is.setstate (status);
313
306
    }
314
307
 
315
308
  return d;
358
351
 
359
352
}
360
353
 
 
354
// Note that the caller is responsible for repositioning the stream on
 
355
// failure.
 
356
 
361
357
static inline float
362
358
read_float_inf_nan_na (std::istream& is, char c0, char sign = '+')
363
359
{
372
368
          {
373
369
            char c2 = is.get ();
374
370
            if (c2 == 'f' || c2 == 'F')
375
 
              d = sign == '-' ? -octave_Float_Inf : octave_Float_Inf;
 
371
              d = octave_Float_Inf;
376
372
            else
377
 
              {
378
 
                is.putback (c2);
379
 
                is.putback (c1);
380
 
                is.putback (c0);
381
 
                is.setstate (std::ios::failbit);
382
 
              }
 
373
              is.setstate (std::ios::failbit);
383
374
          }
384
375
        else
385
 
          {
386
 
            is.putback (c1);
387
 
            is.putback (c0);
388
 
            is.setstate (std::ios::failbit);
389
 
          }
 
376
          is.setstate (std::ios::failbit);
390
377
      }
391
378
      break;
392
379
 
399
386
            if (c2 == 'n' || c2 == 'N')
400
387
              d = octave_Float_NaN;
401
388
            else
402
 
              {
403
 
                is.putback (c2);
404
 
                d = octave_Float_NA;
405
 
              }
 
389
              d = octave_Float_NA;
406
390
          }
407
391
        else
408
 
          {
409
 
            is.putback (c1);
410
 
            is.putback (c0);
411
 
            is.setstate (std::ios::failbit);
412
 
          }
 
392
          is.setstate (std::ios::failbit);
413
393
      }
414
394
      break;
415
395
 
428
408
{
429
409
  float d = 0.0;
430
410
 
 
411
  // FIXME -- resetting stream position is likely to fail unless we are
 
412
  // reading from a file.
 
413
  std::ios::streampos pos = is.tellg ();
 
414
 
431
415
  char c1 = ' ';
432
416
 
433
417
  while (isspace (c1))
434
418
    c1 = is.get ();
435
419
 
 
420
  bool neg = false;
 
421
 
436
422
  switch (c1)
437
423
    {
438
424
    case '-':
439
 
      {
440
 
        char c2 = 0;
441
 
        c2 = is.get ();
442
 
        if (c2 == 'i' || c2 == 'I' || c2 == 'n' || c2 == 'N')
443
 
          d = read_float_inf_nan_na (is, c2, c1);
444
 
        else
445
 
          {
446
 
            is.putback (c2);
447
 
            is.putback (c1);
448
 
            is >> d;
449
 
          }
450
 
      }
451
 
      break;
 
425
      neg = true;
 
426
      // fall through...
452
427
 
453
428
    case '+':
454
429
      {
455
430
        char c2 = 0;
456
431
        c2 = is.get ();
457
432
        if (c2 == 'i' || c2 == 'I' || c2 == 'n' || c2 == 'N')
458
 
          d = read_float_inf_nan_na (is, c2, c1);
 
433
          d = read_float_inf_nan_na (is, c2);
459
434
        else
460
435
          {
461
436
            is.putback (c2);
462
 
            is.putback (c1);
463
437
            is >> d;
464
438
          }
 
439
 
 
440
        if (neg && ! is.fail ())
 
441
          d = -d;
465
442
      }
466
443
      break;
467
444
 
473
450
    default:
474
451
      is.putback (c1);
475
452
      is >> d;
 
453
      break;
 
454
    }
 
455
 
 
456
  std::ios::iostate status = is.rdstate ();
 
457
  if (status & std::ios::failbit)
 
458
    {
 
459
      is.clear ();
 
460
      is.seekg (pos);
 
461
      is.setstate (status);
476
462
    }
477
463
 
478
464
  return d;