Mercurial > octave-nkf

comparison libinterp/octave-value/ov-fcn-inline.cc @ 20615:729a85dafba8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
use new string_value method to handle value extraction errors * ov-class.cc, ov-classdef.cc, ov-fcn-handle.cc, ov-fcn-inline.cc, ov.cc, pt-idx.cc: Use new string_value method.
author John W. Eaton <jwe@octave.org>
date Thu, 08 Oct 2015 17:55:57 -0400
parents f90c8372b7ba
children
comparison
equal deleted inserted replaced
20614:10ec79b47808 20615:729a85dafba8
679 679
680 int nargin = args.length (); 680 int nargin = args.length ();
681 681
682 if (nargin > 0) 682 if (nargin > 0)
683 { 683 {
684 if (args(0).is_string ()) 684 std::string fun = args(0).string_value ("inline: STR argument must be a string");
685
686 string_vector fargs;
687
688 if (nargin == 1)
685 { 689 {
686 std::string fun = args(0).string_value (); 690 bool is_arg = false;
687 string_vector fargs; 691 bool in_string = false;
688 692 std::string tmp_arg;
689 if (nargin == 1) 693 size_t i = 0;
694 size_t fun_length = fun.length ();
695
696 while (i < fun_length)
690 { 697 {
691 bool is_arg = false; 698 bool terminate_arg = false;
692 bool in_string = false; 699 char c = fun[i++];
693 std::string tmp_arg; 700
694 size_t i = 0; 701 if (in_string)
695 size_t fun_length = fun.length ();
696
697 while (i < fun_length)
698 { 702 {
699 bool terminate_arg = false; 703 if (c == '\'' || c == '\"')
700 char c = fun[i++]; 704 in_string = false;
701 705 }
702 if (in_string) 706 else if (c == '\'' || c == '\"')
703 { 707 {
704 if (c == '\'' || c == '\"') 708 in_string = true;
705 in_string = false; 709 if (is_arg)
706 } 710 terminate_arg = true;
707 else if (c == '\'' || c == '\"') 711 }
708 { 712 else if (! isalpha (c) && c != '_')
709 in_string = true; 713 if (! is_arg)
710 if (is_arg) 714 continue;
711 terminate_arg = true; 715 else if (isdigit (c))
712 } 716 tmp_arg.append (1, c);
713 else if (! isalpha (c) && c != '_') 717 else
714 if (! is_arg) 718 {
715 continue; 719 // Before we do anything remove trailing whitespaces.
716 else if (isdigit (c)) 720 while (i < fun_length && isspace (c))
717 tmp_arg.append (1, c); 721 c = fun[i++];
722
723 // Do we have a variable or a function?
724 if (c != '(')
725 terminate_arg = true;
718 else 726 else
719 { 727 {
720 // Before we do anything remove trailing whitespaces. 728 tmp_arg = std::string ();
721 while (i < fun_length && isspace (c)) 729 is_arg = false;
722 c = fun[i++];
723
724 // Do we have a variable or a function?
725 if (c != '(')
726 terminate_arg = true;
727 else
728 {
729 tmp_arg = std::string ();
730 is_arg = false;
731 }
732 } 730 }
733 else if (! is_arg) 731 }
732 else if (! is_arg)
733 {
734 if (c == 'e' || c == 'E')
734 { 735 {
735 if (c == 'e' || c == 'E') 736 // possible number in exponent form, not arg
736 { 737 if (isdigit (fun[i])
737 // possible number in exponent form, not arg 738 || fun[i] == '-' || fun[i] == '+')
738 if (isdigit (fun[i]) 739 continue;
739 || fun[i] == '-' || fun[i] == '+')
740 continue;
741 }
742 is_arg = true;
743 tmp_arg.append (1, c);
744 } 740 }
745 else 741 is_arg = true;
742 tmp_arg.append (1, c);
743 }
744 else
745 {
746 tmp_arg.append (1, c);
747 }
748
749 if (terminate_arg || (i == fun_length && is_arg))
750 {
751 bool have_arg = false;
752
753 for (int j = 0; j < fargs.numel (); j++)
754 if (tmp_arg == fargs (j))
755 {
756 have_arg = true;
757 break;
758 }
759
760 if (! have_arg && tmp_arg != "i" && tmp_arg != "j"
761 && tmp_arg != "NaN" && tmp_arg != "nan"
762 && tmp_arg != "Inf" && tmp_arg != "inf"
763 && tmp_arg != "NA" && tmp_arg != "pi"
764 && tmp_arg != "e" && tmp_arg != "eps")
765 fargs.append (tmp_arg);
766
767 tmp_arg = std::string ();
768 is_arg = false;
769 }
770 }
771
772 // Sort the arguments into ascii order.
773 fargs.sort ();
774
775 if (fargs.numel () == 0)
776 fargs.append (std::string ("x"));
777
778 }
779 else if (nargin == 2 && args(1).is_numeric_type ())
780 {
781 if (! args(1).is_scalar_type ())
782 {
783 error ("inline: N must be an integer");
784 return retval;
785 }
786
787 int n = args(1).int_value ();
788
789 if (! error_state)
790 {
791 if (n >= 0)
792 {
793 fargs.resize (n+1);
794
795 fargs(0) = "x";
796
797 for (int i = 1; i < n+1; i++)
746 { 798 {
747 tmp_arg.append (1, c); 799 std::ostringstream buf;
748 } 800 buf << "P" << i;
749 801 fargs(i) = buf.str ();
750 if (terminate_arg || (i == fun_length && is_arg))
751 {
752 bool have_arg = false;
753
754 for (int j = 0; j < fargs.numel (); j++)
755 if (tmp_arg == fargs (j))
756 {
757 have_arg = true;
758 break;
759 }
760
761 if (! have_arg && tmp_arg != "i" && tmp_arg != "j"
762 && tmp_arg != "NaN" && tmp_arg != "nan"
763 && tmp_arg != "Inf" && tmp_arg != "inf"
764 && tmp_arg != "NA" && tmp_arg != "pi"
765 && tmp_arg != "e" && tmp_arg != "eps")
766 fargs.append (tmp_arg);
767
768 tmp_arg = std::string ();
769 is_arg = false;
770 }
771 }
772
773 // Sort the arguments into ascii order.
774 fargs.sort ();
775
776 if (fargs.numel () == 0)
777 fargs.append (std::string ("x"));
778
779 }
780 else if (nargin == 2 && args(1).is_numeric_type ())
781 {
782 if (! args(1).is_scalar_type ())
783 {
784 error ("inline: N must be an integer");
785 return retval;
786 }
787
788 int n = args(1).int_value ();
789
790 if (! error_state)
791 {
792 if (n >= 0)
793 {
794 fargs.resize (n+1);
795
796 fargs(0) = "x";
797
798 for (int i = 1; i < n+1; i++)
799 {
800 std::ostringstream buf;
801 buf << "P" << i;
802 fargs(i) = buf.str ();
803 }
804 }
805 else
806 {
807 error ("inline: N must be a positive integer or zero");
808 return retval;
809 } 802 }
810 } 803 }
811 else 804 else
812 { 805 {
813 error ("inline: N must be an integer"); 806 error ("inline: N must be a positive integer or zero");
814 return retval; 807 return retval;
815 } 808 }
816 } 809 }
817 else 810 else
818 { 811 {
819 fargs.resize (nargin - 1); 812 error ("inline: N must be an integer");
820 813 return retval;
821 for (int i = 1; i < nargin; i++)
822 {
823 if (args(i).is_string ())
824 {
825 std::string s = args(i).string_value ();
826 fargs(i-1) = s;
827 }
828 else
829 {
830 error ("inline: expecting string arguments");
831 return retval;
832 }
833 }
834 } 814 }
835
836 retval = octave_value (new octave_fcn_inline (fun, fargs));
837 } 815 }
838 else 816 else
839 error ("inline: STR argument must be a string"); 817 {
818 fargs.resize (nargin - 1);
819
820 for (int i = 1; i < nargin; i++)
821 {
822 std::string s = args(i).string_value ("inline: expecting string arguments");
823 fargs(i-1) = s;
824 }
825 }
826
827 retval = octave_value (new octave_fcn_inline (fun, fargs));
840 } 828 }
841 else 829 else
842 print_usage (); 830 print_usage ();
843 831
844 return retval; 832 return retval;