Mercurial > octave-libtiff

comparison libinterp/corefcn/__tiff__.cc @ 31216:fe776b0e904d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
__tiff__.cc: added appropriate print_usage checks for internal functions * libtinterp/corefcn/__tiff__.cc: replaced errors for incorrect number of arguments with appropriate print_usage statements.
author magedrifaat <magedrifaat@gmail.com>
date Wed, 07 Sep 2022 18:30:53 +0200
parents 0fb5ca242d66
children c09f6a3597e6
comparison
equal deleted inserted replaced
31215:0fb5ca242d66 31216:fe776b0e904d
2392 2392
2393 @end deftypefn */) 2393 @end deftypefn */)
2394 { 2394 {
2395 #if defined (HAVE_TIFF) 2395 #if defined (HAVE_TIFF)
2396 int nargin = args.length (); 2396 int nargin = args.length ();
2397 2397
2398 if (nargin == 0 || nargin > 2) 2398 if (nargin < 1 || nargin > 2)
2399 { 2399 print_usage ();
2400 error ("No filename supplied\n");
2401 }
2402 2400
2403 std::string filename = args(0).string_value (); 2401 std::string filename = args(0).string_value ();
2404 std::string mode = "r"; 2402 std::string mode = "r";
2405 2403
2406 if (nargin == 2) 2404 if (nargin == 2)
2461 { 2459 {
2462 #if defined (HAVE_TIFF) 2460 #if defined (HAVE_TIFF)
2463 int nargin = args.length (); 2461 int nargin = args.length ();
2464 2462
2465 if (nargin == 0) 2463 if (nargin == 0)
2466 error ("No handle provided\n"); 2464 print_usage ();
2467 2465
2468 octave_tiff_handle *tiff_handle 2466 octave_tiff_handle *tiff_handle
2469 = octave_tiff_handle::get_tiff_handle (args(0)); 2467 = octave_tiff_handle::get_tiff_handle (args(0));
2470 2468
2471 set_internal_handlers (); 2469 set_internal_handlers ();
2492 @end deftypefn */) 2490 @end deftypefn */)
2493 { 2491 {
2494 #if defined (HAVE_TIFF) 2492 #if defined (HAVE_TIFF)
2495 int nargin = args.length (); 2493 int nargin = args.length ();
2496 2494
2497 if (nargin == 0)
2498 error ("No handle provided\n");
2499
2500 if (nargin < 2) 2495 if (nargin < 2)
2501 error ("No tag name provided\n"); 2496 print_usage ();
2502 2497
2503 octave_tiff_handle *tiff_handle 2498 octave_tiff_handle *tiff_handle
2504 = octave_tiff_handle::get_tiff_handle (args(0)); 2499 = octave_tiff_handle::get_tiff_handle (args(0));
2505 2500
2506 check_closed (tiff_handle); 2501 check_closed (tiff_handle);
2548 @end deftypefn */) 2543 @end deftypefn */)
2549 { 2544 {
2550 #if defined (HAVE_TIFF) 2545 #if defined (HAVE_TIFF)
2551 int nargin = args.length (); 2546 int nargin = args.length ();
2552 2547
2548 if (nargin == 0)
2549 print_usage ();
2550
2553 if (nargin < 2) 2551 if (nargin < 2)
2554 error ("Too few arguments provided\n"); 2552 // Since this function accepts varargin from the Octave side, the
2553 // ommitted arguments are from wrong usage of the setTag method
2554 print_usage ("Tiff.setTag");
2555 2555
2556 octave_tiff_handle *tiff_handle 2556 octave_tiff_handle *tiff_handle
2557 = octave_tiff_handle::get_tiff_handle (args(0)); 2557 = octave_tiff_handle::get_tiff_handle (args(0));
2558 check_closed (tiff_handle); 2558 check_closed (tiff_handle);
2559 2559
2580 } 2580 }
2581 } 2581 }
2582 else 2582 else
2583 { 2583 {
2584 if (nargin < 3) 2584 if (nargin < 3)
2585 error ("Too few arguments provided"); 2585 print_usage ("Tiff.setTag");
2586 2586
2587 const TIFFField *fip; 2587 const TIFFField *fip;
2588 if (args(1).is_string ()) 2588 if (args(1).is_string ())
2589 { 2589 {
2590 std::string tag_name = args(1).string_value (); 2590 std::string tag_name = args(1).string_value ();
2621 { 2621 {
2622 #if defined (HAVE_TIFF) 2622 #if defined (HAVE_TIFF)
2623 int nargin = args.length (); 2623 int nargin = args.length ();
2624 2624
2625 if (nargin == 0) 2625 if (nargin == 0)
2626 error ("No handle provided\n"); 2626 print_usage ();
2627 2627
2628 octave_tiff_handle *tiff_handle 2628 octave_tiff_handle *tiff_handle
2629 = octave_tiff_handle::get_tiff_handle (args(0)); 2629 = octave_tiff_handle::get_tiff_handle (args(0));
2630 check_closed (tiff_handle); 2630 check_closed (tiff_handle);
2631 2631
2682 { 2682 {
2683 #if defined (HAVE_TIFF) 2683 #if defined (HAVE_TIFF)
2684 int nargin = args.length (); 2684 int nargin = args.length ();
2685 2685
2686 if (nargin != 2) 2686 if (nargin != 2)
2687 error ("Wrong number of arguments"); 2687 print_usage ();
2688 2688
2689 octave_tiff_handle *tiff_handle 2689 octave_tiff_handle *tiff_handle
2690 = octave_tiff_handle::get_tiff_handle (args(0)); 2690 = octave_tiff_handle::get_tiff_handle (args(0));
2691 check_closed (tiff_handle); 2691 check_closed (tiff_handle);
2692 2692
2730 { 2730 {
2731 #if defined (HAVE_TIFF) 2731 #if defined (HAVE_TIFF)
2732 int nargin = args.length (); 2732 int nargin = args.length ();
2733 2733
2734 if (nargin != 2) 2734 if (nargin != 2)
2735 error ("Wrong number of arguments"); 2735 print_usage ();
2736 2736
2737 octave_tiff_handle *tiff_handle 2737 octave_tiff_handle *tiff_handle
2738 = octave_tiff_handle::get_tiff_handle (args(0)); 2738 = octave_tiff_handle::get_tiff_handle (args(0));
2739 check_closed (tiff_handle); 2739 check_closed (tiff_handle);
2740 2740
2778 { 2778 {
2779 #if defined (HAVE_TIFF) 2779 #if defined (HAVE_TIFF)
2780 int nargin = args.length (); 2780 int nargin = args.length ();
2781 2781
2782 if (nargin != 1) 2782 if (nargin != 1)
2783 error ("Wrong number of arguments"); 2783 print_usage ();
2784 2784
2785 octave_tiff_handle *tiff_handle 2785 octave_tiff_handle *tiff_handle
2786 = octave_tiff_handle::get_tiff_handle (args(0)); 2786 = octave_tiff_handle::get_tiff_handle (args(0));
2787 check_closed (tiff_handle); 2787 check_closed (tiff_handle);
2788 2788
2871 { 2871 {
2872 #if defined (HAVE_TIFF) 2872 #if defined (HAVE_TIFF)
2873 int nargin = args.length (); 2873 int nargin = args.length ();
2874 2874
2875 if (nargin != 2) 2875 if (nargin != 2)
2876 error ("Wrong number of arguments"); 2876 print_usage ();
2877 2877
2878 octave_tiff_handle *tiff_handle 2878 octave_tiff_handle *tiff_handle
2879 = octave_tiff_handle::get_tiff_handle (args(0)); 2879 = octave_tiff_handle::get_tiff_handle (args(0));
2880 check_closed (tiff_handle); 2880 check_closed (tiff_handle);
2881 2881
2990 { 2990 {
2991 #if defined (HAVE_TIFF) 2991 #if defined (HAVE_TIFF)
2992 int nargin = args.length (); 2992 int nargin = args.length ();
2993 2993
2994 if (nargin != 3) 2994 if (nargin != 3)
2995 error ("Wrong number of arguments"); 2995 print_usage ();
2996 2996
2997 octave_tiff_handle *tiff_handle 2997 octave_tiff_handle *tiff_handle
2998 = octave_tiff_handle::get_tiff_handle (args(0)); 2998 = octave_tiff_handle::get_tiff_handle (args(0));
2999 check_closed (tiff_handle); 2999 check_closed (tiff_handle);
3000 3000
3118 { 3118 {
3119 #if defined (HAVE_TIFF) 3119 #if defined (HAVE_TIFF)
3120 int nargin = args.length (); 3120 int nargin = args.length ();
3121 3121
3122 if (nargin < 2) 3122 if (nargin < 2)
3123 error ("Wrong number of arguments\n"); 3123 print_usage ();
3124 3124
3125 if (nargin > 2) 3125 if (nargin > 2)
3126 error ("Tiff: Writing YCbCr image data is not supported"); 3126 error ("Tiff: Writing YCbCr image data is not supported");
3127 3127
3128 octave_tiff_handle *tiff_handle 3128 octave_tiff_handle *tiff_handle
3176 { 3176 {
3177 #if defined (HAVE_TIFF) 3177 #if defined (HAVE_TIFF)
3178 int nargin = args.length (); 3178 int nargin = args.length ();
3179 3179
3180 if (nargin < 3) 3180 if (nargin < 3)
3181 error ("Too few arguments provided\n"); 3181 print_usage ();
3182 3182
3183 if (nargin > 3) 3183 if (nargin > 3)
3184 error ("Tiff: Writing YCbCr image data is not supported"); 3184 error ("Tiff: Writing YCbCr image data is not supported");
3185 3185
3186 octave_tiff_handle *tiff_handle 3186 octave_tiff_handle *tiff_handle
3223 { 3223 {
3224 #if defined (HAVE_TIFF) 3224 #if defined (HAVE_TIFF)
3225 int nargin = args.length (); 3225 int nargin = args.length ();
3226 3226
3227 if (nargin < 3) 3227 if (nargin < 3)
3228 error ("Too few arguments provided\n"); 3228 print_usage ();
3229 3229
3230 if (nargin > 3) 3230 if (nargin > 3)
3231 error ("Tiff: Writing YCbCr image data is not supported"); 3231 error ("Tiff: Writing YCbCr image data is not supported");
3232 3232
3233 octave_tiff_handle *tiff_handle 3233 octave_tiff_handle *tiff_handle
3270 { 3270 {
3271 #if defined (HAVE_TIFF) 3271 #if defined (HAVE_TIFF)
3272 int nargin = args.length (); 3272 int nargin = args.length ();
3273 3273
3274 if (nargin == 0) 3274 if (nargin == 0)
3275 error ("No handle provided\n"); 3275 print_usage ();
3276 3276
3277 octave_tiff_handle *tiff_handle 3277 octave_tiff_handle *tiff_handle
3278 = octave_tiff_handle::get_tiff_handle (args(0)); 3278 = octave_tiff_handle::get_tiff_handle (args(0));
3279 check_closed (tiff_handle); 3279 check_closed (tiff_handle);
3280 3280
3301 { 3301 {
3302 #if defined (HAVE_TIFF) 3302 #if defined (HAVE_TIFF)
3303 int nargin = args.length (); 3303 int nargin = args.length ();
3304 3304
3305 if (nargin == 0) 3305 if (nargin == 0)
3306 error ("No handle provided\n"); 3306 print_usage ();
3307 3307
3308 octave_tiff_handle *tiff_handle 3308 octave_tiff_handle *tiff_handle
3309 = octave_tiff_handle::get_tiff_handle (args(0)); 3309 = octave_tiff_handle::get_tiff_handle (args(0));
3310 check_closed (tiff_handle); 3310 check_closed (tiff_handle);
3311 3311
3335 { 3335 {
3336 #if defined (HAVE_TIFF) 3336 #if defined (HAVE_TIFF)
3337 int nargin = args.length (); 3337 int nargin = args.length ();
3338 3338
3339 if (nargin == 0) 3339 if (nargin == 0)
3340 error ("No handle provided\n"); 3340 print_usage ();
3341 3341
3342 octave_tiff_handle *tiff_handle 3342 octave_tiff_handle *tiff_handle
3343 = octave_tiff_handle::get_tiff_handle (args(0)); 3343 = octave_tiff_handle::get_tiff_handle (args(0));
3344 check_closed (tiff_handle); 3344 check_closed (tiff_handle);
3345 3345
3369 { 3369 {
3370 #if defined (HAVE_TIFF) 3370 #if defined (HAVE_TIFF)
3371 int nargin = args.length (); 3371 int nargin = args.length ();
3372 3372
3373 if (nargin == 0) 3373 if (nargin == 0)
3374 error ("No handle provided\n"); 3374 print_usage ();
3375 3375
3376 octave_tiff_handle *tiff_handle 3376 octave_tiff_handle *tiff_handle
3377 = octave_tiff_handle::get_tiff_handle (args(0)); 3377 = octave_tiff_handle::get_tiff_handle (args(0));
3378 check_closed (tiff_handle); 3378 check_closed (tiff_handle);
3379 3379
3400 @end deftypefn */) 3400 @end deftypefn */)
3401 { 3401 {
3402 #if defined (HAVE_TIFF) 3402 #if defined (HAVE_TIFF)
3403 int nargin = args.length (); 3403 int nargin = args.length ();
3404 3404
3405 if (nargin == 0)
3406 print_usage ();
3407
3405 if (nargin < 2 || nargin > 3) 3408 if (nargin < 2 || nargin > 3)
3406 error ("Wrong number of arguments\n"); 3409 // Since this function accepts varargin from the Octave side, the
3410 // ommitted arguments are from wrong usage of the computeStrip method
3411 print_usage ("Tiff.computeStrip");
3407 3412
3408 octave_tiff_handle *tiff_handle 3413 octave_tiff_handle *tiff_handle
3409 = octave_tiff_handle::get_tiff_handle (args(0)); 3414 = octave_tiff_handle::get_tiff_handle (args(0));
3410 check_closed (tiff_handle); 3415 check_closed (tiff_handle);
3411 3416
3465 @end deftypefn */) 3470 @end deftypefn */)
3466 { 3471 {
3467 #if defined (HAVE_TIFF) 3472 #if defined (HAVE_TIFF)
3468 int nargin = args.length (); 3473 int nargin = args.length ();
3469 3474
3475 if (nargin == 0)
3476 print_usage ();
3477
3470 if (nargin < 2 || nargin > 3) 3478 if (nargin < 2 || nargin > 3)
3471 error ("Wrong number of arguments\n"); 3479 // Since this function accepts varargin from the Octave side, the
3480 // ommitted arguments are from wrong usage of the computeTile method
3481 print_usage ("Tiff.computeTile");
3472 3482
3473 octave_tiff_handle *tiff_handle 3483 octave_tiff_handle *tiff_handle
3474 = octave_tiff_handle::get_tiff_handle (args(0)); 3484 = octave_tiff_handle::get_tiff_handle (args(0));
3475 check_closed (tiff_handle); 3485 check_closed (tiff_handle);
3476 3486
3539 { 3549 {
3540 #if defined (HAVE_TIFF) 3550 #if defined (HAVE_TIFF)
3541 int nargin = args.length (); 3551 int nargin = args.length ();
3542 3552
3543 if (nargin == 0) 3553 if (nargin == 0)
3544 error ("No handle provided\n"); 3554 print_usage ();
3545 3555
3546 octave_tiff_handle *tiff_handle 3556 octave_tiff_handle *tiff_handle
3547 = octave_tiff_handle::get_tiff_handle (args(0)); 3557 = octave_tiff_handle::get_tiff_handle (args(0));
3548 check_closed (tiff_handle); 3558 check_closed (tiff_handle);
3549 3559
3573 { 3583 {
3574 #if defined (HAVE_TIFF) 3584 #if defined (HAVE_TIFF)
3575 int nargin = args.length (); 3585 int nargin = args.length ();
3576 3586
3577 if (nargin != 1) 3587 if (nargin != 1)
3578 error ("Wrong number of arguments\n"); 3588 print_usage ();
3579 3589
3580 octave_tiff_handle *tiff_handle 3590 octave_tiff_handle *tiff_handle
3581 = octave_tiff_handle::get_tiff_handle (args(0)); 3591 = octave_tiff_handle::get_tiff_handle (args(0));
3582 check_closed (tiff_handle); 3592 check_closed (tiff_handle);
3583 3593
3605 { 3615 {
3606 #if defined (HAVE_TIFF) 3616 #if defined (HAVE_TIFF)
3607 int nargin = args.length (); 3617 int nargin = args.length ();
3608 3618
3609 if (nargin != 1) 3619 if (nargin != 1)
3610 error ("Wrong number of arguments\n"); 3620 print_usage ();
3611 3621
3612 octave_tiff_handle *tiff_handle 3622 octave_tiff_handle *tiff_handle
3613 = octave_tiff_handle::get_tiff_handle (args(0)); 3623 = octave_tiff_handle::get_tiff_handle (args(0));
3614 check_closed (tiff_handle); 3624 check_closed (tiff_handle);
3615 3625
3638 { 3648 {
3639 #if defined (HAVE_TIFF) 3649 #if defined (HAVE_TIFF)
3640 int nargin = args.length (); 3650 int nargin = args.length ();
3641 3651
3642 if (nargin != 1) 3652 if (nargin != 1)
3643 error ("Wrong number of arguments\n"); 3653 print_usage ();
3644 3654
3645 octave_tiff_handle *tiff_handle 3655 octave_tiff_handle *tiff_handle
3646 = octave_tiff_handle::get_tiff_handle (args(0)); 3656 = octave_tiff_handle::get_tiff_handle (args(0));
3647 check_closed (tiff_handle); 3657 check_closed (tiff_handle);
3648 3658
3670 { 3680 {
3671 #if defined (HAVE_TIFF) 3681 #if defined (HAVE_TIFF)
3672 int nargin = args.length (); 3682 int nargin = args.length ();
3673 3683
3674 if (nargin != 1) 3684 if (nargin != 1)
3675 error ("Wrong number of arguments\n"); 3685 print_usage ();
3676 3686
3677 octave_tiff_handle *tiff_handle 3687 octave_tiff_handle *tiff_handle
3678 = octave_tiff_handle::get_tiff_handle (args(0)); 3688 = octave_tiff_handle::get_tiff_handle (args(0));
3679 check_closed (tiff_handle); 3689 check_closed (tiff_handle);
3680 3690
3707 { 3717 {
3708 #if defined (HAVE_TIFF) 3718 #if defined (HAVE_TIFF)
3709 int nargin = args.length (); 3719 int nargin = args.length ();
3710 3720
3711 if (nargin != 2) 3721 if (nargin != 2)
3712 error ("Wrong number of arguments\n"); 3722 print_usage ();
3713 3723
3714 octave_tiff_handle *tiff_handle 3724 octave_tiff_handle *tiff_handle
3715 = octave_tiff_handle::get_tiff_handle (args(0)); 3725 = octave_tiff_handle::get_tiff_handle (args(0));
3716 check_closed (tiff_handle); 3726 check_closed (tiff_handle);
3717 3727
3746 { 3756 {
3747 #if defined (HAVE_TIFF) 3757 #if defined (HAVE_TIFF)
3748 int nargin = args.length (); 3758 int nargin = args.length ();
3749 3759
3750 if (nargin != 1) 3760 if (nargin != 1)
3751 error ("Wrong number of arguments\n"); 3761 print_usage ();
3752 3762
3753 octave_tiff_handle *tiff_handle 3763 octave_tiff_handle *tiff_handle
3754 = octave_tiff_handle::get_tiff_handle (args(0)); 3764 = octave_tiff_handle::get_tiff_handle (args(0));
3755 check_closed (tiff_handle); 3765 check_closed (tiff_handle);
3756 3766
3777 { 3787 {
3778 #if defined (HAVE_TIFF) 3788 #if defined (HAVE_TIFF)
3779 int nargin = args.length (); 3789 int nargin = args.length ();
3780 3790
3781 if (nargin != 1) 3791 if (nargin != 1)
3782 error ("Wrong number of arguments\n"); 3792 print_usage ();
3783 3793
3784 octave_tiff_handle *tiff_handle 3794 octave_tiff_handle *tiff_handle
3785 = octave_tiff_handle::get_tiff_handle (args(0)); 3795 = octave_tiff_handle::get_tiff_handle (args(0));
3786 check_closed (tiff_handle); 3796 check_closed (tiff_handle);
3787 3797
3810 { 3820 {
3811 #if defined (HAVE_TIFF) 3821 #if defined (HAVE_TIFF)
3812 int nargin = args.length (); 3822 int nargin = args.length ();
3813 3823
3814 if (nargin != 2) 3824 if (nargin != 2)
3815 error ("Wrong number of arguments\n"); 3825 print_usage ();
3816 3826
3817 octave_tiff_handle *tiff_handle 3827 octave_tiff_handle *tiff_handle
3818 = octave_tiff_handle::get_tiff_handle (args(0)); 3828 = octave_tiff_handle::get_tiff_handle (args(0));
3819 check_closed (tiff_handle); 3829 check_closed (tiff_handle);
3820 3830
3865 { 3875 {
3866 #if defined (HAVE_TIFF) 3876 #if defined (HAVE_TIFF)
3867 int nargin = args.length (); 3877 int nargin = args.length ();
3868 3878
3869 if (nargin != 1) 3879 if (nargin != 1)
3870 error ("Wrong number of arguments\n"); 3880 print_usage ();
3871 3881
3872 octave_tiff_handle *tiff_handle 3882 octave_tiff_handle *tiff_handle
3873 = octave_tiff_handle::get_tiff_handle (args(0)); 3883 = octave_tiff_handle::get_tiff_handle (args(0));
3874 check_closed (tiff_handle); 3884 check_closed (tiff_handle);
3875 3885
3912 3922
3913 @end deftypefn */) 3923 @end deftypefn */)
3914 { 3924 {
3915 #if defined (HAVE_TIFF) 3925 #if defined (HAVE_TIFF)
3916 if (args.length () == 0) 3926 if (args.length () == 0)
3917 error ("No state argument provided"); 3927 print_usage ();
3918 3928
3919 if (! args(0).is_bool_scalar ()) 3929 if (! args(0).is_bool_scalar ())
3920 error ("Expected logical value as argument"); 3930 error ("Expected logical value as argument");
3921 3931
3922 // Set the error and warning handlers according to the bool parameter 3932 // Set the error and warning handlers according to the bool parameter