Mercurial > hg > octave-jordi

comparison src/oct-stream.cc @ 2305:5a3f1d00a474

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 1996-07-09 16:20:40 by jwe]
author jwe
date Tue, 09 Jul 1996 16:20:40 +0000
parents 59740768906f
children 8c09c04f7747
comparison
equal deleted inserted replaced
2304:532542bd9493 2305:5a3f1d00a474
112 double dnr = -1.0; 112 double dnr = -1.0;
113 double dnc = -1.0; 113 double dnc = -1.0;
114 114
115 if (size.rows () == 1 && size.cols () > 0) 115 if (size.rows () == 1 && size.cols () > 0)
116 { 116 {
117 dnr = size.elem (0, 0); 117 dnr = size (0, 0);
118 118
119 if (size.cols () == 2) 119 if (size.cols () == 2)
120 dnc = size.elem (0, 1); 120 dnc = size (0, 1);
121 else if (size.cols () > 2) 121 else if (size.cols () > 2)
122 ::error ("%s: invalid size specification", warn_for); 122 ::error ("%s: invalid size specification", warn_for);
123 } 123 }
124 else if (size.cols () == 1 && size.rows () > 0) 124 else if (size.cols () == 1 && size.rows () > 0)
125 { 125 {
126 dnr = size.elem (0, 0); 126 dnr = size (0, 0);
127 127
128 if (size.rows () == 2) 128 if (size.rows () == 2)
129 dnc = size.elem (1, 0); 129 dnc = size (1, 0);
130 else if (size.rows () > 2) 130 else if (size.rows () > 2)
131 ::error ("%s: invalid size specification", warn_for); 131 ::error ("%s: invalid size specification", warn_for);
132 } 132 }
133 else 133 else
134 ::error ("%s: invalid size specification", warn_for); 134 ::error ("%s: invalid size specification", warn_for);
199 { 199 {
200 int n = list.length (); 200 int n = list.length ();
201 201
202 for (int i = 0; i < n; i++) 202 for (int i = 0; i < n; i++)
203 { 203 {
204 scanf_format_elt *elt = list.elem (i); 204 scanf_format_elt *elt = list (i);
205 delete elt; 205 delete elt;
206 } 206 }
207 } 207 }
208 208
209 void 209 void
224 = new scanf_format_elt (text, width, discard, type, modifier); 224 = new scanf_format_elt (text, width, discard, type, modifier);
225 225
226 if (num_elts == list.length ()) 226 if (num_elts == list.length ())
227 list.resize (2 * num_elts); 227 list.resize (2 * num_elts);
228 228
229 list.elem (num_elts++) = elt; 229 list (num_elts++) = elt;
230 } 230 }
231 else 231 else
232 delete [] text; 232 delete [] text;
233 } 233 }
234 234
393 { 393 {
394 int n = list.length (); 394 int n = list.length ();
395 395
396 for (int i = 0; i < n; i++) 396 for (int i = 0; i < n; i++)
397 { 397 {
398 scanf_format_elt *elt = list.elem (i); 398 scanf_format_elt *elt = list (i);
399 399
400 cerr << elt->width << "\t" 400 cerr << elt->width << "\t"
401 << elt->discard << "\t" 401 << elt->discard << "\t"
402 << elt->type << "\t" 402 << elt->type << "\t"
403 << elt->modifier << "\t" 403 << elt->modifier << "\t"
412 412
413 if (n > 0) 413 if (n > 0)
414 { 414 {
415 for (int i = 0; i < n; i++) 415 for (int i = 0; i < n; i++)
416 { 416 {
417 scanf_format_elt *elt = list.elem (i); 417 scanf_format_elt *elt = list (i);
418 418
419 switch (elt->type) 419 switch (elt->type)
420 { 420 {
421 case 'c': case 's': case 'p': case '%': case '[': 421 case 'c': case 's': case 'p': case '%': case '[':
422 break; 422 break;
440 440
441 if (n > 0) 441 if (n > 0)
442 { 442 {
443 for (int i = 0; i < n; i++) 443 for (int i = 0; i < n; i++)
444 { 444 {
445 scanf_format_elt *elt = list.elem (i); 445 scanf_format_elt *elt = list (i);
446 446
447 switch (elt->type) 447 switch (elt->type)
448 { 448 {
449 case 'd': case 'i': case 'o': case 'u': case 'x': 449 case 'd': case 'i': case 'o': case 'u': case 'x':
450 case 'e': case 'f': case 'g': 450 case 'e': case 'f': case 'g':
520 { 520 {
521 int n = list.length (); 521 int n = list.length ();
522 522
523 for (int i = 0; i < n; i++) 523 for (int i = 0; i < n; i++)
524 { 524 {
525 printf_format_elt *elt = list.elem (i); 525 printf_format_elt *elt = list (i);
526 delete elt; 526 delete elt;
527 } 527 }
528 } 528 }
529 529
530 void 530 void
545 = new printf_format_elt (text, args, type, modifier); 545 = new printf_format_elt (text, args, type, modifier);
546 546
547 if (num_elts == list.length ()) 547 if (num_elts == list.length ())
548 list.resize (2 * num_elts); 548 list.resize (2 * num_elts);
549 549
550 list.elem (num_elts++) = elt; 550 list (num_elts++) = elt;
551 } 551 }
552 else 552 else
553 delete [] text; 553 delete [] text;
554 } 554 }
555 555
704 { 704 {
705 int n = list.length (); 705 int n = list.length ();
706 706
707 for (int i = 0; i < n; i++) 707 for (int i = 0; i < n; i++)
708 { 708 {
709 printf_format_elt *elt = list.elem (i); 709 printf_format_elt *elt = list (i);
710 710
711 cerr << elt->args<< "\t" 711 cerr << elt->args<< "\t"
712 << elt->type << "\t" 712 << elt->type << "\t"
713 << elt->modifier << "\t" 713 << elt->modifier << "\t"
714 << undo_string_escapes (elt->text) << "\n"; 714 << undo_string_escapes (elt->text) << "\n";
2667 // Insert item in first open slot, increasing size of list if 2667 // Insert item in first open slot, increasing size of list if
2668 // necessary. 2668 // necessary.
2669 2669
2670 for (int i = 0; i < curr_len; i++) 2670 for (int i = 0; i < curr_len; i++)
2671 { 2671 {
2672 octave_stream *tmp = list.elem (i); 2672 octave_stream *tmp = list (i);
2673 2673
2674 if (! tmp) 2674 if (! tmp)
2675 { 2675 {
2676 list.elem (i) = os; 2676 list (i) = os;
2677 retval = i; 2677 retval = i;
2678 break; 2678 break;
2679 } 2679 }
2680 } 2680 }
2681 2681
2684 int total_len = list.length (); 2684 int total_len = list.length ();
2685 2685
2686 if (curr_len == total_len) 2686 if (curr_len == total_len)
2687 list.resize (total_len * 2); 2687 list.resize (total_len * 2);
2688 2688
2689 list.elem (curr_len) = os; 2689 list (curr_len) = os;
2690 retval = curr_len; 2690 retval = curr_len;
2691 curr_len++; 2691 curr_len++;
2692 } 2692 }
2693 } 2693 }
2694 else 2694 else
2717 octave_stream_list::do_lookup (int fid) const 2717 octave_stream_list::do_lookup (int fid) const
2718 { 2718 {
2719 octave_stream *retval = 0; 2719 octave_stream *retval = 0;
2720 2720
2721 if (fid >= 0 && fid < curr_len) 2721 if (fid >= 0 && fid < curr_len)
2722 retval = list.elem (fid); 2722 retval = list (fid);
2723 2723
2724 return retval; 2724 return retval;
2725 } 2725 }
2726 2726
2727 octave_stream * 2727 octave_stream *
2766 2766
2767 // Can't remove stdin (cin), stdout (cout), or stderr (cerr). 2767 // Can't remove stdin (cin), stdout (cout), or stderr (cerr).
2768 2768
2769 if (fid > 2 && fid < curr_len) 2769 if (fid > 2 && fid < curr_len)
2770 { 2770 {
2771 octave_stream *os = list.elem (fid); 2771 octave_stream *os = list (fid);
2772 2772
2773 if (os) 2773 if (os)
2774 { 2774 {
2775 delete os; 2775 delete os;
2776 list.elem (fid) = 0; 2776 list (fid) = 0;
2777 retval = 0; 2777 retval = 0;
2778 } 2778 }
2779 } 2779 }
2780 2780
2781 return retval; 2781 return retval;
2819 void 2819 void
2820 octave_stream_list::do_clear (void) 2820 octave_stream_list::do_clear (void)
2821 { 2821 {
2822 // Do flush stdout and stderr. 2822 // Do flush stdout and stderr.
2823 2823
2824 list.elem (0) -> flush (); 2824 list (0) -> flush ();
2825 list.elem (1) -> flush (); 2825 list (1) -> flush ();
2826 2826
2827 // But don't delete them or stdin. 2827 // But don't delete them or stdin.
2828 2828
2829 for (int i = 3; i < curr_len; i++) 2829 for (int i = 3; i < curr_len; i++)
2830 { 2830 {
2831 octave_stream *os = list.elem (i); 2831 octave_stream *os = list (i);
2832 2832
2833 delete os; 2833 delete os;
2834 2834
2835 list.elem (i) = 0; 2835 list (i) = 0;
2836 } 2836 }
2837 } 2837 }
2838 2838
2839 void 2839 void
2840 octave_stream_list::clear (void) 2840 octave_stream_list::clear (void)
2916 << " number mode arch name\n" 2916 << " number mode arch name\n"
2917 << " ------ ---- ---- ----\n"; 2917 << " ------ ---- ---- ----\n";
2918 2918
2919 for (int i = 0; i < curr_len; i++) 2919 for (int i = 0; i < curr_len; i++)
2920 { 2920 {
2921 octave_stream *os = list.elem (i); 2921 octave_stream *os = list (i);
2922 2922
2923 if (os) 2923 if (os)
2924 { 2924 {
2925 string mode = octave_stream::mode_as_string (os->mode ()); 2925 string mode = octave_stream::mode_as_string (os->mode ());
2926 string arch = octave_stream::arch_as_string (os->architecture ()); 2926 string arch = octave_stream::arch_as_string (os->architecture ());
2962 2962
2963 // Skip stdin, stdout, and stderr. 2963 // Skip stdin, stdout, and stderr.
2964 2964
2965 for (int i = 3; i < curr_len; i++) 2965 for (int i = 3; i < curr_len; i++)
2966 { 2966 {
2967 if (list.elem (i)) 2967 if (list (i))
2968 retval (0, num_open++) = i; 2968 retval (0, num_open++) = i;
2969 } 2969 }
2970 2970
2971 retval.resize ((num_open > 0), num_open); 2971 retval.resize ((num_open > 0), num_open);
2972 2972
2995 2995
2996 // stdin (cin), stdout (cout), and stderr (cerr) are unnamed. 2996 // stdin (cin), stdout (cout), and stderr (cerr) are unnamed.
2997 2997
2998 for (int i = 3; i < curr_len; i++) 2998 for (int i = 3; i < curr_len; i++)
2999 { 2999 {
3000 octave_stream *os = list.elem (i); 3000 octave_stream *os = list (i);
3001 3001
3002 if (os && os->name () == nm) 3002 if (os && os->name () == nm)
3003 { 3003 {
3004 retval = i; 3004 retval = i;
3005 break; 3005 break;