errorTable (rewrite errmsg to use default Scierror) 45/1845/3
Allan CORNET [Wed, 8 Sep 2010 09:05:21 +0000 (11:05 +0200)]
Change-Id: I1251d61dcbd9df0fbbb8a46e0f364580e5a75e17

14 files changed:
scilab/modules/core/tests/unit_tests/error.dia.ref [new file with mode: 0644]
scilab/modules/core/tests/unit_tests/error.tst [new file with mode: 0644]
scilab/modules/output_stream/Makefile.am
scilab/modules/output_stream/Makefile.in
scilab/modules/output_stream/src/c/Scierror.c
scilab/modules/output_stream/src/c/errmsg.h [deleted file]
scilab/modules/output_stream/src/c/error.c
scilab/modules/output_stream/src/c/errorTable.c [moved from scilab/modules/output_stream/src/c/errmsg.c with 50% similarity]
scilab/modules/output_stream/src/c/errorTable.h [new file with mode: 0644]
scilab/modules/output_stream/src/c/error_internal.c
scilab/modules/output_stream/src/c/error_internal.h
scilab/modules/output_stream/src/c/msgstore.c
scilab/modules/output_stream/src/c/output_stream.vcxproj
scilab/modules/output_stream/src/c/output_stream.vcxproj.filters

diff --git a/scilab/modules/core/tests/unit_tests/error.dia.ref b/scilab/modules/core/tests/unit_tests/error.dia.ref
new file mode 100644 (file)
index 0000000..a545e51
--- /dev/null
@@ -0,0 +1,450 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011 - DIGITEO - Allan CORNET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+msgerror = msprintf(gettext("Incorrect assignment.\n"));
+assert_checkerror ( "error(1)" , msgerror );
+msgerror = msprintf(gettext("Invalid factor.\n"));
+assert_checkerror ( "error(2)" , msgerror );
+msgerror = msprintf(gettext("Waiting for right parenthesis.\n"));
+assert_checkerror ( "error(3)" , msgerror );
+msgerror = msprintf(gettext("Undefined variable: %s\n"), "error");
+assert_checkerror ( "error(4)" , msgerror );
+msgerror = msprintf(gettext("Inconsistent column/row dimensions.\n"));
+assert_checkerror ( "error(5)" , msgerror );
+msgerror = msprintf(gettext("Inconsistent row/column dimensions.\n"));
+assert_checkerror ( "error(6)" , msgerror );
+msgerror = msprintf(gettext("Dot cannot be used as modifier for this operator.\n"));
+assert_checkerror ( "error(7)" , msgerror );
+msgerror = msprintf(gettext("Inconsistent addition.\n"));
+assert_checkerror ( "error(8)" , msgerror );
+msgerror = msprintf(gettext("Inconsistent subtraction.\n"));
+assert_checkerror ( "error(9)" , msgerror );
+msgerror = msprintf(gettext("Inconsistent multiplication.\n"));
+assert_checkerror ( "error(10)" , msgerror );
+msgerror = msprintf(gettext("Inconsistent right division.\n"));
+assert_checkerror ( "error(11)" , msgerror );
+msgerror = msprintf(gettext("Inconsistent left division.\n"));
+assert_checkerror ( "error(12)" , msgerror );
+msgerror = msprintf(gettext("Redefining permanent variable.\n"));
+assert_checkerror ( "error(13)" , msgerror );
+msgerror = msprintf(gettext("Eye variable undefined in this context.\n"));
+assert_checkerror ( "error(14)" , msgerror );
+msgerror = msprintf(gettext("Submatrix incorrectly defined.\n"));
+assert_checkerror ( "error(15)" , msgerror );
+msgerror = msprintf(gettext("Incorrect command!\n"));
+assert_checkerror ( "error(16)" , msgerror );
+msgerror = msprintf(gettext("Too many variables!\n"));
+assert_checkerror ( "error(18)" , msgerror );
+msgerror = msprintf(gettext("Problem is singular.\n"));
+assert_checkerror ( "error(19)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for argument %d: Square matrix expected.\n"), 3);
+assert_checkerror ( "error(20,3)" , msgerror );
+msgerror = msprintf(gettext("Invalid index.\n"));
+assert_checkerror ( "error(21)" , msgerror );
+msgerror = msprintf(gettext("Recursion problems. Sorry...\n"));
+assert_checkerror ( "error(22)" , msgerror );
+msgerror = msprintf(gettext("Matrix norms available are 1, 2, inf, and fro.\n"));
+assert_checkerror ( "error(23)" , msgerror );
+msgerror = msprintf(gettext("Convergence problem...\n"));
+assert_checkerror ( "error(24)" , msgerror );
+msgerror = msprintf(gettext("Bad call to primitive: %s\n"), "error");
+assert_checkerror ( "error(25)" , msgerror );
+msgerror = msprintf(gettext("Too complex recursion! (recursion tables are full)\n"));
+assert_checkerror ( "error(26)" , msgerror );
+msgerror = msprintf(gettext("Division by zero...\n"));
+assert_checkerror ( "error(27)" , msgerror );
+msgerror = msprintf(gettext("Empty function...\n"));
+assert_checkerror ( "error(28)" , msgerror );
+msgerror = msprintf(gettext("Matrix is not positive definite.\n"));
+assert_checkerror ( "error(29)" , msgerror );
+msgerror = msprintf(gettext("Invalid exponent.\n"));
+assert_checkerror ( "error(30)" , msgerror );
+msgerror = msprintf(gettext("Incorrect string.\n"));
+assert_checkerror ( "error(31)" , msgerror );
+msgerror = msprintf(gettext("Singularity of log or tan function.\n"));
+assert_checkerror ( "error(32)" , msgerror );
+msgerror = msprintf(gettext("Too many '':''\n"));
+assert_checkerror ( "error(33)" , msgerror );
+msgerror = msprintf(gettext("Incorrect control instruction syntax.\n"));
+assert_checkerror ( "error(34)" , msgerror );
+msgerror = msprintf(gettext("Incorrect control instruction syntax.\n"));
+assert_checkerror ( "error(34)" , msgerror );
+msgerror = msprintf(gettext("Syntax error in a ''%s'' instruction.\n") , "select/case");
+assert_checkerror ( "error(35)" , msgerror );
+msgerror = msprintf(gettext("Wrong input argument %d.\n") , 18);
+assert_checkerror ( "error(36,18)" , msgerror );
+msgerror = msprintf(gettext("Incorrect function at line %d.\n") , 18);
+assert_checkerror ( "error(37,18)" , msgerror );
+msgerror = msprintf(gettext("Incorrect function.\n"));
+assert_checkerror ( "error(37)" , msgerror );
+msgerror = msprintf(gettext("Wrong file name.\n"));
+assert_checkerror ( "error(38)" , msgerror );
+msgerror = msprintf(gettext("Incorrect number of input arguments.\n"));
+assert_checkerror ( "error(39)" , msgerror );
+msgerror = msprintf(gettext("Waiting for end of command.\n"));
+assert_checkerror ( "error(40)" , msgerror );
+msgerror = msprintf(gettext("Incompatible output argument.\n"));
+assert_checkerror ( "error(41)" , msgerror );
+msgerror = msprintf(gettext("Incompatible input argument.\n"));
+assert_checkerror ( "error(42)" , msgerror );
+msgerror = msprintf(gettext("Not implemented in scilab...\n"));
+assert_checkerror ( "error(43)" , msgerror );
+msgerror = msprintf(gettext("Wrong argument %d.\n"), 8);
+assert_checkerror ( "error(44,8)" , msgerror );
+msgerror = msprintf(gettext("null matrix (argument # %d).\n"), 81);
+assert_checkerror ( "error(45,81)" , msgerror );
+msgerror = msprintf(gettext("Incorrect syntax.\n"));
+assert_checkerror ( "error(46)" , msgerror );
+msgerror = msprintf(gettext(" end or else is missing...\n"));
+assert_checkerror ( "error(47)" , msgerror );
+msgerror = msprintf(gettext(" input line longer than buffer size: %d\n"), 4096);
+assert_checkerror ( "error(48)" , msgerror );
+msgerror = msprintf(gettext("Incorrect file or format.\n"));
+assert_checkerror ( "error(49)" , msgerror );
+msgerror = msprintf(gettext("subroutine not found: %s\n"),"");
+assert_checkerror ( "error(50)" , msgerror );
+msgerror = "";
+assert_checkerror ( "error(51)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for argument %d: Real matrix expected.\n"), 69);
+assert_checkerror ( "error(52, 69)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for input argument %d: Real or complex matrix expected.\n"), 69);
+assert_checkerror ( "error(53, 69)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for input argument %d: Polynomial expected.\n"), 69);
+assert_checkerror ( "error(54, 69)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for argument %d: String expected.\n"), 69);
+assert_checkerror ( "error(55, 69)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for argument %d: List expected.\n"), 69);
+assert_checkerror ( "error(56, 69)" , msgerror );
+msgerror = msprintf(gettext("Problem with comparison symbol...\n"));
+assert_checkerror ( "error(57)" , msgerror );
+msgerror = msprintf(gettext("Wrong number of input arguments."));
+assert_checkerror ( "error(58)" , msgerror );
+msgerror = msprintf(gettext("Wrong number of output arguments.\n"));
+assert_checkerror ( "error(59)" , msgerror );
+msgerror = msprintf(gettext("Wrong size for argument: Incompatible dimensions.\n"));
+assert_checkerror ( "error(60)" , msgerror );
+msgerror = msprintf(gettext("Direct access : give format.\n"));
+assert_checkerror ( "error(61)" , msgerror );
+msgerror = msprintf(gettext("End of file at line %d.\n"), 45);
+assert_checkerror ( "error(62,45)" , msgerror );
+msgerror = msprintf(gettext("%d graphic terminal?\n"), 45);
+assert_checkerror ( "error(63,45)" , msgerror );
+msgerror = msprintf(gettext("Integration fails.\n"));
+assert_checkerror ( "error(64)" , msgerror );
+msgerror = msprintf(gettext("%d: logical unit already used.\n"), 45);
+assert_checkerror ( "error(65,45)" , msgerror );
+msgerror = msprintf(gettext("Too many files opened!\n"));
+assert_checkerror ( "error(66)" , msgerror );
+msgerror = msprintf(gettext("Unknown file format.\n"));
+assert_checkerror ( "error(67)" , msgerror );
+msgerror = msprintf(gettext("Floating point exception.\n"));
+assert_checkerror ( "error(69)" , msgerror );
+msgerror = msprintf(gettext("Too many arguments in fort (max 30).\n"));
+assert_checkerror ( "error(70)" , msgerror );
+msgerror = msprintf(gettext("This variable is not valid in fort.\n"));
+assert_checkerror ( "error(71)" , msgerror );
+msgerror = msprintf(gettext("%s is not valid in this context.\n"), "error");
+assert_checkerror ( "error(72)" , msgerror );
+msgerror = msprintf(gettext("Error while linking.\n"));
+assert_checkerror ( "error(73)" , msgerror );
+msgerror = msprintf(gettext("Leading coefficient is zero.\n"));
+assert_checkerror ( "error(74)" , msgerror );
+msgerror = msprintf(gettext("Too high degree (max 100).\n"));
+assert_checkerror ( "error(75)" , msgerror );
+msgerror = msprintf(gettext("for x=val with type(val)=%d  is not implemented in Scilab.\n"),18);
+assert_checkerror ( "error(76, 18)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong number of input arguments.\n"), "error");
+assert_checkerror ( "error(77)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong number of output arguments.\n"), "error");
+assert_checkerror ( "error(78)" , msgerror );
+msgerror = msprintf(gettext("Indexing not allowed for output arguments of resume.\n"));
+assert_checkerror ( "error(79)" , msgerror );
+msgerror = msprintf(gettext("Incorrect function (argument n: %d).\n"), 99);
+assert_checkerror ( "error(80, 99)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Real or complex matrix expected.\n"), "error", 99);
+assert_checkerror ( "error(81, 99)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Real matrix expected.\n"), "error", 99);
+assert_checkerror ( "error(82, 99)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Real vector expected.\n"), "error", 99);
+assert_checkerror ( "error(83, 99)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Scalar expected.\n"), "error", 99);
+assert_checkerror ( "error(84, 99)" , msgerror );
+msgerror = msprintf(gettext("Host does not answer...\n"));
+assert_checkerror ( "error(85)" , msgerror );
+msgerror = msprintf(gettext("Uncontrollable system.\n"));
+assert_checkerror ( "error(86)" , msgerror );
+msgerror = msprintf(gettext("Unobservable system.\n"));
+assert_checkerror ( "error(87)" , msgerror );
+msgerror = msprintf(gettext("%s: singular or asymmetric problem.\n"), "sfact");
+assert_checkerror ( "error(88)" , msgerror );
+msgerror = msprintf(gettext("Wrong size for argument %d.\n"), 38);
+assert_checkerror ( "error(89, 38)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for argument %d: Transfer matrix expected.\n"), 38);
+assert_checkerror ( "error(90, 38)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for argument %d: In state space form expected.\n"), 38);
+assert_checkerror ( "error(91, 38)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for argument %d: Rational matrix expected.\n"), 38);
+assert_checkerror ( "error(92, 38)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for argument %d: In continuous time expected.\n"), 38);
+assert_checkerror ( "error(93, 38)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for argument %d: In discrete time expected.\n"), 38);
+assert_checkerror ( "error(94, 38)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for argument %d: SISO expected.\n"), 38);
+assert_checkerror ( "error(95, 38)" , msgerror );
+msgerror = msprintf(gettext("time domain of argument %d is not defined.\n"), 38);
+assert_checkerror ( "error(96, 38)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for argument %d: A system in state space or transfer matrix form expected.\n"), 38);
+assert_checkerror ( "error(97, 38)" , msgerror );
+msgerror = msprintf(gettext("Variable returned by scilab argument function is incorrect.\n"));
+assert_checkerror ( "error(98)" , msgerror );
+msgerror = msprintf(gettext("Elements of %dth argument must be in increasing order.\n"), 16);
+assert_checkerror ( "error(99, 16)" , msgerror );
+msgerror = msprintf(gettext("Elements of %dth argument are not in (strictly) decreasing order.\n"), 16);
+assert_checkerror ( "error(100, 16)" , msgerror );
+msgerror = msprintf(gettext("Last element of %dth argument <> first.\n"), 16);
+assert_checkerror ( "error(101, 16)" , msgerror );
+msgerror = msprintf(gettext("Variable or function %s are not in file.\n"), "error");
+assert_checkerror ( "error(102)" , msgerror );
+msgerror = msprintf(gettext("Variable %s is not a valid rational function.\n"), "error");
+assert_checkerror ( "error(103)" , msgerror );
+msgerror = msprintf(gettext("Variable %s is not a valid state space representation.\n"), "error");
+assert_checkerror ( "error(104)" , msgerror );
+msgerror = msprintf(gettext("Undefined fonction.\n"));
+assert_checkerror ( "error(105)" , msgerror );
+msgerror = msprintf(gettext("Function name already used.\n"));
+assert_checkerror ( "error(106)" , msgerror );
+msgerror = msprintf(gettext("Too many functions are defined (maximum #:%d).\n"), 18);
+assert_checkerror ( "error(107, 18)" , msgerror );
+msgerror = msprintf(gettext("Too complex for scilab, may be a too long control instruction.\n"));
+assert_checkerror ( "error(108)" , msgerror );
+msgerror = msprintf(gettext("Too large, can''t be displayed.\n"));
+assert_checkerror ( "error(109)" , msgerror );
+msgerror = msprintf(gettext("%s was a function when compiled but is now a primitive!\n"), "error");
+assert_checkerror ( "error(110)" , msgerror );
+msgerror = msprintf(gettext("Trying to re-define function %s.\n"), "error");
+assert_checkerror ( "error(111)" , msgerror );
+msgerror = msprintf(gettext("No more memory.\n"));
+assert_checkerror ( "error(112)" , msgerror );
+msgerror = msprintf(gettext("Too large string.\n"));
+assert_checkerror ( "error(113)" , msgerror );
+msgerror = msprintf(gettext("Too many linked routines.\n"));
+assert_checkerror ( "error(114)" , msgerror );
+msgerror = msprintf(gettext("Wrong value for argument %d.\n"), 18);
+assert_checkerror ( "error(116, 18)" , msgerror );
+msgerror = msprintf(gettext("List element number %d is Undefined.\n"), 18);
+assert_checkerror ( "error(117, 18)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for argument %d: Named variable not an expression expected.\n"), 18);
+assert_checkerror ( "error(118, 18)" , msgerror );
+msgerror = "";
+assert_checkerror ( "error(119)" , msgerror );
+msgerror = msprintf(gettext("Indices for non-zero elements must be given by a 2 column matrix.\n"));
+assert_checkerror ( "error(120)" , msgerror );
+msgerror = msprintf(gettext("Incompatible indices for non-zero elements.\n"));
+assert_checkerror ( "error(121)" , msgerror );
+msgerror = msprintf(gettext("Logical unit number should be larger than %d.\n"), 12);
+assert_checkerror ( "error(122, 12)" , msgerror );
+msgerror = msprintf(gettext("Function not bounded from below.\n"));
+assert_checkerror ( "error(123)" , msgerror );
+msgerror = "";
+assert_checkerror ( "error(124)" , msgerror );
+msgerror = msprintf(gettext("Problem may be unbounded: too high distance between two consecutive iterations.\n"));
+assert_checkerror ( "error(125)" , msgerror );
+msgerror = msprintf(gettext("Inconsistent constraints.\n"));
+assert_checkerror ( "error(126)" , msgerror );
+msgerror = msprintf(gettext("No feasible solution.\n"));
+assert_checkerror ( "error(127)" , msgerror );
+msgerror = msprintf(gettext("Degenerate starting point.\n"));
+assert_checkerror ( "error(128)" , msgerror );
+msgerror = msprintf(gettext("No feasible point has been found.\n"));
+assert_checkerror ( "error(129)" , msgerror );
+msgerror = msprintf(gettext("Optimization fails: back to initial point.\n"));
+assert_checkerror ( "error(130)" , msgerror );
+msgerror = msprintf(gettext("%s: Stop requested by simulator (ind=0)\n"), "optim");
+assert_checkerror ( "error(131)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong input parameters.\n"), "optim");
+assert_checkerror ( "error(132)" , msgerror );
+msgerror = msprintf(gettext("Too small memory.\n"));
+assert_checkerror ( "error(133)" , msgerror );
+msgerror = msprintf(gettext("%s: Problem with initial constants in simul.\n"), "optim");
+assert_checkerror ( "error(134)" , msgerror );
+msgerror = msprintf(gettext("%s: Bounds and initial guess are incompatible.\n"), "optim");
+assert_checkerror ( "error(135)" , msgerror );
+msgerror = msprintf(gettext("%s: This method is NOT implemented.\n"), "optim");
+assert_checkerror ( "error(136)" , msgerror );
+msgerror = msprintf(gettext("NO hot restart available in this method.\n"));
+assert_checkerror ( "error(137)" , msgerror );
+msgerror = msprintf(gettext("%s: Incorrect stopping parameters.\n"), "optim");
+assert_checkerror ( "error(138)" , msgerror );
+msgerror = msprintf(gettext("%s: Incorrect bounds.\n"), "optim");
+assert_checkerror ( "error(139)" , msgerror );
+msgerror = msprintf(gettext("Variable : %s must be a list\n"), "error");
+assert_checkerror ( "error(140)" , msgerror );
+msgerror = msprintf(gettext("Incorrect function (argument n: %d).\n"), 22);
+assert_checkerror ( "error(141, 22)" , msgerror );
+msgerror = msprintf(gettext("Hot restart: dimension of working table (argument n:%d).\n"), 22);
+assert_checkerror ( "error(142, 22)" , msgerror );
+msgerror = msprintf(gettext("%s: df0 must be positive !\n"), "optim");
+assert_checkerror ( "error(143)" , msgerror );
+msgerror = "";
+assert_checkerror ( "error(200)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Real or complex matrix expected.\n"), "error", 22);
+assert_checkerror ( "error(201, 22)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Real matrix expected.\n"), "error", 22);
+assert_checkerror ( "error(202, 22)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Real vector expected.\n"), "error", 22);
+assert_checkerror ( "error(203, 22)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Scalar expected.\n"), "error", 22);
+assert_checkerror ( "error(204, 22)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong size for argument %d: (%d,%d) expected.\n"), "error", 0, 1 , 301);
+assert_checkerror ( "error(205)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong size for argument %d: %d expected.\n"), "error", 0, 1);
+assert_checkerror ( "error(206)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Matrix of strings expected.\n"), "error", 0);
+assert_checkerror ( "error(207)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Boolean matrix expected.\n"), "error", 20);
+assert_checkerror ( "error(208, 20)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Matrix expected.\n"), "error", 20);
+assert_checkerror ( "error(209, 20)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: List expected.\n"), "error", 20);
+assert_checkerror ( "error(210, 20)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Function or string (external function) expected.\n"), "error", 20);
+assert_checkerror ( "error(211, 20)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Polynomial expected.\n"), "error", 20);
+assert_checkerror ( "error(212, 20)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Working int matrix expected.\n"), "error", 20);
+assert_checkerror ( "error(213, 20)" , msgerror );
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Vector expected.\n"), "error", 20);
+assert_checkerror ( "error(214, 20)" , msgerror );
+msgerror = msprintf(gettext("%dth argument type must be boolean.\n"), 20);
+assert_checkerror ( "error(215, 20)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for argument %d: Boolean or scalar expected.\n"), 20);
+assert_checkerror ( "error(216, 20)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for argument %d: Sparse matrix of scalars expected.\n"), 20);
+assert_checkerror ( "error(217, 20)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for argument %d: Handle to sparse lu factors expected.\n"), 20);
+assert_checkerror ( "error(218, 20)" , msgerror );
+msgerror = msprintf(gettext("Wrong type argument %d: Sparse or full scalar matrix expected.\n"), 20);
+assert_checkerror ( "error(219, 20)" , msgerror );
+msgerror = msprintf(gettext("Null variable cannot be used here.\n"));
+assert_checkerror ( "error(220)" , msgerror );
+msgerror = msprintf(gettext("A sparse matrix entry is defined with two different values.\n"));
+assert_checkerror ( "error(221)" , msgerror );
+msgerror = msprintf(gettext("%s not yet implemented for full input parameter.\n"), "lusolve");
+assert_checkerror ( "error(222)" , msgerror );
+msgerror = msprintf(gettext("It is not possible to redefine the %s primitive this way (see clearfun).\n"), "error");
+assert_checkerror ( "error(223)" , msgerror );
+msgerror = msprintf(gettext("Type data base is full.\n"));
+assert_checkerror ( "error(224)" , msgerror );
+msgerror = msprintf(gettext("This data type is already defined.\n"));
+assert_checkerror ( "error(225)" , msgerror );
+msgerror = msprintf(gettext("Inequality comparison with empty matrix.\n"));
+assert_checkerror ( "error(226)" , msgerror );
+msgerror = msprintf(gettext("Missing index.\n"));
+assert_checkerror ( "error(227)" , msgerror );
+msgerror = msprintf(gettext("reference to the cleared global variable %s.\n"), "error");
+assert_checkerror ( "error(228)" , msgerror );
+msgerror = msprintf(gettext("Operands of / and \\ operations must not contain NaN of Inf.\n"));
+assert_checkerror ( "error(229)" , msgerror );
+msgerror = msprintf(gettext("semi def fails.\n"));
+assert_checkerror ( "error(230)" , msgerror );
+msgerror = msprintf(gettext("Wrong type for first input argument: Single string expected.\n"));
+assert_checkerror ( "error(231)" , msgerror );
+msgerror = msprintf(gettext("Entry name not found.\n"));
+assert_checkerror ( "error(232)" , msgerror );
+msgerror = msprintf(gettext("Maximum number of dynamic interfaces reached.\n"));
+assert_checkerror ( "error(233)" , msgerror );
+msgerror = msprintf(gettext("%s: expecting more than one argument.\n"), "link");
+assert_checkerror ( "error(234)" , msgerror );
+msgerror = msprintf(gettext("%s: problem with one of the entry point.\n"), "link");
+assert_checkerror ( "error(235)" , msgerror );
+msgerror = msprintf(gettext("%s: the shared archive was not loaded.\n"), "link");
+assert_checkerror ( "error(236)" , msgerror );
+msgerror = msprintf(gettext("%s: Only one entry point allowed on this operating system.\n"), "link");
+assert_checkerror ( "error(237)" , msgerror );
+msgerror = msprintf(gettext("%s: First argument cannot be a number.\n"), "link");
+assert_checkerror ( "error(238)" , msgerror );
+msgerror = msprintf(gettext("You cannot link more functions, maxentry reached.\n"));
+assert_checkerror ( "error(239)" , msgerror );
+msgerror = msprintf(gettext("You cannot link more functions, maxentry reached.\n"));
+assert_checkerror ( "error(239)" , msgerror );
+msgerror = msprintf(gettext("File ""%s"" already exists or directory write access denied.\n"), "");
+assert_checkerror ( "error(240)" , msgerror );
+msgerror = msprintf(gettext("File ""%s"" does not exist or read access denied.\n"), "");
+assert_checkerror ( "error(241)" , msgerror );
+msgerror = msprintf(gettext("Binary direct access files must be opened by ''file''.\n"));
+assert_checkerror ( "error(242)" , msgerror );
+msgerror = msprintf(gettext("C file logical unit not allowed here.\n"));
+assert_checkerror ( "error(243)" , msgerror );
+msgerror = msprintf(gettext("Fortran file logical unit not allowed here.\n"));
+assert_checkerror ( "error(244)" , msgerror );
+msgerror = msprintf(gettext("No input file associated to logical unit %d.\n"), 23);
+assert_checkerror ( "error(245, 23)" , msgerror );
+msgerror = msprintf(gettext("Wrong value for argument %d: the lu handle is no more valid.\n"), 45);
+assert_checkerror ( "error(247, 45)" , msgerror );
+msgerror = msprintf(gettext("Wrong value for argument %d: Valid variable name expected.\n"), 45);
+assert_checkerror ( "error(248, 45)" , msgerror );
+msgerror = msprintf(gettext("Wrong value for argument %d: Empty string expected.\n"), 45);
+assert_checkerror ( "error(249, 45)" , msgerror );
+msgerror = msprintf(gettext("Recursive extraction is not valid in this context.\n"));
+assert_checkerror ( "error(250)" , msgerror );
+msgerror = msprintf(gettext("%s: ipar dimensioned at least 11.\n"), "bvode");
+assert_checkerror ( "error(251)" , msgerror );
+msgerror = msprintf(gettext("%s: ltol must be of size ipar(4).\n"), "bvode");
+assert_checkerror ( "error(252)" , msgerror );
+msgerror = msprintf(gettext("%s: fixpnt must be of size ipar(11).\n"), "bvode");
+assert_checkerror ( "error(253)" , msgerror );
+msgerror = msprintf(gettext("%s: ncomp < 20 requested.\n"), "bvode");
+assert_checkerror ( "error(254)" , msgerror );
+msgerror = msprintf(gettext("%s: m must be of size ncomp.\n"), "bvode");
+assert_checkerror ( "error(255)" , msgerror );
+msgerror = msprintf(gettext("%s: sum(m) must be less than 40.\n"), "bvode");
+assert_checkerror ( "error(256)" , msgerror );
+msgerror = msprintf(gettext("%s: sum(m) must be less than 40.\n"), "bvode");
+assert_checkerror ( "error(257)" , msgerror );
+msgerror = msprintf(gettext("%s: input data error.\n"), "bvode");
+assert_checkerror ( "error(258)" , msgerror );
+msgerror = msprintf(gettext("%s: no. of subintervals exceeds storage.\n"), "bvode");
+assert_checkerror ( "error(259)" , msgerror );
+msgerror = msprintf(gettext("%s: The colocation matrix is singular.\n"), "bvode");
+assert_checkerror ( "error(260)" , msgerror );
+msgerror = msprintf(gettext("Interface property table is full.\n"));
+assert_checkerror ( "error(261)" , msgerror );
+msgerror = msprintf(gettext("Error while writing in file: disk full or deleted file.\n"));
+assert_checkerror ( "error(263)" , msgerror );
+msgerror = msprintf(gettext("Wrong value for argument %d: Must not contain NaN or Inf.\n"), 2);
+assert_checkerror ( "error(264, 2)" , msgerror );
+msgerror = msprintf(gettext("%s and %s must have equal number of rows.\n"), "A", "B");
+assert_checkerror ( "error(265)" , msgerror );
+msgerror = msprintf(gettext("%s and %s must have equal number of columns.\n"), "A", "B");
+assert_checkerror ( "error(266)" , msgerror );
+msgerror = msprintf(gettext("%s and %s must have equal dimensions.\n"), "A", "B");
+assert_checkerror ( "error(267)" , msgerror );
+msgerror = msprintf(gettext("Invalid return value for function passed in arg %d.\n"), 8);
+assert_checkerror ( "error(268, 8)" , msgerror );
+msgerror = msprintf(gettext("Wrong value for argument %d: eigenvalues must have negative real parts.\n"), 8);
+assert_checkerror ( "error(269, 8)" , msgerror );
+msgerror = msprintf(gettext("Wrong value for argument %d: eigenvalues modulus must be less than one.\n"), 8);
+assert_checkerror ( "error(270, 8)" , msgerror );
+msgerror = msprintf(gettext("Size varying argument a*eye(), (arg %d) not allowed here.\n"), 8);
+assert_checkerror ( "error(271, 8)" , msgerror );
+msgerror = msprintf(gettext("endfunction is missing.\n"));
+assert_checkerror ( "error(272)" , msgerror );
+msgerror = msprintf(gettext("Instruction left hand side: waiting for a dot or a left parenthesis.\n"));
+assert_checkerror ( "error(273)" , msgerror );
+msgerror = msprintf(gettext("Instruction left hand side: waiting for a name.\n"));
+assert_checkerror ( "error(274)" , msgerror );
+msgerror = msprintf(gettext("varargout keyword cannot be used here.\n"));
+assert_checkerror ( "error(275)" , msgerror );
+msgerror = msprintf(gettext("Missing operator, comma, or semicolon.\n"));
+assert_checkerror ( "error(276)" , msgerror );
+msgerror = msprintf(gettext("Too many commands defined.\n"));
+assert_checkerror ( "error(277)" , msgerror );
+msgerror = msprintf(gettext("%s: Input arguments should have the same formal variable name.\n"), "error");
+assert_checkerror ( "error(278)" , msgerror );
+msgerror = "";
+assert_checkerror ( "error(279)" , msgerror );
+msgerror = "";
+assert_checkerror ( "error(280)" , msgerror );
diff --git a/scilab/modules/core/tests/unit_tests/error.tst b/scilab/modules/core/tests/unit_tests/error.tst
new file mode 100644 (file)
index 0000000..6df80b0
--- /dev/null
@@ -0,0 +1,673 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2011 - DIGITEO - Allan CORNET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+msgerror = msprintf(gettext("Incorrect assignment.\n"));
+assert_checkerror ( "error(1)" , msgerror );
+
+msgerror = msprintf(gettext("Invalid factor.\n"));
+assert_checkerror ( "error(2)" , msgerror );
+
+msgerror = msprintf(gettext("Waiting for right parenthesis.\n"));
+assert_checkerror ( "error(3)" , msgerror );
+
+msgerror = msprintf(gettext("Undefined variable: %s\n"), "error");
+assert_checkerror ( "error(4)" , msgerror );
+
+msgerror = msprintf(gettext("Inconsistent column/row dimensions.\n"));
+assert_checkerror ( "error(5)" , msgerror );
+
+msgerror = msprintf(gettext("Inconsistent row/column dimensions.\n"));
+assert_checkerror ( "error(6)" , msgerror );
+
+msgerror = msprintf(gettext("Dot cannot be used as modifier for this operator.\n"));
+assert_checkerror ( "error(7)" , msgerror );
+
+msgerror = msprintf(gettext("Inconsistent addition.\n"));
+assert_checkerror ( "error(8)" , msgerror );
+
+msgerror = msprintf(gettext("Inconsistent subtraction.\n"));
+assert_checkerror ( "error(9)" , msgerror );
+
+msgerror = msprintf(gettext("Inconsistent multiplication.\n"));
+assert_checkerror ( "error(10)" , msgerror );
+
+msgerror = msprintf(gettext("Inconsistent right division.\n"));
+assert_checkerror ( "error(11)" , msgerror );
+
+msgerror = msprintf(gettext("Inconsistent left division.\n"));
+assert_checkerror ( "error(12)" , msgerror );
+
+msgerror = msprintf(gettext("Redefining permanent variable.\n"));
+assert_checkerror ( "error(13)" , msgerror );
+
+msgerror = msprintf(gettext("Eye variable undefined in this context.\n"));
+assert_checkerror ( "error(14)" , msgerror );
+
+msgerror = msprintf(gettext("Submatrix incorrectly defined.\n"));
+assert_checkerror ( "error(15)" , msgerror );
+
+msgerror = msprintf(gettext("Incorrect command!\n"));
+assert_checkerror ( "error(16)" , msgerror );
+
+msgerror = msprintf(gettext("Too many variables!\n"));
+assert_checkerror ( "error(18)" , msgerror );
+
+msgerror = msprintf(gettext("Problem is singular.\n"));
+assert_checkerror ( "error(19)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for argument %d: Square matrix expected.\n"), 3);
+assert_checkerror ( "error(20,3)" , msgerror );
+
+msgerror = msprintf(gettext("Invalid index.\n"));
+assert_checkerror ( "error(21)" , msgerror );
+
+msgerror = msprintf(gettext("Recursion problems. Sorry...\n"));
+assert_checkerror ( "error(22)" , msgerror );
+
+msgerror = msprintf(gettext("Matrix norms available are 1, 2, inf, and fro.\n"));
+assert_checkerror ( "error(23)" , msgerror );
+
+msgerror = msprintf(gettext("Convergence problem...\n"));
+assert_checkerror ( "error(24)" , msgerror );
+
+msgerror = msprintf(gettext("Bad call to primitive: %s\n"), "error");
+assert_checkerror ( "error(25)" , msgerror );
+
+msgerror = msprintf(gettext("Too complex recursion! (recursion tables are full)\n"));
+assert_checkerror ( "error(26)" , msgerror );
+
+msgerror = msprintf(gettext("Division by zero...\n"));
+assert_checkerror ( "error(27)" , msgerror );
+
+msgerror = msprintf(gettext("Empty function...\n"));
+assert_checkerror ( "error(28)" , msgerror );
+
+msgerror = msprintf(gettext("Matrix is not positive definite.\n"));
+assert_checkerror ( "error(29)" , msgerror );
+
+msgerror = msprintf(gettext("Invalid exponent.\n"));
+assert_checkerror ( "error(30)" , msgerror );
+
+msgerror = msprintf(gettext("Incorrect string.\n"));
+assert_checkerror ( "error(31)" , msgerror );
+
+msgerror = msprintf(gettext("Singularity of log or tan function.\n"));
+assert_checkerror ( "error(32)" , msgerror );
+
+msgerror = msprintf(gettext("Too many '':''\n"));
+assert_checkerror ( "error(33)" , msgerror );
+
+msgerror = msprintf(gettext("Incorrect control instruction syntax.\n"));
+assert_checkerror ( "error(34)" , msgerror );
+
+msgerror = msprintf(gettext("Incorrect control instruction syntax.\n"));
+assert_checkerror ( "error(34)" , msgerror );
+
+msgerror = msprintf(gettext("Syntax error in a ''%s'' instruction.\n") , "select/case");
+assert_checkerror ( "error(35)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong input argument %d.\n") , 18);
+assert_checkerror ( "error(36,18)" , msgerror );
+
+msgerror = msprintf(gettext("Incorrect function at line %d.\n") , 18);
+assert_checkerror ( "error(37,18)" , msgerror );
+
+msgerror = msprintf(gettext("Incorrect function.\n"));
+assert_checkerror ( "error(37)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong file name.\n"));
+assert_checkerror ( "error(38)" , msgerror );
+
+msgerror = msprintf(gettext("Incorrect number of input arguments.\n"));
+assert_checkerror ( "error(39)" , msgerror );
+
+msgerror = msprintf(gettext("Waiting for end of command.\n"));
+assert_checkerror ( "error(40)" , msgerror );
+
+msgerror = msprintf(gettext("Incompatible output argument.\n"));
+assert_checkerror ( "error(41)" , msgerror );
+
+msgerror = msprintf(gettext("Incompatible input argument.\n"));
+assert_checkerror ( "error(42)" , msgerror );
+
+msgerror = msprintf(gettext("Not implemented in scilab...\n"));
+assert_checkerror ( "error(43)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong argument %d.\n"), 8);
+assert_checkerror ( "error(44,8)" , msgerror );
+
+msgerror = msprintf(gettext("null matrix (argument # %d).\n"), 81);
+assert_checkerror ( "error(45,81)" , msgerror );
+
+msgerror = msprintf(gettext("Incorrect syntax.\n"));
+assert_checkerror ( "error(46)" , msgerror );
+
+msgerror = msprintf(gettext(" end or else is missing...\n"));
+assert_checkerror ( "error(47)" , msgerror );
+
+msgerror = msprintf(gettext(" input line longer than buffer size: %d\n"), 4096);
+assert_checkerror ( "error(48)" , msgerror );
+
+msgerror = msprintf(gettext("Incorrect file or format.\n"));
+assert_checkerror ( "error(49)" , msgerror );
+
+msgerror = msprintf(gettext("subroutine not found: %s\n"),"");
+assert_checkerror ( "error(50)" , msgerror );
+
+msgerror = "";
+assert_checkerror ( "error(51)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for argument %d: Real matrix expected.\n"), 69);
+assert_checkerror ( "error(52, 69)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for input argument %d: Real or complex matrix expected.\n"), 69);
+assert_checkerror ( "error(53, 69)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for input argument %d: Polynomial expected.\n"), 69);
+assert_checkerror ( "error(54, 69)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for argument %d: String expected.\n"), 69);
+assert_checkerror ( "error(55, 69)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for argument %d: List expected.\n"), 69);
+assert_checkerror ( "error(56, 69)" , msgerror );
+
+msgerror = msprintf(gettext("Problem with comparison symbol...\n"));
+assert_checkerror ( "error(57)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong number of input arguments."));
+assert_checkerror ( "error(58)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong number of output arguments.\n"));
+assert_checkerror ( "error(59)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong size for argument: Incompatible dimensions.\n"));
+assert_checkerror ( "error(60)" , msgerror );
+
+msgerror = msprintf(gettext("Direct access : give format.\n"));
+assert_checkerror ( "error(61)" , msgerror );
+
+msgerror = msprintf(gettext("End of file at line %d.\n"), 45);
+assert_checkerror ( "error(62,45)" , msgerror );
+
+msgerror = msprintf(gettext("%d graphic terminal?\n"), 45);
+assert_checkerror ( "error(63,45)" , msgerror );
+
+msgerror = msprintf(gettext("Integration fails.\n"));
+assert_checkerror ( "error(64)" , msgerror );
+
+msgerror = msprintf(gettext("%d: logical unit already used.\n"), 45);
+assert_checkerror ( "error(65,45)" , msgerror );
+
+msgerror = msprintf(gettext("Too many files opened!\n"));
+assert_checkerror ( "error(66)" , msgerror );
+
+msgerror = msprintf(gettext("Unknown file format.\n"));
+assert_checkerror ( "error(67)" , msgerror );
+
+msgerror = msprintf(gettext("Floating point exception.\n"));
+assert_checkerror ( "error(69)" , msgerror );
+
+msgerror = msprintf(gettext("Too many arguments in fort (max 30).\n"));
+assert_checkerror ( "error(70)" , msgerror );
+
+msgerror = msprintf(gettext("This variable is not valid in fort.\n"));
+assert_checkerror ( "error(71)" , msgerror );
+
+msgerror = msprintf(gettext("%s is not valid in this context.\n"), "error");
+assert_checkerror ( "error(72)" , msgerror );
+
+msgerror = msprintf(gettext("Error while linking.\n"));
+assert_checkerror ( "error(73)" , msgerror );
+
+msgerror = msprintf(gettext("Leading coefficient is zero.\n"));
+assert_checkerror ( "error(74)" , msgerror );
+
+msgerror = msprintf(gettext("Too high degree (max 100).\n"));
+assert_checkerror ( "error(75)" , msgerror );
+
+msgerror = msprintf(gettext("for x=val with type(val)=%d  is not implemented in Scilab.\n"),18);
+assert_checkerror ( "error(76, 18)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong number of input arguments.\n"), "error");
+assert_checkerror ( "error(77)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong number of output arguments.\n"), "error");
+assert_checkerror ( "error(78)" , msgerror );
+
+msgerror = msprintf(gettext("Indexing not allowed for output arguments of resume.\n"));
+assert_checkerror ( "error(79)" , msgerror );
+
+msgerror = msprintf(gettext("Incorrect function (argument n: %d).\n"), 99);
+assert_checkerror ( "error(80, 99)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Real or complex matrix expected.\n"), "error", 99);
+assert_checkerror ( "error(81, 99)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Real matrix expected.\n"), "error", 99);
+assert_checkerror ( "error(82, 99)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Real vector expected.\n"), "error", 99);
+assert_checkerror ( "error(83, 99)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Scalar expected.\n"), "error", 99);
+assert_checkerror ( "error(84, 99)" , msgerror );
+
+msgerror = msprintf(gettext("Host does not answer...\n"));
+assert_checkerror ( "error(85)" , msgerror );
+
+msgerror = msprintf(gettext("Uncontrollable system.\n"));
+assert_checkerror ( "error(86)" , msgerror );
+
+msgerror = msprintf(gettext("Unobservable system.\n"));
+assert_checkerror ( "error(87)" , msgerror );
+
+msgerror = msprintf(gettext("%s: singular or asymmetric problem.\n"), "sfact");
+assert_checkerror ( "error(88)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong size for argument %d.\n"), 38);
+assert_checkerror ( "error(89, 38)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for argument %d: Transfer matrix expected.\n"), 38);
+assert_checkerror ( "error(90, 38)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for argument %d: In state space form expected.\n"), 38);
+assert_checkerror ( "error(91, 38)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for argument %d: Rational matrix expected.\n"), 38);
+assert_checkerror ( "error(92, 38)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for argument %d: In continuous time expected.\n"), 38);
+assert_checkerror ( "error(93, 38)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for argument %d: In discrete time expected.\n"), 38);
+assert_checkerror ( "error(94, 38)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for argument %d: SISO expected.\n"), 38);
+assert_checkerror ( "error(95, 38)" , msgerror );
+
+msgerror = msprintf(gettext("time domain of argument %d is not defined.\n"), 38);
+assert_checkerror ( "error(96, 38)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for argument %d: A system in state space or transfer matrix form expected.\n"), 38);
+assert_checkerror ( "error(97, 38)" , msgerror );
+
+msgerror = msprintf(gettext("Variable returned by scilab argument function is incorrect.\n"));
+assert_checkerror ( "error(98)" , msgerror );
+
+msgerror = msprintf(gettext("Elements of %dth argument must be in increasing order.\n"), 16);
+assert_checkerror ( "error(99, 16)" , msgerror );
+
+msgerror = msprintf(gettext("Elements of %dth argument are not in (strictly) decreasing order.\n"), 16);
+assert_checkerror ( "error(100, 16)" , msgerror );
+
+msgerror = msprintf(gettext("Last element of %dth argument <> first.\n"), 16);
+assert_checkerror ( "error(101, 16)" , msgerror );
+
+msgerror = msprintf(gettext("Variable or function %s are not in file.\n"), "error");
+assert_checkerror ( "error(102)" , msgerror );
+
+msgerror = msprintf(gettext("Variable %s is not a valid rational function.\n"), "error");
+assert_checkerror ( "error(103)" , msgerror );
+
+msgerror = msprintf(gettext("Variable %s is not a valid state space representation.\n"), "error");
+assert_checkerror ( "error(104)" , msgerror );
+
+msgerror = msprintf(gettext("Undefined fonction.\n"));
+assert_checkerror ( "error(105)" , msgerror );
+
+msgerror = msprintf(gettext("Function name already used.\n"));
+assert_checkerror ( "error(106)" , msgerror );
+
+msgerror = msprintf(gettext("Too many functions are defined (maximum #:%d).\n"), 18);
+assert_checkerror ( "error(107, 18)" , msgerror );
+
+msgerror = msprintf(gettext("Too complex for scilab, may be a too long control instruction.\n"));
+assert_checkerror ( "error(108)" , msgerror );
+
+msgerror = msprintf(gettext("Too large, can''t be displayed.\n"));
+assert_checkerror ( "error(109)" , msgerror );
+
+msgerror = msprintf(gettext("%s was a function when compiled but is now a primitive!\n"), "error");
+assert_checkerror ( "error(110)" , msgerror );
+
+msgerror = msprintf(gettext("Trying to re-define function %s.\n"), "error");
+assert_checkerror ( "error(111)" , msgerror );
+
+msgerror = msprintf(gettext("No more memory.\n"));
+assert_checkerror ( "error(112)" , msgerror );
+
+msgerror = msprintf(gettext("Too large string.\n"));
+assert_checkerror ( "error(113)" , msgerror );
+
+msgerror = msprintf(gettext("Too many linked routines.\n"));
+assert_checkerror ( "error(114)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong value for argument %d.\n"), 18);
+assert_checkerror ( "error(116, 18)" , msgerror );
+
+msgerror = msprintf(gettext("List element number %d is Undefined.\n"), 18);
+assert_checkerror ( "error(117, 18)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for argument %d: Named variable not an expression expected.\n"), 18);
+assert_checkerror ( "error(118, 18)" , msgerror );
+
+msgerror = "";
+assert_checkerror ( "error(119)" , msgerror );
+
+msgerror = msprintf(gettext("Indices for non-zero elements must be given by a 2 column matrix.\n"));
+assert_checkerror ( "error(120)" , msgerror );
+
+msgerror = msprintf(gettext("Incompatible indices for non-zero elements.\n"));
+assert_checkerror ( "error(121)" , msgerror );
+
+msgerror = msprintf(gettext("Logical unit number should be larger than %d.\n"), 12);
+assert_checkerror ( "error(122, 12)" , msgerror );
+
+msgerror = msprintf(gettext("Function not bounded from below.\n"));
+assert_checkerror ( "error(123)" , msgerror );
+
+msgerror = "";
+assert_checkerror ( "error(124)" , msgerror );
+
+msgerror = msprintf(gettext("Problem may be unbounded: too high distance between two consecutive iterations.\n"));
+assert_checkerror ( "error(125)" , msgerror );
+
+msgerror = msprintf(gettext("Inconsistent constraints.\n"));
+assert_checkerror ( "error(126)" , msgerror );
+
+msgerror = msprintf(gettext("No feasible solution.\n"));
+assert_checkerror ( "error(127)" , msgerror );
+
+msgerror = msprintf(gettext("Degenerate starting point.\n"));
+assert_checkerror ( "error(128)" , msgerror );
+
+msgerror = msprintf(gettext("No feasible point has been found.\n"));
+assert_checkerror ( "error(129)" , msgerror );
+
+msgerror = msprintf(gettext("Optimization fails: back to initial point.\n"));
+assert_checkerror ( "error(130)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Stop requested by simulator (ind=0)\n"), "optim");
+assert_checkerror ( "error(131)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong input parameters.\n"), "optim");
+assert_checkerror ( "error(132)" , msgerror );
+
+msgerror = msprintf(gettext("Too small memory.\n"));
+assert_checkerror ( "error(133)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Problem with initial constants in simul.\n"), "optim");
+assert_checkerror ( "error(134)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Bounds and initial guess are incompatible.\n"), "optim");
+assert_checkerror ( "error(135)" , msgerror );
+
+msgerror = msprintf(gettext("%s: This method is NOT implemented.\n"), "optim");
+assert_checkerror ( "error(136)" , msgerror );
+
+msgerror = msprintf(gettext("NO hot restart available in this method.\n"));
+assert_checkerror ( "error(137)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Incorrect stopping parameters.\n"), "optim");
+assert_checkerror ( "error(138)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Incorrect bounds.\n"), "optim");
+assert_checkerror ( "error(139)" , msgerror );
+
+msgerror = msprintf(gettext("Variable : %s must be a list\n"), "error");
+assert_checkerror ( "error(140)" , msgerror );
+
+msgerror = msprintf(gettext("Incorrect function (argument n: %d).\n"), 22);
+assert_checkerror ( "error(141, 22)" , msgerror );
+
+msgerror = msprintf(gettext("Hot restart: dimension of working table (argument n:%d).\n"), 22);
+assert_checkerror ( "error(142, 22)" , msgerror );
+
+msgerror = msprintf(gettext("%s: df0 must be positive !\n"), "optim");
+assert_checkerror ( "error(143)" , msgerror );
+
+msgerror = "";
+assert_checkerror ( "error(200)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Real or complex matrix expected.\n"), "error", 22);
+assert_checkerror ( "error(201, 22)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Real matrix expected.\n"), "error", 22);
+assert_checkerror ( "error(202, 22)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Real vector expected.\n"), "error", 22);
+assert_checkerror ( "error(203, 22)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Scalar expected.\n"), "error", 22);
+assert_checkerror ( "error(204, 22)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong size for argument %d: (%d,%d) expected.\n"), "error", 0, 1 , 301);
+assert_checkerror ( "error(205)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong size for argument %d: %d expected.\n"), "error", 0, 1);
+assert_checkerror ( "error(206)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Matrix of strings expected.\n"), "error", 0);
+assert_checkerror ( "error(207)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Boolean matrix expected.\n"), "error", 20);
+assert_checkerror ( "error(208, 20)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Matrix expected.\n"), "error", 20);
+assert_checkerror ( "error(209, 20)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: List expected.\n"), "error", 20);
+assert_checkerror ( "error(210, 20)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Function or string (external function) expected.\n"), "error", 20);
+assert_checkerror ( "error(211, 20)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Polynomial expected.\n"), "error", 20);
+assert_checkerror ( "error(212, 20)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Working int matrix expected.\n"), "error", 20);
+assert_checkerror ( "error(213, 20)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Wrong type for argument %d: Vector expected.\n"), "error", 20);
+assert_checkerror ( "error(214, 20)" , msgerror );
+
+msgerror = msprintf(gettext("%dth argument type must be boolean.\n"), 20);
+assert_checkerror ( "error(215, 20)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for argument %d: Boolean or scalar expected.\n"), 20);
+assert_checkerror ( "error(216, 20)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for argument %d: Sparse matrix of scalars expected.\n"), 20);
+assert_checkerror ( "error(217, 20)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for argument %d: Handle to sparse lu factors expected.\n"), 20);
+assert_checkerror ( "error(218, 20)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type argument %d: Sparse or full scalar matrix expected.\n"), 20);
+assert_checkerror ( "error(219, 20)" , msgerror );
+
+msgerror = msprintf(gettext("Null variable cannot be used here.\n"));
+assert_checkerror ( "error(220)" , msgerror );
+
+msgerror = msprintf(gettext("A sparse matrix entry is defined with two different values.\n"));
+assert_checkerror ( "error(221)" , msgerror );
+
+msgerror = msprintf(gettext("%s not yet implemented for full input parameter.\n"), "lusolve");
+assert_checkerror ( "error(222)" , msgerror );
+
+msgerror = msprintf(gettext("It is not possible to redefine the %s primitive this way (see clearfun).\n"), "error");
+assert_checkerror ( "error(223)" , msgerror );
+
+msgerror = msprintf(gettext("Type data base is full.\n"));
+assert_checkerror ( "error(224)" , msgerror );
+
+msgerror = msprintf(gettext("This data type is already defined.\n"));
+assert_checkerror ( "error(225)" , msgerror );
+
+msgerror = msprintf(gettext("Inequality comparison with empty matrix.\n"));
+assert_checkerror ( "error(226)" , msgerror );
+
+msgerror = msprintf(gettext("Missing index.\n"));
+assert_checkerror ( "error(227)" , msgerror );
+
+msgerror = msprintf(gettext("reference to the cleared global variable %s.\n"), "error");
+assert_checkerror ( "error(228)" , msgerror );
+
+msgerror = msprintf(gettext("Operands of / and \\ operations must not contain NaN of Inf.\n"));
+assert_checkerror ( "error(229)" , msgerror );
+
+msgerror = msprintf(gettext("semi def fails.\n"));
+assert_checkerror ( "error(230)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong type for first input argument: Single string expected.\n"));
+assert_checkerror ( "error(231)" , msgerror );
+
+msgerror = msprintf(gettext("Entry name not found.\n"));
+assert_checkerror ( "error(232)" , msgerror );
+
+msgerror = msprintf(gettext("Maximum number of dynamic interfaces reached.\n"));
+assert_checkerror ( "error(233)" , msgerror );
+
+msgerror = msprintf(gettext("%s: expecting more than one argument.\n"), "link");
+assert_checkerror ( "error(234)" , msgerror );
+
+msgerror = msprintf(gettext("%s: problem with one of the entry point.\n"), "link");
+assert_checkerror ( "error(235)" , msgerror );
+
+msgerror = msprintf(gettext("%s: the shared archive was not loaded.\n"), "link");
+assert_checkerror ( "error(236)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Only one entry point allowed on this operating system.\n"), "link");
+assert_checkerror ( "error(237)" , msgerror );
+
+msgerror = msprintf(gettext("%s: First argument cannot be a number.\n"), "link");
+assert_checkerror ( "error(238)" , msgerror );
+
+msgerror = msprintf(gettext("You cannot link more functions, maxentry reached.\n"));
+assert_checkerror ( "error(239)" , msgerror );
+
+msgerror = msprintf(gettext("You cannot link more functions, maxentry reached.\n"));
+assert_checkerror ( "error(239)" , msgerror );
+
+msgerror = msprintf(gettext("File ""%s"" already exists or directory write access denied.\n"), "");
+assert_checkerror ( "error(240)" , msgerror );
+
+msgerror = msprintf(gettext("File ""%s"" does not exist or read access denied.\n"), "");
+assert_checkerror ( "error(241)" , msgerror );
+
+msgerror = msprintf(gettext("Binary direct access files must be opened by ''file''.\n"));
+assert_checkerror ( "error(242)" , msgerror );
+
+msgerror = msprintf(gettext("C file logical unit not allowed here.\n"));
+assert_checkerror ( "error(243)" , msgerror );
+
+msgerror = msprintf(gettext("Fortran file logical unit not allowed here.\n"));
+assert_checkerror ( "error(244)" , msgerror );
+
+msgerror = msprintf(gettext("No input file associated to logical unit %d.\n"), 23);
+assert_checkerror ( "error(245, 23)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong value for argument %d: the lu handle is no more valid.\n"), 45);
+assert_checkerror ( "error(247, 45)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong value for argument %d: Valid variable name expected.\n"), 45);
+assert_checkerror ( "error(248, 45)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong value for argument %d: Empty string expected.\n"), 45);
+assert_checkerror ( "error(249, 45)" , msgerror );
+
+msgerror = msprintf(gettext("Recursive extraction is not valid in this context.\n"));
+assert_checkerror ( "error(250)" , msgerror );
+
+msgerror = msprintf(gettext("%s: ipar dimensioned at least 11.\n"), "bvode");
+assert_checkerror ( "error(251)" , msgerror );
+
+msgerror = msprintf(gettext("%s: ltol must be of size ipar(4).\n"), "bvode");
+assert_checkerror ( "error(252)" , msgerror );
+
+msgerror = msprintf(gettext("%s: fixpnt must be of size ipar(11).\n"), "bvode");
+assert_checkerror ( "error(253)" , msgerror );
+
+msgerror = msprintf(gettext("%s: ncomp < 20 requested.\n"), "bvode");
+assert_checkerror ( "error(254)" , msgerror );
+
+msgerror = msprintf(gettext("%s: m must be of size ncomp.\n"), "bvode");
+assert_checkerror ( "error(255)" , msgerror );
+
+msgerror = msprintf(gettext("%s: sum(m) must be less than 40.\n"), "bvode");
+assert_checkerror ( "error(256)" , msgerror );
+
+msgerror = msprintf(gettext("%s: sum(m) must be less than 40.\n"), "bvode");
+assert_checkerror ( "error(257)" , msgerror );
+
+msgerror = msprintf(gettext("%s: input data error.\n"), "bvode");
+assert_checkerror ( "error(258)" , msgerror );
+
+msgerror = msprintf(gettext("%s: no. of subintervals exceeds storage.\n"), "bvode");
+assert_checkerror ( "error(259)" , msgerror );
+
+msgerror = msprintf(gettext("%s: The colocation matrix is singular.\n"), "bvode");
+assert_checkerror ( "error(260)" , msgerror );
+
+msgerror = msprintf(gettext("Interface property table is full.\n"));
+assert_checkerror ( "error(261)" , msgerror );
+
+msgerror = msprintf(gettext("Error while writing in file: disk full or deleted file.\n"));
+assert_checkerror ( "error(263)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong value for argument %d: Must not contain NaN or Inf.\n"), 2);
+assert_checkerror ( "error(264, 2)" , msgerror );
+
+msgerror = msprintf(gettext("%s and %s must have equal number of rows.\n"), "A", "B");
+assert_checkerror ( "error(265)" , msgerror );
+
+msgerror = msprintf(gettext("%s and %s must have equal number of columns.\n"), "A", "B");
+assert_checkerror ( "error(266)" , msgerror );
+
+msgerror = msprintf(gettext("%s and %s must have equal dimensions.\n"), "A", "B");
+assert_checkerror ( "error(267)" , msgerror );
+
+msgerror = msprintf(gettext("Invalid return value for function passed in arg %d.\n"), 8);
+assert_checkerror ( "error(268, 8)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong value for argument %d: eigenvalues must have negative real parts.\n"), 8);
+assert_checkerror ( "error(269, 8)" , msgerror );
+
+msgerror = msprintf(gettext("Wrong value for argument %d: eigenvalues modulus must be less than one.\n"), 8);
+assert_checkerror ( "error(270, 8)" , msgerror );
+
+msgerror = msprintf(gettext("Size varying argument a*eye(), (arg %d) not allowed here.\n"), 8);
+assert_checkerror ( "error(271, 8)" , msgerror );
+
+msgerror = msprintf(gettext("endfunction is missing.\n"));
+assert_checkerror ( "error(272)" , msgerror );
+
+msgerror = msprintf(gettext("Instruction left hand side: waiting for a dot or a left parenthesis.\n"));
+assert_checkerror ( "error(273)" , msgerror );
+
+msgerror = msprintf(gettext("Instruction left hand side: waiting for a name.\n"));
+assert_checkerror ( "error(274)" , msgerror );
+
+msgerror = msprintf(gettext("varargout keyword cannot be used here.\n"));
+assert_checkerror ( "error(275)" , msgerror );
+
+msgerror = msprintf(gettext("Missing operator, comma, or semicolon.\n"));
+assert_checkerror ( "error(276)" , msgerror );
+
+msgerror = msprintf(gettext("Too many commands defined.\n"));
+assert_checkerror ( "error(277)" , msgerror );
+
+msgerror = msprintf(gettext("%s: Input arguments should have the same formal variable name.\n"), "error");
+assert_checkerror ( "error(278)" , msgerror );
+
+msgerror = "";
+assert_checkerror ( "error(279)" , msgerror );
+
+msgerror = "";
+assert_checkerror ( "error(280)" , msgerror );
+
index 3d59a59..7b722dc 100644 (file)
@@ -27,7 +27,7 @@ OUTPUT_STREAM_C_SOURCES =     src/c/erro.c \
                                src/c/sciprint.c \
                                src/c/sciprint_full.c \
                                src/c/errmds.c \
-                               src/c/errmsg.c \
+                               src/c/errorTable.c \
                                src/c/error.c \
                                src/c/error_internal.c \
                                src/c/do_xxprintf.c \
index 044b898..3241ca4 100644 (file)
@@ -116,29 +116,29 @@ am__installdirs = "$(DESTDIR)$(pkglibdir)" \
        "$(DESTDIR)$(libscioutput_stream_la_sci_gatewaydir)" \
        "$(DESTDIR)$(libscioutput_stream_la_includedir)"
 LTLIBRARIES = $(noinst_LTLIBRARIES) $(pkglib_LTLIBRARIES)
-libscioutput_stream_algo_la_LIBADD =
-am__objects_1 = libscioutput_stream_algo_la-erro.lo \
-       libscioutput_stream_algo_la-cerro.lo \
-       libscioutput_stream_algo_la-Scierror.lo \
-       libscioutput_stream_algo_la-msgstore.lo \
-       libscioutput_stream_algo_la-msgout.lo \
-       libscioutput_stream_algo_la-msgs.lo \
-       libscioutput_stream_algo_la-msgstxt.lo \
-       libscioutput_stream_algo_la-basout.lo \
-       libscioutput_stream_algo_la-sciprint.lo \
-       libscioutput_stream_algo_la-sciprint_full.lo \
-       libscioutput_stream_algo_la-errmds.lo \
-       libscioutput_stream_algo_la-errmsg.lo \
-       libscioutput_stream_algo_la-error.lo \
-       libscioutput_stream_algo_la-error_internal.lo \
-       libscioutput_stream_algo_la-do_xxprintf.lo \
-       libscioutput_stream_algo_la-set_xxprintf.lo \
-       libscioutput_stream_algo_la-lasterror.lo
-am__objects_2 = libscioutput_stream_algo_la-Diary.lo \
-       libscioutput_stream_algo_la-DiaryList.lo \
-       libscioutput_stream_algo_la-diary_manager.lo \
-       libscioutput_stream_algo_la-getDiaryDate.lo \
-       libscioutput_stream_algo_la-getFullFilename.lo
+libscioutput_stream_la_LIBADD =
+am__objects_1 = libscioutput_stream_la-erro.lo \
+       libscioutput_stream_la-cerro.lo \
+       libscioutput_stream_la-Scierror.lo \
+       libscioutput_stream_la-msgstore.lo \
+       libscioutput_stream_la-msgout.lo \
+       libscioutput_stream_la-msgs.lo \
+       libscioutput_stream_la-msgstxt.lo \
+       libscioutput_stream_la-basout.lo \
+       libscioutput_stream_la-sciprint.lo \
+       libscioutput_stream_la-sciprint_full.lo \
+       libscioutput_stream_la-errmds.lo \
+       libscioutput_stream_la-errorTable.lo \
+       libscioutput_stream_la-error.lo \
+       libscioutput_stream_la-error_internal.lo \
+       libscioutput_stream_la-do_xxprintf.lo \
+       libscioutput_stream_la-set_xxprintf.lo \
+       libscioutput_stream_la-lasterror.lo
+am__objects_2 = libscioutput_stream_la-Diary.lo \
+       libscioutput_stream_la-DiaryList.lo \
+       libscioutput_stream_la-diary_manager.lo \
+       libscioutput_stream_la-getDiaryDate.lo \
+       libscioutput_stream_la-getFullFilename.lo
 am__objects_3 = wspdsp.lo wmdsp.lo strdsp.lo prntid.lo print.lo \
        lspdsp.lo fmttyp.lo fmt.lo dspdsp.lo dmrdsp.lo dmpdsp.lo \
        dmdspf.lo dmdsp.lo dldsp.lo basouttofile.lo formatnumber.lo
@@ -469,7 +469,7 @@ OUTPUT_STREAM_C_SOURCES = src/c/erro.c \
                                src/c/sciprint.c \
                                src/c/sciprint_full.c \
                                src/c/errmds.c \
-                               src/c/errmsg.c \
+                               src/c/errorTable.c \
                                src/c/error.c \
                                src/c/error_internal.c \
                                src/c/do_xxprintf.c \
@@ -704,28 +704,20 @@ mostlyclean-compile:
 distclean-compile:
        -rm -f *.tab.c
 
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-Diary.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-DiaryList.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-Scierror.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-basout.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-cerro.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-diary_manager.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-do_xxprintf.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-errmds.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-errmsg.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-erro.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-error.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-error_internal.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-getDiaryDate.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-getFullFilename.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-lasterror.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-msgout.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-msgs.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-msgstore.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-msgstxt.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-sciprint.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-sciprint_full.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_algo_la-set_xxprintf.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_la-Diary.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_la-DiaryList.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_la-Scierror.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_la-basout.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_la-cerro.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_la-diary_manager.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_la-do_xxprintf.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_la-errmds.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_la-errorTable.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_la-erro.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_la-error.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_la-error_internal.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_la-getDiaryDate.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_la-getFullFilename.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_la-gw_output_stream.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_la-sci_diary.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscioutput_stream_la-sci_disp.Plo@am__quote@
@@ -831,12 +823,12 @@ libscioutput_stream_algo_la-errmds.lo: src/c/errmds.c
 @AMDEP_TRUE@@am__fastdepCC_FALSE@      DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@  $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscioutput_stream_algo_la_CPPFLAGS) $(CPPFLAGS) $(libscioutput_stream_algo_la_CFLAGS) $(CFLAGS) -c -o libscioutput_stream_algo_la-errmds.lo `test -f 'src/c/errmds.c' || echo '$(srcdir)/'`src/c/errmds.c
 
-libscioutput_stream_algo_la-errmsg.lo: src/c/errmsg.c
-@am__fastdepCC_TRUE@   $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscioutput_stream_algo_la_CPPFLAGS) $(CPPFLAGS) $(libscioutput_stream_algo_la_CFLAGS) $(CFLAGS) -MT libscioutput_stream_algo_la-errmsg.lo -MD -MP -MF $(DEPDIR)/libscioutput_stream_algo_la-errmsg.Tpo -c -o libscioutput_stream_algo_la-errmsg.lo `test -f 'src/c/errmsg.c' || echo '$(srcdir)/'`src/c/errmsg.c
-@am__fastdepCC_TRUE@   $(am__mv) $(DEPDIR)/libscioutput_stream_algo_la-errmsg.Tpo $(DEPDIR)/libscioutput_stream_algo_la-errmsg.Plo
-@AMDEP_TRUE@@am__fastdepCC_FALSE@      source='src/c/errmsg.c' object='libscioutput_stream_algo_la-errmsg.lo' libtool=yes @AMDEPBACKSLASH@
+libscioutput_stream_la-errorTable.lo: src/c/errorTable.c
+@am__fastdepCC_TRUE@   $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscioutput_stream_la_CPPFLAGS) $(CPPFLAGS) $(libscioutput_stream_la_CFLAGS) $(CFLAGS) -MT libscioutput_stream_la-errorTable.lo -MD -MP -MF $(DEPDIR)/libscioutput_stream_la-errorTable.Tpo -c -o libscioutput_stream_la-errorTable.lo `test -f 'src/c/errorTable.c' || echo '$(srcdir)/'`src/c/errorTable.c
+@am__fastdepCC_TRUE@   $(am__mv) $(DEPDIR)/libscioutput_stream_la-errorTable.Tpo $(DEPDIR)/libscioutput_stream_la-errorTable.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@      source='src/c/errorTable.c' object='libscioutput_stream_la-errorTable.lo' libtool=yes @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@      DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@  $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscioutput_stream_algo_la_CPPFLAGS) $(CPPFLAGS) $(libscioutput_stream_algo_la_CFLAGS) $(CFLAGS) -c -o libscioutput_stream_algo_la-errmsg.lo `test -f 'src/c/errmsg.c' || echo '$(srcdir)/'`src/c/errmsg.c
+@am__fastdepCC_FALSE@  $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscioutput_stream_la_CPPFLAGS) $(CPPFLAGS) $(libscioutput_stream_la_CFLAGS) $(CFLAGS) -c -o libscioutput_stream_la-errorTable.lo `test -f 'src/c/errorTable.c' || echo '$(srcdir)/'`src/c/errorTable.c
 
 libscioutput_stream_algo_la-error.lo: src/c/error.c
 @am__fastdepCC_TRUE@   $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscioutput_stream_algo_la_CPPFLAGS) $(CPPFLAGS) $(libscioutput_stream_algo_la_CFLAGS) $(CFLAGS) -MT libscioutput_stream_algo_la-error.lo -MD -MP -MF $(DEPDIR)/libscioutput_stream_algo_la-error.Tpo -c -o libscioutput_stream_algo_la-error.lo `test -f 'src/c/error.c' || echo '$(srcdir)/'`src/c/error.c
index 760f5b6..9844e94 100644 (file)
@@ -1,6 +1,7 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) INRIA - 
+ * Copyright (C) DIGITEO - 2010 - Allan CORNET
  * 
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
@@ -41,7 +42,7 @@ int  Scierror(int iv,const char *fmt,...)
        lstr = (int) strlen(s_buf);
        va_end(ap);
 
-       error_internal(&iv,s_buf,ERROR_FROM_C);
+       error_internal(&iv,s_buf);
 
        return retval;
 }
diff --git a/scilab/modules/output_stream/src/c/errmsg.h b/scilab/modules/output_stream/src/c/errmsg.h
deleted file mode 100644 (file)
index dc07b99..0000000
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) INRIA - Bruno JOFFRET
- * 
- * This file must be used under the terms of the CeCILL.
- * This source file is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.  The terms
- * are also available at    
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
-
-#ifndef        __ERRMSG_H__
-#define        __ERRMSG_H__
-
-#include "machine.h"
-
-/*
-* errmsg displays the error message
-* @param[in] n : error number, if n exceeds the maximum error number this
-* routines displays the error message contained in buf
-* @param[out] errtyp : error type (recoverable:0 or not:1)
-*/
-int C2F(errmsg)(int *n,int *errtyp);
-
-#endif             /* !__ERRMSG_H__ */
index 562e9d9..8887c9d 100644 (file)
  */
 
 #include "do_error_number.h"
-#include "MALLOC.h" /* NULL*/
-#include "error_internal.h"
-#include "msgstore.h"
+#include "errorTable.h"
 #include "lasterror.h"
 /*--------------------------------------------------------------------------*/ 
 int C2F(error)(int *n)
 {
-    return error_internal(n,NULL,ERROR_FROM_FORTRAN);
+    return errorTable(*n);
 } 
 /*--------------------------------------------------------------------------*/ 
 void SciError(int n)
@@ -1,7 +1,6 @@
 /*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) INRIA - Allan CORNET
- * Copyright (C) DIGITEO - 2010 - Allan CORNET
+ * ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) DIGITEO - 2010-2011 - Allan CORNET
  * 
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
-
 #include <string.h>
 #include <stdio.h>
 #include <stdarg.h>
-#include "errmsg.h"
 #include "localization.h"
 #include "stack-c.h"
 #include "MALLOC.h"
 #include "stackinfo.h"
-#include "core_math.h"
 #include "inffic.h"
-#include "msgstore.h"
-#include "msgout.h"
-#include "lasterror.h"
 #ifdef _MSC_VER
 #include "strdup_Windows.h"
 #endif
-/*--------------------------------------------------------------------------*/
-extern int C2F(showstack)(); /* used in error 115 */
-extern int C2F(prntid)(); /* to print variables on stack */
-/*--------------------------------------------------------------------------*/
-static void strip_blank(char *source);
-static void displayAndStoreError(const char *msg,...);
-static void resetLastError(void);
-static char *getConvertedNameFromStack(int cvnametype);
-static char *defaultStringError(void);
-/*--------------------------------------------------------------------------*/
-#define EMPTY_BUFFER "00000000000000000000000"
-/*--------------------------------------------------------------------------*/
-#ifdef _MSC_VER
-#define vsnprintf _vsnprintf
-#endif
+#include "errorTable.h"
+#include "lasterror.h"
+#include "Scierror.h"
 /*--------------------------------------------------------------------------*/
 typedef enum {
     CVNAME_READING_TYPE_1 = 0, 
@@ -52,36 +33,39 @@ typedef enum {
     CVNAME_READING_TYPE_6 = 5,
 } CVNAME_TYPE;
 /*--------------------------------------------------------------------------*/
-int C2F(errmsg)(int *n,int *errtyp)
+extern int C2F(errmgr)(); /* fortran */
+/*--------------------------------------------------------------------------*/
+static void strip_blank(char *source);
+static char *getConvertedNameFromStack(int cvnametype);
+static char *defaultStringError(void);
+/*--------------------------------------------------------------------------*/
+int errorTable(int iErr)
 {
-    resetLastError();
-
-    /* store error code (lasterror) */
-    setLastErrorValue(*n);
+    int errtyp = 0; /* by default error can be catched */
+    int iValueReturned = 0;
 
-    *errtyp = 0; /* by default errors are recoverable */
-    /* errors not recoverable aren't catchable by top
-    try,catch */ 
-    /* errors 2,3,16,26,31,34,35,40,46,47,276*/
+    /* clean last error */
+    clearLastError();
 
-    switch ((int)*n)
+    switch (iErr)
     {
     case 1:
         {
-            displayAndStoreError(_("Incorrect assignment.\n"));
-
+            iValueReturned = Scierror(iErr, _("Incorrect assignment.\n"));
         }
         break;
     case 2:
         {
-            displayAndStoreError(_("Invalid factor.\n"));
-            *errtyp = 1;
+            iValueReturned = Scierror(iErr, _("Invalid factor.\n"));
+            errtyp = 1;
+            C2F(errmgr)(&iErr, &errtyp);
         }
         break;
     case 3:
         {
-            displayAndStoreError(_("Waiting for right parenthesis.\n"));
-            *errtyp = 1;
+            iValueReturned = Scierror(iErr, _("Waiting for right parenthesis.\n"));
+            errtyp = 1;
+            C2F(errmgr)(&iErr, &errtyp);
         }
         break;
     case 4:
@@ -92,7 +76,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             {
                 if (NameVarOnStack[0] != '0')
                 {
-                    displayAndStoreError(_("Undefined variable: %s\n"), NameVarOnStack);
+                    iValueReturned = Scierror(iErr, _("Undefined variable: %s\n"), NameVarOnStack);
                     FREE(NameVarOnStack);
                     NameVarOnStack = NULL;
                     break;
@@ -101,68 +85,69 @@ int C2F(errmsg)(int *n,int *errtyp)
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
-            displayAndStoreError(_("Undefined variable.\n"));
+            iValueReturned = Scierror(iErr, _("Undefined variable.\n"));
         }
         break;
     case 5:
         {
-            displayAndStoreError(_("Inconsistent column/row dimensions.\n"));
+            iValueReturned = Scierror(iErr, _("Inconsistent column/row dimensions.\n"));
         }
         break;
     case 6:
         {
-            displayAndStoreError(_("Inconsistent row/column dimensions.\n"));
+            iValueReturned = Scierror(iErr, _("Inconsistent row/column dimensions.\n"));
         }
         break;
     case 7:
         {
-            displayAndStoreError(_("Dot cannot be used as modifier for this operator.\n"));
+            iValueReturned = Scierror(iErr, _("Dot cannot be used as modifier for this operator.\n"));
         }
         break;
     case 8:
         {
-            displayAndStoreError(_("Inconsistent addition.\n"));
+            iValueReturned = Scierror(iErr, _("Inconsistent addition.\n"));
         }
         break;
     case 9:
         {
-            displayAndStoreError(_("Inconsistent subtraction.\n"));
+            iValueReturned = Scierror(iErr, _("Inconsistent subtraction.\n"));
         }
         break;
     case 10:
         {
-            displayAndStoreError(_("Inconsistent multiplication.\n"));
+            iValueReturned = Scierror(iErr, _("Inconsistent multiplication.\n"));
         }
         break;
     case 11:
         {
-            displayAndStoreError(_("Inconsistent right division.\n"));
+            iValueReturned = Scierror(iErr, _("Inconsistent right division.\n"));
         }
         break;
     case 12:
         {
-            displayAndStoreError(_("Inconsistent left division.\n"));
+            iValueReturned = Scierror(iErr, _("Inconsistent left division.\n"));
         }
         break;
     case 13:
         {
-            displayAndStoreError(_("Redefining permanent variable.\n"));
+            iValueReturned = Scierror(iErr, _("Redefining permanent variable.\n"));
         }
         break;
     case 14:
         {
-            displayAndStoreError(_("Eye variable undefined in this context.\n"));
+            iValueReturned = Scierror(iErr, _("Eye variable undefined in this context.\n"));
         }
         break;
     case 15:
         {
-            displayAndStoreError(_("Submatrix incorrectly defined.\n"));
+            iValueReturned = Scierror(iErr, _("Submatrix incorrectly defined.\n"));
         }
         break;
     case 16:
         {
-            displayAndStoreError(_("Incorrect command!\n"));
-            *errtyp = 1; /* error not recoverable */
+            iValueReturned = Scierror(iErr, _("Incorrect command!\n"));
+            errtyp = 1; /* error not recoverable */
+            C2F(errmgr)(&iErr, &errtyp);
         }
         break;
     case 17:
@@ -170,57 +155,67 @@ int C2F(errmsg)(int *n,int *errtyp)
             int Memory_used_for_variables = 0;
             int Intermediate_Memory = 0;
             int Total_Memory_available = 0;
+            char msgErr[bsiz];
+            char msgTmp[bsiz];
 
             Intermediate_Memory = getIntermediateMemoryNeeded();
-            C2F(getstackinfo)(&Total_Memory_available,&Memory_used_for_variables);
+            C2F(getstackinfo)(&Total_Memory_available, &Memory_used_for_variables);
+
+            strcpy(msgErr, _("stack size exceeded!\n"));
+            strcat(msgErr, _("Use stacksize function to increase it.\n"));
 
-            displayAndStoreError(_("stack size exceeded!\n"));
-            displayAndStoreError(_("Use stacksize function to increase it.\n"));
-            displayAndStoreError(_("Memory used for variables: %d\n"),Memory_used_for_variables);
-            displayAndStoreError(_("Intermediate memory needed: %d\n"),Intermediate_Memory);
-            displayAndStoreError(_("Total memory available: %d\n"),Total_Memory_available);
+            sprintf(msgTmp, _("Memory used for variables: %d\n"), Memory_used_for_variables);
+            strcat(msgErr, msgTmp);
+
+            sprintf(msgTmp, _("Intermediate memory needed: %d\n"), Intermediate_Memory);
+            strcat(msgErr, msgTmp);
+
+            sprintf(msgTmp, _("Total memory available: %d\n"), Total_Memory_available);
+            strcat(msgErr, msgTmp);
+
+            iValueReturned = Scierror(iErr, msgErr);
         }
         break;
     case 18:
         {
-            displayAndStoreError(_("Too many variables!\n"));
+            iValueReturned = Scierror(iErr, _("Too many variables!\n"));
         }
         break;
     case 19:
         {
-            displayAndStoreError(_("Problem is singular.\n"));
+            iValueReturned = Scierror(iErr, _("Problem is singular.\n"));
         }
         break;
     case 20:
         {
             if (Err == 1)
             {
-                displayAndStoreError(_("Wrong type for first argument: Square matrix expected.\n"));
+                iValueReturned = Scierror(iErr, _("Wrong type for first argument: Square matrix expected.\n"));
             }
             else
             {
-                displayAndStoreError(_("Wrong type for argument %d: Square matrix expected.\n"),Err);
+                iValueReturned = Scierror(iErr, _("Wrong type for argument %d: Square matrix expected.\n"),Err);
             }
         }
         break;
     case 21:
         {
-            displayAndStoreError(_("Invalid index.\n"));
+            iValueReturned = Scierror(iErr, _("Invalid index.\n"));
         }
         break;
     case 22:
         {
-            displayAndStoreError(_("Recursion problems. Sorry...\n"));
+            iValueReturned = Scierror(iErr, _("Recursion problems. Sorry...\n"));
         }
         break;
     case 23:
         {
-            displayAndStoreError(_("Matrix norms available are 1, 2, inf, and fro.\n"));
+            iValueReturned = Scierror(iErr, _("Matrix norms available are 1, 2, inf, and fro.\n"));
         }
         break;
     case 24:
         {
-            displayAndStoreError(_("Convergence problem...\n"));
+            iValueReturned = Scierror(iErr, _("Convergence problem...\n"));
         }
         break;
     case 25:
@@ -228,7 +223,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_2);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("Bad call to primitive: %s\n"),NameVarOnStack);
+                iValueReturned = Scierror(iErr, _("Bad call to primitive: %s\n"),NameVarOnStack);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -236,52 +231,55 @@ int C2F(errmsg)(int *n,int *errtyp)
         break;
     case 26:
         {
-            displayAndStoreError(_("Too complex recursion! (recursion tables are full)\n"));
+            iValueReturned = Scierror(iErr, _("Too complex recursion! (recursion tables are full)\n"));
             /* break recursion */
             C2F(recu).pt = Min(C2F(recu).pt,psiz);
-            *errtyp = 1; /* error not recoverable */
+            errtyp = 1; /* error not recoverable */
+            C2F(errmgr)(&iErr, &errtyp);
         }
         break;
     case 27:
         {
-            displayAndStoreError(_("Division by zero...\n"));
+            iValueReturned = Scierror(iErr, _("Division by zero...\n"));
         }
         break;
     case 28:
         {
-            displayAndStoreError(_("Empty function...\n"));
+            iValueReturned = Scierror(iErr, _("Empty function...\n"));
         }
         break;
     case 29:
         {
-            displayAndStoreError(_("Matrix is not positive definite.\n"));
+            iValueReturned = Scierror(iErr, _("Matrix is not positive definite.\n"));
         }
         break;
     case 30:
         {
-            displayAndStoreError(_("Invalid exponent.\n"));
+            iValueReturned = Scierror(iErr, _("Invalid exponent.\n"));
         }
         break;
     case 31:
         {
-            displayAndStoreError(_( "Incorrect string.\n"));
-            *errtyp = 1; /* error not recoverable */
+            iValueReturned = Scierror(iErr, _( "Incorrect string.\n"));
+            errtyp = 1; /* error not recoverable */
+            C2F(errmgr)(&iErr, &errtyp);
         }
         break;
     case 32:
         {
-            displayAndStoreError(_("Singularity of log or tan function.\n"));
+            iValueReturned = Scierror(iErr, _("Singularity of log or tan function.\n"));
         }
         break;
     case 33:
         {
-            displayAndStoreError(_("Too many ':'\n"));
+            iValueReturned = Scierror(iErr, _("Too many ':'\n"));
         }
         break;
     case 34:
         {
-            displayAndStoreError(_("Incorrect control instruction syntax.\n"));
-            *errtyp = 1; /* error not recoverable */
+            iValueReturned = Scierror(iErr, _("Incorrect control instruction syntax.\n"));
+            errtyp = 1; /* error not recoverable */
+            C2F(errmgr)(&iErr, &errtyp);
         }
         break;
     case 35:
@@ -289,109 +287,112 @@ int C2F(errmsg)(int *n,int *errtyp)
             switch (C2F(recu).ids[C2F(recu).pt * nsiz - nsiz]) /* find instruction type */
             {
             case 1: /* if */
-                displayAndStoreError(_("Syntax error in a '%s' instruction.\n"),"if");
+                iValueReturned = Scierror(iErr,_("Syntax error in a '%s' instruction.\n"), "if");
                 break;
 
             case 2: /* while */
-                displayAndStoreError(_("Syntax error in a '%s' instruction.\n"),"while");
+                iValueReturned = Scierror(iErr,_("Syntax error in a '%s' instruction.\n"),"while");
                 break;
 
             default: /* select/case */
-                displayAndStoreError(_("Syntax error in a '%s' instruction.\n"),"select/case");
+                iValueReturned = Scierror(iErr,_("Syntax error in a '%s' instruction.\n"),"select/case");
                 break;
             }
-            *errtyp = 1; /* error not recoverable */
+            errtyp = 1; /* error not recoverable */
+            C2F(errmgr)(&iErr, &errtyp);
         }
         break;
     case 36:
         {
             if (Err == 1)
             {
-                displayAndStoreError(_("Wrong first argument.\n"));
+                iValueReturned = Scierror(iErr, _("Wrong first argument.\n"));
             }
             else
             {
-                displayAndStoreError(_("Wrong input argument %d.\n"),Err);
+                iValueReturned = Scierror(iErr, _("Wrong input argument %d.\n"),Err);
             }
         }
         break;
     case 37:
         {
             if (Err>0) 
-                displayAndStoreError(_("Incorrect function at line %d.\n"),Err);
+                iValueReturned = Scierror(iErr, _("Incorrect function at line %d.\n"),Err);
             else
-                displayAndStoreError(_("Incorrect function.\n"));
+                iValueReturned = Scierror(iErr, _("Incorrect function.\n"));
         }
         break;
     case 38:
         {
-            displayAndStoreError(_("Wrong file name.\n"));
+            iValueReturned = Scierror(iErr, _("Wrong file name.\n"));
         }
         break;
     case 39:
         {
-            displayAndStoreError(_("Incorrect number of input arguments.\n"));
+            iValueReturned = Scierror(iErr, _("Incorrect number of input arguments.\n"));
         }
         break;
     case 40:
         {
-            displayAndStoreError(_("Waiting for end of command.\n"));
-            *errtyp = 1; /* error not recoverable */
+            iValueReturned = Scierror(iErr, _("Waiting for end of command.\n"));
+            errtyp = 1; /* error not recoverable */
+            C2F(errmgr)(&iErr, &errtyp);
         }
         break;
     case 41:
         {
-            displayAndStoreError(_("Incompatible output argument.\n"));
+            iValueReturned = Scierror(iErr, _("Incompatible output argument.\n"));
         }
         break;
     case 42:
         {
-            displayAndStoreError(_("Incompatible input argument.\n"));
+            iValueReturned = Scierror(iErr, _("Incompatible input argument.\n"));
         }
         break;
     case 43:
         {
-            displayAndStoreError(_("Not implemented in scilab...\n"));
+            iValueReturned = Scierror(iErr, _("Not implemented in scilab...\n"));
         }
         break;
     case 44:
         {
             if (Err == 1)
             {
-                displayAndStoreError(_("Wrong first argument.\n"));
+                iValueReturned = Scierror(iErr, _("Wrong first argument.\n"));
             }
             else
             {
-                displayAndStoreError(_("Wrong argument %d.\n"),Err);
+                iValueReturned = Scierror(iErr, _("Wrong argument %d.\n"),Err);
             }
-
         }
         break;
     case 45:
         {
-            displayAndStoreError(_("null matrix (argument # %d).\n"),Err);
+            iValueReturned = Scierror(iErr, _("null matrix (argument # %d).\n"),Err);
         }
         break;
     case 46:
         {
-            displayAndStoreError(_("Incorrect syntax.\n"));
-            *errtyp = 1; /* error not recoverable */
+            iValueReturned = Scierror(iErr, _("Incorrect syntax.\n"));
+            errtyp = 1; /* error not recoverable */
+            C2F(errmgr)(&iErr, &errtyp);
         }
         break;
     case 47:
         {
-            displayAndStoreError(_(" end or else is missing...\n"));
-            *errtyp = 1; /* error not recoverable */
+            iValueReturned = Scierror(iErr, _(" end or else is missing...\n"));
+            errtyp = 1; /* error not recoverable */
+            C2F(errmgr)(&iErr, &errtyp);
         }
         break;
     case 48:
         {
-            displayAndStoreError(_(" input line longer than buffer size: %d\n"),bsiz);
+            iValueReturned = Scierror(iErr, _(" input line longer than buffer size: %d\n"),bsiz);
         }
         break;
     case 49:
         {
-            displayAndStoreError(_("Incorrect file or format.\n"));
+            iValueReturned = Scierror(iErr, _("Incorrect file or format.\n"));
         }
         break;
     case 50:
@@ -399,7 +400,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_5);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("subroutine not found: %s\n"),NameVarOnStack);
+                iValueReturned = Scierror(iErr, _("subroutine not found: %s\n"), NameVarOnStack);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -408,130 +409,126 @@ int C2F(errmsg)(int *n,int *errtyp)
     case 51:
         {
             /* no message  */
+             iValueReturned = Scierror(iErr, "");
         }
         break;
     case 52:
         {
-            displayAndStoreError(_("Wrong type for argument %d: Real matrix expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong type for argument %d: Real matrix expected.\n"),Err);
         }
         break;
     case 53:
         {
-            displayAndStoreError(_("Wrong type for input argument %d: Real or complex matrix expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong type for input argument %d: Real or complex matrix expected.\n"),Err);
         }
         break;
     case 54:
         {
-            displayAndStoreError(_("Wrong type for input argument %d: Polynomial expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong type for input argument %d: Polynomial expected.\n"),Err);
         }
         break;
     case 55:
         {
-            displayAndStoreError(_("Wrong type for argument %d: String expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong type for argument %d: String expected.\n"),Err);
         }
         break;
     case 56:
         {
-            displayAndStoreError(_("Wrong type for argument %d: List expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong type for argument %d: List expected.\n"),Err);
         }
         break;
     case 57:
         {
-            displayAndStoreError(_("Problem with comparison symbol...\n"));
+            iValueReturned = Scierror(iErr, _("Problem with comparison symbol...\n"));
         }
         break;
     case 58:
         {
             if (Rhs == 0)
             {
-                displayAndStoreError(_("Wrong number of input arguments: This function has no input argument.\n"));
+                iValueReturned = Scierror(iErr, _("Wrong number of input arguments: This function has no input argument.\n"));
             }
             else
             {
-                displayAndStoreError(_("Wrong number of input arguments:\n"));
-                displayAndStoreError(_("Arguments are :\n"));
-                /* print variables name on stack :( */
-                C2F(prntid)(istk(C2F(recu).pstk[C2F(recu).pt - 1]), &Rhs, &C2F(iop).wte);
+                iValueReturned = Scierror(iErr, _("Wrong number of input arguments."));
             }
-
         }
         break;
     case 59:
         {
             if (Lhs == 0)
             {
-                displayAndStoreError(_("Wrong number of output arguments: This function has no output argument.\n"));
+                iValueReturned = Scierror(iErr, _("Wrong number of output arguments: This function has no output argument.\n"));
             }
             else
             {
-                displayAndStoreError(_("Wrong number of output arguments\n"));
-                displayAndStoreError(_("Arguments are :\n"));
-                /* print variables name on stack :( */
-                C2F(prntid)(istk(C2F(recu).pstk[C2F(recu).pt - 1]), &Lhs, &C2F(iop).wte);
+                iValueReturned = Scierror(iErr, _("Wrong number of output arguments.\n"));
             }
         }
         break;
     case 60:
         {
-            displayAndStoreError(_("Wrong size for argument: Incompatible dimensions.\n"));
+            iValueReturned = Scierror(iErr, _("Wrong size for argument: Incompatible dimensions.\n"));
         }
         break;
     case 61:
         {
-            displayAndStoreError(_("Direct access : give format.\n"));
+            iValueReturned = Scierror(iErr, _("Direct access : give format.\n"));
         }
         break;
     case 62:
         {
-            displayAndStoreError(_("End of file at line %d.\n"),Err);
+            iValueReturned = Scierror(iErr, _("End of file at line %d.\n"),Err);
         }
         break;
     case 63:
         {
-            displayAndStoreError(_("%d graphic terminal?\n"),Err);
+            iValueReturned = Scierror(iErr, _("%d graphic terminal?\n"),Err);
         }
         break;
     case 64:
         {
-            displayAndStoreError(_("Integration fails.\n"));
+            iValueReturned = Scierror(iErr, _("Integration fails.\n"));
         }
         break;
     case 65:
         {
-            displayAndStoreError(_("%d: logical unit already used.\n"),Err);
+            iValueReturned = Scierror(iErr, _("%d: logical unit already used.\n"),Err);
         }
         break;
     case 66:
         {
-            displayAndStoreError(_("Too many files opened!\n"));
+            iValueReturned = Scierror(iErr, _("Too many files opened!\n"));
         }
         break;
     case 67:
         {
-            displayAndStoreError(_("Unknown file format.\n"));
+            iValueReturned = Scierror(iErr, _("Unknown file format.\n"));
         }
         break;
     case 68:
         {
-            displayAndStoreError(_("Fatal error!!! Your variables have been saved in the file : %s\n\
-                                   Bad call to a scilab function ?\n\
-                                   Otherwise, send a bug report to :\n"),get_sci_data_strings(SAVE_ID));
-            displayAndStoreError("http://bugzilla.scilab.org/\n");
+            char msgErr[bsiz];
+            sprintf(msgErr, _("Fatal error!!! Your variables have been saved in the file : %s\n"), get_sci_data_strings(SAVE_ID));
+            strcat(msgErr, _("Bad call to a scilab function ?\n"));
+            strcat(msgErr, _("Otherwise, send a bug report to :"));
+            strcat(msgErr, "http://bugzilla.scilab.org/\n");
+            iValueReturned = Scierror(iErr, msgErr);
         }
         break;
     case 69:
         {
-            displayAndStoreError(_("Floating point exception.\n"));
+            iValueReturned = Scierror(iErr, _("Floating point exception.\n"));
         }
         break;
     case 70:
         {
-            displayAndStoreError(_("Too many arguments in fort (max 30).\n"));
+            iValueReturned = Scierror(iErr, _("Too many arguments in fort (max 30).\n"));
         }
         break;
     case 71:
         {
-            displayAndStoreError(_("This variable is not valid in fort.\n"));
+            iValueReturned = Scierror(iErr, _("This variable is not valid in fort.\n"));
         }
         break;
     case 72:
@@ -539,7 +536,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_2);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s is not valid in this context.\n"),NameVarOnStack);
+                iValueReturned = Scierror(iErr, _("%s is not valid in this context.\n"),NameVarOnStack);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -547,22 +544,22 @@ int C2F(errmsg)(int *n,int *errtyp)
         break;
     case 73:
         {
-            displayAndStoreError(_("Error while linking.\n"));
+            iValueReturned = Scierror(iErr, _("Error while linking.\n"));
         }
         break;
     case 74:
         {
-            displayAndStoreError(_("Leading coefficient is zero.\n"));
+            iValueReturned = Scierror(iErr, _("Leading coefficient is zero.\n"));
         }
         break;
     case 75:
         {
-            displayAndStoreError(_("Too high degree (max 100).\n"));
+            iValueReturned = Scierror(iErr, _("Too high degree (max 100).\n"));
         }
         break;
     case 76:
         {
-            displayAndStoreError(_("for x=val with type(val)=%d  is not implemented in Scilab.\n"),Err);
+            iValueReturned = Scierror(iErr, _("for x=val with type(val)=%d  is not implemented in Scilab.\n"),Err);
         }
         break;
     case 77:
@@ -570,7 +567,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_1);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong number of input arguments.\n"),NameVarOnStack);
+                iValueReturned = Scierror(iErr, _("%s: Wrong number of input arguments.\n"),NameVarOnStack);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -581,7 +578,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_1);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong number of output arguments.\n"),NameVarOnStack);
+                iValueReturned = Scierror(iErr, _("%s: Wrong number of output arguments.\n"),NameVarOnStack);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -589,13 +586,12 @@ int C2F(errmsg)(int *n,int *errtyp)
         break;
     case 79:
         {
-            displayAndStoreError(_("Indexing not allowed for output arguments of resume.\n"),Err);
-
+            iValueReturned = Scierror(iErr, _("Indexing not allowed for output arguments of resume.\n"),Err);
         }
         break;
     case 80:
         {
-            displayAndStoreError(_("Incorrect function (argument n: %d).\n"),Err);
+            iValueReturned = Scierror(iErr, _("Incorrect function (argument n: %d).\n"),Err);
         }
         break;
     case 81:
@@ -603,7 +599,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong type for argument %d: Real or complex matrix expected.\n"),NameVarOnStack,Err);
+                iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Real or complex matrix expected.\n"),NameVarOnStack,Err);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -614,7 +610,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong type for argument %d: Real matrix expected.\n"),NameVarOnStack, Err);
+                iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Real matrix expected.\n"),NameVarOnStack, Err);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -625,7 +621,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong type for argument %d: Real vector expected.\n"),NameVarOnStack,Err);
+                iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Real vector expected.\n"),NameVarOnStack,Err);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -636,7 +632,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong type for argument %d: Scalar expected.\n"),NameVarOnStack,Err);
+                iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Scalar expected.\n"),NameVarOnStack,Err);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -644,83 +640,83 @@ int C2F(errmsg)(int *n,int *errtyp)
         break;
     case 85:
         {
-            displayAndStoreError(_("Host does not answer...\n"));
+            iValueReturned = Scierror(iErr, _("Host does not answer...\n"));
         }
         break;
     case 86:
         {
-            displayAndStoreError(_("Uncontrollable system.\n"));
+            iValueReturned = Scierror(iErr, _("Uncontrollable system.\n"));
         }
         break;
     case 87:
         {
-            displayAndStoreError(_("Unobservable system.\n"));
+            iValueReturned = Scierror(iErr, _("Unobservable system.\n"));
         }
         break;
     case 88:
         {
-            displayAndStoreError(_("%s: singular or asymmetric problem.\n"),"sfact");
+            iValueReturned = Scierror(iErr, _("%s: singular or asymmetric problem.\n"),"sfact");
         }
         break;
     case 89:
         {
-            displayAndStoreError(_("Wrong size for argument %d.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong size for argument %d.\n"),Err);
         }
         break;
     case 90:
         {
-            displayAndStoreError(_("Wrong type for argument %d: Transfer matrix expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong type for argument %d: Transfer matrix expected.\n"),Err);
         }
         break;
     case 91:
         {
-            displayAndStoreError(_("Wrong type for argument %d: In state space form expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong type for argument %d: In state space form expected.\n"),Err);
         }
         break;
     case 92:
         {
-            displayAndStoreError(_("Wrong type for argument %d: Rational matrix expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong type for argument %d: Rational matrix expected.\n"),Err);
         }
         break;
     case 93:
         {
-            displayAndStoreError(_("Wrong type for argument %d: In continuous time expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong type for argument %d: In continuous time expected.\n"),Err);
         }
         break;
     case 94:
         {
-            displayAndStoreError(_("Wrong type for argument %d: In discrete time expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong type for argument %d: In discrete time expected.\n"),Err);
         }
         break;
     case 95:
         {
-            displayAndStoreError(_("Wrong type for argument %d: SISO expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong type for argument %d: SISO expected.\n"),Err);
         }
         break;
     case 96:
         {
-            displayAndStoreError(_("time domain of argument %d is not defined.\n"),Err);
+            iValueReturned = Scierror(iErr, _("time domain of argument %d is not defined.\n"),Err);
         }
         break;
     case 97:
         {
-            displayAndStoreError(_("Wrong type for argument %d: A system in state space or transfer matrix form expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong type for argument %d: A system in state space or transfer matrix form expected.\n"),Err);
         }
         break;
     case 98:
         {
-            displayAndStoreError(_("Variable returned by scilab argument function is incorrect.\n"));
+            iValueReturned = Scierror(iErr, _("Variable returned by scilab argument function is incorrect.\n"));
         }
         break;
     case 99:
         {
             if (Err != 1)
             {
-                displayAndStoreError(_("Elements of %dth argument must be in increasing order.\n"),Err);
+                iValueReturned = Scierror(iErr, _("Elements of %dth argument must be in increasing order.\n"),Err);
             }
             else
             {
-                displayAndStoreError(_("Elements of first argument are not (strictly) increasing.\n"));
+                iValueReturned = Scierror(iErr, _("Elements of first argument are not (strictly) increasing.\n"));
             }
         }
         break;
@@ -728,11 +724,11 @@ int C2F(errmsg)(int *n,int *errtyp)
         {
             if (Err != 1)
             {
-                displayAndStoreError(_("Elements of %dth argument are not in (strictly) decreasing order.\n"),Err);
+                iValueReturned = Scierror(iErr, _("Elements of %dth argument are not in (strictly) decreasing order.\n"),Err);
             }
             else
             {
-                displayAndStoreError(_("Elements of first argument are not in (strictly) decreasing order.\n"));
+                iValueReturned = Scierror(iErr, _("Elements of first argument are not in (strictly) decreasing order.\n"));
             }
         }
         break;
@@ -740,11 +736,11 @@ int C2F(errmsg)(int *n,int *errtyp)
         {
             if (Err != 1)
             {
-                displayAndStoreError(_("Last element of %dth argument <> first.\n"),Err);
+                iValueReturned = Scierror(iErr, _("Last element of %dth argument <> first.\n"),Err);
             }
             else
             {
-                displayAndStoreError(_("Last element of first argument does not match the first one.\n"));
+                iValueReturned = Scierror(iErr, _("Last element of first argument does not match the first one.\n"));
             }
         }
         break;
@@ -753,7 +749,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_2);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("Variable or function %s are not in file.\n"),NameVarOnStack);
+                iValueReturned = Scierror(iErr, _("Variable or function %s are not in file.\n"),NameVarOnStack);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -764,7 +760,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_3);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("Variable %s is not a valid rational function.\n"),NameVarOnStack);
+                iValueReturned = Scierror(iErr, _("Variable %s is not a valid rational function.\n"),NameVarOnStack);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -775,7 +771,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_3);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("Variable %s is not a valid state space representation.\n"),NameVarOnStack);
+                iValueReturned = Scierror(iErr, _("Variable %s is not a valid state space representation.\n"),NameVarOnStack);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -783,27 +779,27 @@ int C2F(errmsg)(int *n,int *errtyp)
         break;
     case 105:
         {
-            displayAndStoreError(_("Undefined fonction.\n"));
+            iValueReturned = Scierror(iErr, _("Undefined fonction.\n"));
         }
         break;
     case 106:
         {
-            displayAndStoreError(_("Function name already used.\n"));
+            iValueReturned = Scierror(iErr, _("Function name already used.\n"));
         }
         break;
     case 107:
         {
-            displayAndStoreError(_("Too many functions are defined (maximum #:%d).\n"),Err);
+            iValueReturned = Scierror(iErr, _("Too many functions are defined (maximum #:%d).\n"),Err);
         }
         break;
     case 108:
         {
-            displayAndStoreError(_("Too complex for scilab, may be a too long control instruction.\n"));
+            iValueReturned = Scierror(iErr, _("Too complex for scilab, may be a too long control instruction.\n"));
         }
         break;
     case 109:
         {
-            displayAndStoreError(_("Too large, can't be displayed.\n"));
+            iValueReturned = Scierror(iErr, _("Too large, can't be displayed.\n"));
         }
         break;
     case 110:
@@ -811,7 +807,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_2);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s was a function when compiled but is now a primitive!\n"),NameVarOnStack);
+                iValueReturned = Scierror(iErr, _("%s was a function when compiled but is now a primitive!\n"),NameVarOnStack);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -822,7 +818,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_2);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("Trying to re-define function %s.\n"),NameVarOnStack);
+                iValueReturned = Scierror(iErr, _("Trying to re-define function %s.\n"),NameVarOnStack);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -830,147 +826,147 @@ int C2F(errmsg)(int *n,int *errtyp)
         break;
     case 112:
         {
-            displayAndStoreError(_("No more memory.\n"));
+            iValueReturned = Scierror(iErr, _("No more memory.\n"));
         }
         break;
     case 113:
         {
-            displayAndStoreError(_("Too large string.\n"));
+            iValueReturned = Scierror(iErr, _("Too large string.\n"));
         }
         break;
     case 114:
         {
-            displayAndStoreError(_("Too many linked routines.\n"));
+            iValueReturned = Scierror(iErr, _("Too many linked routines.\n"));
         }
         break;
     case 115:
         {
-            displayAndStoreError(_("Stack problem detected within a loop.\nA primitive function has been called with a wrong number of output arguments.\nNo output argument test has been made for this function.\nPlease report this bug :\n"));
-            displayAndStoreError("http://bugzilla.scilab.org/\n");
-
-            C2F(showstack)(); /* display of calling tree */
+            char msgErr[bsiz];
+            strcpy(msgErr, _("Stack problem detected within a loop.\nA primitive function has been called with a wrong number of output arguments.\nNo output argument test has been made for this function.\nPlease report this bug :\n"));
+            strcat(msgErr, "http://bugzilla.scilab.org/\n");
+            iValueReturned = Scierror(iErr, msgErr);
         }
         break;
     case 116:
         {
-
-            displayAndStoreError(_("Wrong value for argument %d.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong value for argument %d.\n"),Err);
         }
         break;
     case 117:
         {
-            displayAndStoreError(_("List element number %d is Undefined.\n"),Err);
+            iValueReturned = Scierror(iErr, _("List element number %d is Undefined.\n"),Err);
         }
         break;
     case 118:
         {
-
-            displayAndStoreError(_("Wrong type for argument %d: Named variable not an expression expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong type for argument %d: Named variable not an expression expected.\n"),Err);
         }
         break;
     case 119:
         {
             /* no message  */
+            iValueReturned = Scierror(iErr, "");
         }
         break;
     case 120:
         {
-            displayAndStoreError(_("Indices for non-zero elements must be given by a 2 column matrix.\n"));
+            iValueReturned = Scierror(iErr, _("Indices for non-zero elements must be given by a 2 column matrix.\n"));
         }
         break;
     case 121:
         {
-            displayAndStoreError(_("Incompatible indices for non-zero elements.\n"));
+            iValueReturned = Scierror(iErr, _("Incompatible indices for non-zero elements.\n"));
         }
         break;
     case 122:
         {
-            displayAndStoreError(_("Logical unit number should be larger than %d.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Logical unit number should be larger than %d.\n"),Err);
         }
         break;
     case 123:
         {
-            displayAndStoreError(_("Function not bounded from below.\n"));
+            iValueReturned = Scierror(iErr, _("Function not bounded from below.\n"));
         }
         break;
     case 124:
         {
             /* no message  */
+            iValueReturned = Scierror(iErr, "");
         }
         break;
     case 125:
         {
-            displayAndStoreError(_("Problem may be unbounded: too high distance between two consecutive iterations.\n"));
+            iValueReturned = Scierror(iErr, _("Problem may be unbounded: too high distance between two consecutive iterations.\n"));
         }
         break;
     case 126:
         {
-            displayAndStoreError(_("Inconsistent constraints.\n"));
+            iValueReturned = Scierror(iErr, _("Inconsistent constraints.\n"));
         }
         break;
     case 127:
         {
-            displayAndStoreError(_("No feasible solution.\n"));
+            iValueReturned = Scierror(iErr, _("No feasible solution.\n"));
         }
         break;
     case 128:
         {
-            displayAndStoreError(_("Degenerate starting point.\n"));
+            iValueReturned = Scierror(iErr, _("Degenerate starting point.\n"));
         }
         break;
     case 129:
         {
-            displayAndStoreError(_("No feasible point has been found.\n"));
+            iValueReturned = Scierror(iErr, _("No feasible point has been found.\n"));
         }
         break;
     case 130:
         {
-            displayAndStoreError(_("Optimization fails: back to initial point.\n"));
+            iValueReturned = Scierror(iErr, _("Optimization fails: back to initial point.\n"));
         }
         break;
     case 131:
         {
-            displayAndStoreError(_("%s: Stop requested by simulator (ind=0)\n"),"optim");
+            iValueReturned = Scierror(iErr, _("%s: Stop requested by simulator (ind=0)\n"),"optim");
         }
         break;
     case 132:
         {
-            displayAndStoreError(_("%s: Wrong input parameters.\n"),"optim");
+            iValueReturned = Scierror(iErr, _("%s: Wrong input parameters.\n"),"optim");
         }
         break;
     case 133:
         {
-            displayAndStoreError(_("Too small memory.\n"));
+            iValueReturned = Scierror(iErr, _("Too small memory.\n"));
         }
         break;
     case 134:
         {
-            displayAndStoreError(_("%s: Problem with initial constants in simul.\n"),"optim");
+            iValueReturned = Scierror(iErr, _("%s: Problem with initial constants in simul.\n"),"optim");
         }
         break;
     case 135:
         {
-            displayAndStoreError(_("%s: Bounds and initial guess are incompatible.\n"),"optim");
+            iValueReturned = Scierror(iErr, _("%s: Bounds and initial guess are incompatible.\n"),"optim");
         }
         break;
     case 136:
         {
-            displayAndStoreError(_("%s: This method is NOT implemented.\n"),"optim");
+            iValueReturned = Scierror(iErr, _("%s: This method is NOT implemented.\n"),"optim");
         }
         break;
     case 137:
         {
-            displayAndStoreError(_("NO hot restart available in this method.\n"));
+            iValueReturned = Scierror(iErr, _("NO hot restart available in this method.\n"));
         }
         break;
     case 138:
         {
-            displayAndStoreError(_("%s: Incorrect stopping parameters.\n"),"optim");
+            iValueReturned = Scierror(iErr, _("%s: Incorrect stopping parameters.\n"),"optim");
         }
         break;
     case 139:
         {
-            displayAndStoreError(_("%s: Incorrect bounds.\n"),"optim");
+            iValueReturned = Scierror(iErr, _("%s: Incorrect bounds.\n"),"optim");
         }
         break;
     case 140:
@@ -979,7 +975,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_6);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("Variable : %s must be a list\n"),NameVarOnStack);
+                iValueReturned = Scierror(iErr, _("Variable : %s must be a list\n"),NameVarOnStack);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -988,17 +984,17 @@ int C2F(errmsg)(int *n,int *errtyp)
         break;
     case 141:
         {
-            displayAndStoreError(_("Incorrect function (argument n: %d).\n"),Err);
+            iValueReturned = Scierror(iErr, _("Incorrect function (argument n: %d).\n"),Err);
         }
         break;
     case 142:
         {
-            displayAndStoreError(_("Hot restart: dimension of working table (argument n:%d).\n"),Err);
+            iValueReturned = Scierror(iErr, _("Hot restart: dimension of working table (argument n:%d).\n"),Err);
         }
         break;
     case 143:
         {
-            displayAndStoreError(_("%s: df0 must be positive !\n"),"optim");
+            iValueReturned = Scierror(iErr, _("%s: df0 must be positive !\n"),"optim");
         }
         break;
     case 144:
@@ -1006,16 +1002,14 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_1);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("Undefined operation for the given operands.\n"));
+                char msgErr[bsiz*2];
+                char msgTmp[bsiz];
+
+                strcpy(msgErr, _("Undefined operation for the given operands.\n"));
+                sprintf(msgTmp, _("check or define function %s for overloading.\n"), NameVarOnStack);
+                strcat(msgErr, msgTmp);
+                iValueReturned = Scierror(iErr, msgErr);
 
-                /* bug 8279 error(144) */
-                /* but error code 144 also called by internal fortran routines */
-                /* see modules/core/src/fortran/mname.f(136) */
-                /* then we check variable name */
-                if (strcmp(NameVarOnStack, "error"))
-                {
-                    displayAndStoreError(_("check or define function %s for overloading.\n"), NameVarOnStack);
-                }
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1031,6 +1025,7 @@ int C2F(errmsg)(int *n,int *errtyp)
     case 200:
         {
             /* no message  */
+            iValueReturned = Scierror(iErr, "");
         }
         break;
     case 201:
@@ -1040,7 +1035,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong type for argument %d: Real or complex matrix expected.\n"),NameVarOnStack,Err);
+                iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Real or complex matrix expected.\n"),NameVarOnStack,Err);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1053,7 +1048,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong type for argument %d: Real matrix expected.\n"),NameVarOnStack,Err);
+                iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Real matrix expected.\n"),NameVarOnStack,Err);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1066,7 +1061,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong type for argument %d: Real vector expected.\n"),NameVarOnStack,Err);
+                iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Real vector expected.\n"),NameVarOnStack,Err);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1077,7 +1072,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong type for argument %d: Scalar expected.\n"),NameVarOnStack,Err);
+                iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Scalar expected.\n"),NameVarOnStack,Err);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1091,7 +1086,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong size for argument %d: (%d,%d) expected.\n"),NameVarOnStack,Err,minvalue,maxvalue);
+                iValueReturned = Scierror(iErr, _("%s: Wrong size for argument %d: (%d,%d) expected.\n"),NameVarOnStack,Err,minvalue,maxvalue);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1104,7 +1099,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong size for argument %d: %d expected.\n"),NameVarOnStack,Err,vectorsize);
+                iValueReturned = Scierror(iErr, _("%s: Wrong size for argument %d: %d expected.\n"),NameVarOnStack,Err,vectorsize);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1115,7 +1110,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong type for argument %d: Matrix of strings expected.\n"),NameVarOnStack,Err);
+                iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Matrix of strings expected.\n"),NameVarOnStack,Err);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1126,7 +1121,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong type for argument %d: Boolean matrix expected.\n"),NameVarOnStack,Err);
+                iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Boolean matrix expected.\n"),NameVarOnStack,Err);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1137,7 +1132,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong type for argument %d: Matrix expected.\n"),NameVarOnStack,Err);
+                iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Matrix expected.\n"),NameVarOnStack,Err);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1148,7 +1143,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong type for argument %d: List expected.\n"),NameVarOnStack, Err);
+                iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: List expected.\n"),NameVarOnStack, Err);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1159,7 +1154,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong type for argument %d: Function or string (external function) expected.\n"),NameVarOnStack,Err);
+                iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Function or string (external function) expected.\n"),NameVarOnStack,Err);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1170,7 +1165,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong type for argument %d: Polynomial expected.\n"),NameVarOnStack,Err);
+                iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Polynomial expected.\n"),NameVarOnStack,Err);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1181,7 +1176,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong type for argument %d: Working int matrix expected.\n"),NameVarOnStack,Err);
+                iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Working int matrix expected.\n"),NameVarOnStack,Err);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1192,7 +1187,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("%s: Wrong type for argument %d: Vector expected.\n"),NameVarOnStack,Err);
+                iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Vector expected.\n"),NameVarOnStack,Err);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1202,48 +1197,47 @@ int C2F(errmsg)(int *n,int *errtyp)
         {
             if (Err != 1)
             {
-                displayAndStoreError(_("%dth argument type must be boolean.\n"),Err);
+                iValueReturned = Scierror(iErr, _("%dth argument type must be boolean.\n"),Err);
             }
             else
             {
-                displayAndStoreError(_("Argument type must be boolean.\n"));
+                iValueReturned = Scierror(iErr, _("Argument type must be boolean.\n"));
             }
         }
         break;
     case 216:
         {
-            displayAndStoreError(_("Wrong type for argument %d: Boolean or scalar expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong type for argument %d: Boolean or scalar expected.\n"),Err);
         }
         break;
     case 217:
         {
-            displayAndStoreError(_("Wrong type for argument %d: Sparse matrix of scalars expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong type for argument %d: Sparse matrix of scalars expected.\n"),Err);
         }
         break;
     case 218:
         {
-            displayAndStoreError(_("Wrong type for argument %d: Handle to sparse lu factors expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong type for argument %d: Handle to sparse lu factors expected.\n"),Err);
         }
         break;
     case 219:
         {
-
-            displayAndStoreError(_("Wrong type argument %d: Sparse or full scalar matrix expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong type argument %d: Sparse or full scalar matrix expected.\n"),Err);
         }
         break;
     case 220:
         {
-            displayAndStoreError(_("Null variable cannot be used here.\n"));
+            iValueReturned = Scierror(iErr, _("Null variable cannot be used here.\n"));
         }
         break;
     case 221:
         {
-            displayAndStoreError(_("A sparse matrix entry is defined with two different values.\n"));
+            iValueReturned = Scierror(iErr, _("A sparse matrix entry is defined with two different values.\n"));
         }
         break;
     case 222:
         {
-            displayAndStoreError(_("%s not yet implemented for full input parameter.\n"),"lusolve");
+            iValueReturned = Scierror(iErr, _("%s not yet implemented for full input parameter.\n"),"lusolve");
         }
         break;
     case 223:
@@ -1251,7 +1245,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_1);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("It is not possible to redefine the %s primitive this way (see clearfun).\n"),NameVarOnStack);
+                iValueReturned = Scierror(iErr, _("It is not possible to redefine the %s primitive this way (see clearfun).\n"),NameVarOnStack);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1259,22 +1253,22 @@ int C2F(errmsg)(int *n,int *errtyp)
         break;
     case 224:
         {
-            displayAndStoreError(_("Type data base is full.\n"));
+            iValueReturned = Scierror(iErr, _("Type data base is full.\n"));
         }
         break;
     case 225:
         {
-            displayAndStoreError(_("This data type is already defined.\n"));
+            iValueReturned = Scierror(iErr, _("This data type is already defined.\n"));
         }
         break;
     case 226:
         {
-            displayAndStoreError(_("Inequality comparison with empty matrix.\n"));
+            iValueReturned = Scierror(iErr, _("Inequality comparison with empty matrix.\n"));
         }
         break;
     case 227:
         {
-            displayAndStoreError(_("Missing index.\n"));
+            iValueReturned = Scierror(iErr, _("Missing index.\n"));
         }
         break;
     case 228:
@@ -1282,7 +1276,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_1);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("reference to the cleared global variable %s.\n"),NameVarOnStack);
+                iValueReturned = Scierror(iErr, _("reference to the cleared global variable %s.\n"),NameVarOnStack);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1290,57 +1284,57 @@ int C2F(errmsg)(int *n,int *errtyp)
         break;
     case 229:
         {
-            displayAndStoreError(_("Operands of / and \\ operations must not contain NaN or Inf.\n"));
+            iValueReturned = Scierror(iErr, _("Operands of / and \\ operations must not contain NaN of Inf.\n"));
         }
         break;
     case 230:
         {
-            displayAndStoreError(_("semi def fails.\n"));
+            iValueReturned = Scierror(iErr, _("semi def fails.\n"));
         }
         break;
     case 231:
         {
-            displayAndStoreError(_("Wrong type for first input argument: Single string expected.\n"));
+            iValueReturned = Scierror(iErr, _("Wrong type for first input argument: Single string expected.\n"));
         }
         break;
     case 232:
         {
-            displayAndStoreError(_("Entry name not found.\n"));
+            iValueReturned = Scierror(iErr, _("Entry name not found.\n"));
         }
         break;
     case 233:
         {
-            displayAndStoreError(_("Maximum number of dynamic interfaces reached.\n"));
+            iValueReturned = Scierror(iErr, _("Maximum number of dynamic interfaces reached.\n"));
         }
         break;
     case 234:
         {
-            displayAndStoreError(_("%s: expecting more than one argument.\n"),"Link");
+            iValueReturned = Scierror(iErr, _("%s: expecting more than one argument.\n"),"link");
         }
         break;
     case 235:
         {
-            displayAndStoreError(_("%s: problem with one of the entry point.\n"),"Link");
+            iValueReturned = Scierror(iErr, _("%s: problem with one of the entry point.\n"),"link");
         }
         break;
     case 236:
         {
-            displayAndStoreError(_("%s: the shared archive was not loaded.\n"),"Link");
+            iValueReturned = Scierror(iErr, _("%s: the shared archive was not loaded.\n"),"link");
         }
         break;
     case 237:
         {
-            displayAndStoreError(_("%s: Only one entry point allowed on this operating system.\n"),"Link");
+            iValueReturned = Scierror(iErr, _("%s: Only one entry point allowed on this operating system.\n"),"link");
         }
         break;
     case 238:
         {
-            displayAndStoreError(_("%s: First argument cannot be a number.\n"),"Link");
+            iValueReturned = Scierror(iErr, _("%s: First argument cannot be a number.\n"),"link");
         }
         break;
     case 239:
         {
-            displayAndStoreError(_("You cannot link more functions, maxentry reached.\n"));
+            iValueReturned = Scierror(iErr, _("You cannot link more functions, maxentry reached.\n"));
         }
         break;
     case 240:
@@ -1349,7 +1343,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_5);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("File \"%s\" already exists or directory write access denied.\n"),NameVarOnStack);
+                iValueReturned = Scierror(iErr, _("File \"%s\" already exists or directory write access denied.\n"),NameVarOnStack);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1361,7 +1355,7 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_5);
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("File \"%s\" does not exist or read access denied.\n"),NameVarOnStack);
+                iValueReturned = Scierror(iErr, _("File \"%s\" does not exist or read access denied.\n"),NameVarOnStack);
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
@@ -1369,186 +1363,197 @@ int C2F(errmsg)(int *n,int *errtyp)
         break;
     case 242:
         {
-            displayAndStoreError(_("Binary direct access files must be opened by 'file'.\n"));
+            iValueReturned = Scierror(iErr, _("Binary direct access files must be opened by 'file'.\n"));
         }
         break;
     case 243:
         {
-            displayAndStoreError(_("C file logical unit not allowed here.\n"));
+            iValueReturned = Scierror(iErr, _("C file logical unit not allowed here.\n"));
         }
         break;
     case 244:
         {
-            displayAndStoreError(_("Fortran file logical unit not allowed here.\n"));
+            iValueReturned = Scierror(iErr, _("Fortran file logical unit not allowed here.\n"));
         }
         break;
     case 245:
         {
-            displayAndStoreError(_("No input file associated to logical unit %d.\n"),Err);
+            iValueReturned = Scierror(iErr, _("No input file associated to logical unit %d.\n"),Err);
         }
         break;
     case 246:
         {
             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_6);
-            displayAndStoreError(_("Function not defined for given argument type(s),\n"));
             if (NameVarOnStack)
             {
-                displayAndStoreError(_("  check arguments or define function %s for overloading.\n"),NameVarOnStack);
+                char msgErr[bsiz];
+                char msgTmp[bsiz];
+
+                strcpy(msgErr, _("Function not defined for given argument type(s),\n"));
+                sprintf(msgTmp, _("  check arguments or define function %s for overloading.\n"),NameVarOnStack);
+                strcat(msgErr, msgTmp);
+                iValueReturned = Scierror(iErr, msgErr);
+
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
             }
+            else
+            {
+                iValueReturned = Scierror(iErr, _("Function not defined for given argument type(s),\n"));
+            }
         }
         break;
     case 247:
         {
-            displayAndStoreError(_("Wrong value for argument %d: the lu handle is no more valid.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong value for argument %d: the lu handle is no more valid.\n"),Err);
         }
         break;
     case 248:
         {                      
-            displayAndStoreError(_("Wrong value for argument %d: Valid variable name expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong value for argument %d: Valid variable name expected.\n"),Err);
         }
         break;
     case 249:
         {
-            displayAndStoreError(_("Wrong value for argument %d: Empty string expected.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong value for argument %d: Empty string expected.\n"),Err);
         }
         break;
     case 250:
         {
-            displayAndStoreError(_("Recursive extraction is not valid in this context.\n"));
+            iValueReturned = Scierror(iErr, _("Recursive extraction is not valid in this context.\n"));
         }
         break;
     case 251:
         {
-            displayAndStoreError(_("%s: ipar dimensioned at least 11.\n"),"bvode");
+            iValueReturned = Scierror(iErr, _("%s: ipar dimensioned at least 11.\n"),"bvode");
         }
         break;
     case 252:
         {
-            displayAndStoreError(_("%s: ltol must be of size ipar(4).\n"),"bvode");
+            iValueReturned = Scierror(iErr, _("%s: ltol must be of size ipar(4).\n"),"bvode");
         }
         break;
     case 253:
         {
-            displayAndStoreError(_("%s: fixpnt must be of size ipar(11).\n"),"bvode");
+            iValueReturned = Scierror(iErr, _("%s: fixpnt must be of size ipar(11).\n"),"bvode");
         }
         break;
     case 254:
         {
-            displayAndStoreError(_("%s: ncomp < 20 requested.\n"),"bvode");
+            iValueReturned = Scierror(iErr, _("%s: ncomp < 20 requested.\n"),"bvode");
         }
         break;
     case 255:
         {
-            displayAndStoreError(_("%s: m must be of size ncomp.\n"),"bvode");
+            iValueReturned = Scierror(iErr, _("%s: m must be of size ncomp.\n"),"bvode");
         }
         break;
     case 256: case 257:
         {
-            displayAndStoreError(_("%s: sum(m) must be less than 40.\n"),"bvode");
+            iValueReturned = Scierror(iErr, _("%s: sum(m) must be less than 40.\n"),"bvode");
         }
         break;
     case 258:
         {
-            displayAndStoreError(_("%s: input data error.\n"),"bvode");
+            iValueReturned = Scierror(iErr, _("%s: input data error.\n"),"bvode");
         }
         break;
     case 259:
         {
-            displayAndStoreError(_("%s: no. of subintervals exceeds storage.\n"),"bvode");
+            iValueReturned = Scierror(iErr, _("%s: no. of subintervals exceeds storage.\n"),"bvode");
         }
         break;
     case 260:
         {
-            displayAndStoreError(_("%s: The colocation matrix is singular.\n"),"bvode");
+            iValueReturned = Scierror(iErr, _("%s: The colocation matrix is singular.\n"),"bvode");
         }
         break;
     case 261:
         {
-            displayAndStoreError(_("Interface property table is full.\n"));
+            iValueReturned = Scierror(iErr, _("Interface property table is full.\n"));
         }
         break;
     case 262:
         {
             int maxglobalvariables = isizt - C2F(vstk).isiz - 1;
-            displayAndStoreError(_("Too many global variables! Max number is %d.\n"),maxglobalvariables);
+            iValueReturned = Scierror(iErr, _("Too many global variables! Max number is %d.\n"),maxglobalvariables);
         }
         break;
     case 263:
         {
-            displayAndStoreError(_("Error while writing in file: disk full or deleted file.\n"));
+            iValueReturned = Scierror(iErr, _("Error while writing in file: disk full or deleted file.\n"));
         }
         break;
     case 264:
         {
-            displayAndStoreError(_("Wrong value for argument %d: Must not contain NaN or Inf.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong value for argument %d: Must not contain NaN or Inf.\n"),Err);
         }
         break;
     case 265:
         {
-            displayAndStoreError(_("%s and %s must have equal number of rows.\n"),"A","B");
+            iValueReturned = Scierror(iErr, _("%s and %s must have equal number of rows.\n"),"A","B");
         }
         break;
     case 266:
         {
-            displayAndStoreError(_("%s and %s must have equal number of columns.\n"),"A","B");
+            iValueReturned = Scierror(iErr, _("%s and %s must have equal number of columns.\n"),"A","B");
         }
         break;
     case 267:
         {
-            displayAndStoreError(_("%s and %s must have equal dimensions.\n"),"A","B");
+            iValueReturned = Scierror(iErr, _("%s and %s must have equal dimensions.\n"),"A","B");
         }
         break;
     case 268:
         {
-            displayAndStoreError(_("Invalid return value for function passed in arg %d.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Invalid return value for function passed in arg %d.\n"),Err);
         }
         break;
     case 269:
         {
-            displayAndStoreError(_("Wrong value for argument %d: eigenvalues must have negative real parts.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong value for argument %d: eigenvalues must have negative real parts.\n"),Err);
         }
         break;
     case 270:
         {
-            displayAndStoreError(_("Wrong value for argument %d: eigenvalues modulus must be less than one.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Wrong value for argument %d: eigenvalues modulus must be less than one.\n"),Err);
         }
         break;
     case 271:
         {
-            displayAndStoreError(_("Size varying argument a*eye(), (arg %d) not allowed here.\n"),Err);
+            iValueReturned = Scierror(iErr, _("Size varying argument a*eye(), (arg %d) not allowed here.\n"),Err);
         }
         break;
     case 272:
         {
-            displayAndStoreError(_("endfunction is missing.\n"));
+            iValueReturned = Scierror(iErr, _("endfunction is missing.\n"));
         }
         break;
     case 273:
         {
-            displayAndStoreError(_("Instruction left hand side: waiting for a dot or a left parenthesis.\n"));
+            iValueReturned = Scierror(iErr, _("Instruction left hand side: waiting for a dot or a left parenthesis.\n"));
         }
         break;
     case 274:
         {
-            displayAndStoreError(_("Instruction left hand side: waiting for a name.\n"));
+            iValueReturned = Scierror(iErr, _("Instruction left hand side: waiting for a name.\n"));
         }
         break;
     case 275:
         {
-            displayAndStoreError(_("varargout keyword cannot be used here.\n"));
+            iValueReturned = Scierror(iErr, _("varargout keyword cannot be used here.\n"));
         }
         break;
     case 276:
         {
-            displayAndStoreError(_("Missing operator, comma, or semicolon.\n"));
-            *errtyp = 1; /* error not recoverable */
+            iValueReturned = Scierror(iErr, _("Missing operator, comma, or semicolon.\n"));
+            errtyp = 1; /* error not recoverable */
+            C2F(errmgr)(&iErr, &errtyp);
         }
         break;
     case 277:
         {
-            displayAndStoreError(_("Too many commands defined.\n"));
+            iValueReturned = Scierror(iErr, _("Too many commands defined.\n"));
         }
         break;
     case 278: 
@@ -1558,11 +1563,11 @@ int C2F(errmsg)(int *n,int *errtyp)
             {
                 if (NameVarOnStack[0] != '0')
                 {
-                    displayAndStoreError(_("%s: Input arguments should have the same formal variable name.\n"),NameVarOnStack);
+                    iValueReturned = Scierror(iErr, _("%s: Input arguments should have the same formal variable name.\n"),NameVarOnStack);
                 }
                 else
                 {
-                    displayAndStoreError(_("Input arguments should have the same formal variable name.\n"));
+                    iValueReturned = Scierror(iErr, _("Input arguments should have the same formal variable name.\n"));
                 }
                 FREE(NameVarOnStack);
                 NameVarOnStack = NULL;
@@ -1572,6 +1577,7 @@ int C2F(errmsg)(int *n,int *errtyp)
     case 279: case 280:
         {
             /* no message  */
+            iValueReturned = Scierror(iErr, "");
         }
         break;
 
@@ -1580,14 +1586,14 @@ int C2F(errmsg)(int *n,int *errtyp)
             char *buffer = defaultStringError();
             if (buffer)
             {
-                displayAndStoreError(buffer);
+                iValueReturned = Scierror(iErr, buffer);
                 FREE(buffer);
                 buffer = NULL;
             }
         }
         break;
     }
-    return 0;
+    return iValueReturned;
 }
 /*--------------------------------------------------------------------------*/
 static void strip_blank(char *source)
@@ -1668,45 +1674,6 @@ static char *getConvertedNameFromStack(int cvnametype)
     return strdup(local_variable_buffer);
 }
 /*--------------------------------------------------------------------------*/
-static void displayAndStoreError(const char *msg,...)
-{
-    int io = 0;
-    int len = 0;
-
-    va_list ap;
-    static char s_buf[bsiz];
-
-    va_start(ap,msg);
-
-#if defined(linux) || defined(_MSC_VER)
-    {
-        int count=0;
-        count= vsnprintf(s_buf,bsiz, msg, ap );
-        if (count == -1) s_buf[bsiz-1]='\0';
-    }
-#else
-    (void )vsprintf(s_buf, msg, ap );
-#endif
-    va_end(ap);
-
-    /* store and display error(lasterror) */
-
-    len = (int)strlen(s_buf);
-    C2F(msgout)(&io,&C2F(iop).wte,s_buf,len);
-}
-/*--------------------------------------------------------------------------*/
-static void resetLastError(void)
-{
-#define SPACE_CHAR " "
-    int zero = 0;
-    int lenspace = (int)strlen(SPACE_CHAR);
-
-    /* reset lasterror */
-    C2F(linestore)(&zero);
-    C2F(funnamestore)(SPACE_CHAR, &zero, lenspace);
-    clearLastError();
-}
-/*--------------------------------------------------------------------------*/
 static char *defaultStringError(void)
 {
     char *buffer = NULL;
diff --git a/scilab/modules/output_stream/src/c/errorTable.h b/scilab/modules/output_stream/src/c/errorTable.h
new file mode 100644 (file)
index 0000000..b93ff64
--- /dev/null
@@ -0,0 +1,24 @@
+/*
+ * ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) DIGITEO - 2010 - Allan CORNET
+ * 
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at    
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ */
+
+#ifndef __ERROR_TABLE_H__
+#define __ERROR_TABLE_H__
+
+/**
+* internal error table
+* see also help error_table in scilab
+* @param[in] error code
+* @return value returned by internal Scierror
+*/
+int errorTable(int iErr);
+
+#endif /*  __ERROR_TABLE_H__ */
\ No newline at end of file
index 0c1ac0b..18cd55c 100644 (file)
@@ -1,15 +1,15 @@
 /*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) INRIA - Allan CORNET
- * Copyright (C) DIGITEO - 2010 - Allan CORNET
- * 
- * This file must be used under the terms of the CeCILL.
- * This source file is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.  The terms
- * are also available at    
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
+* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+* Copyright (C) INRIA - Allan CORNET
+* Copyright (C) DIGITEO - 2010-2011 - Allan CORNET
+* 
+* This file must be used under the terms of the CeCILL.
+* This source file is licensed as described in the file COPYING, which
+* you should have received as part of this distribution.  The terms
+* are also available at    
+* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+*
+*/
 
 #include <string.h>
 #include "error_internal.h"
@@ -17,7 +17,6 @@
 #include "msgstore.h"
 #include "BOOL.h"
 #include "stack-def.h"
-#include "errmsg.h"
 #include "errmds.h"
 #include "lasterror.h"
 /*--------------------------------------------------------------------------*/ 
@@ -25,10 +24,10 @@ extern int C2F(errloc)(int *n); /* fortran */
 extern int C2F(errmgr)(); /* fortran */
 extern int C2F(errcontext)(); /* fortran */
 extern int C2F(whatln)(int *lpt1,int *lpt2,int *lpt6,int *nct,int *idebut,int *ifin); /* fortran */
-
 /*--------------------------------------------------------------------------*/ 
-int error_internal(int *n,char *buffer,int mode)
+int error_internal(int *n,char *buffer)
 {
+    int len = 0;
     int num = 0;
     int lct1 = 0;
     int imode = 0;
@@ -65,27 +64,22 @@ int error_internal(int *n,char *buffer,int mode)
             C2F(iop).lct[0] = -1;
         }
 
-        if (mode == ERROR_FROM_FORTRAN)
-        {
-            /* output and store error message */
-            C2F(errmsg)(n, &errtyp);
-        }
-        else /* ERROR_FROM_C */
-        {
-            int len = (int) strlen(buffer);
+        len = (int) strlen(buffer);
 
-            /* free message table */
-            clearLastError();
+        /* free message table */
+        clearLastError();
 
-            /* store error number */
-            setLastErrorValue(*n);
+        /* store error number */
+        setLastErrorValue(*n);
 
-            /* store message */
-            C2F(msgstore)(buffer,&len);
+        /* store message */
+
+
+        C2F(msgstore)(buffer,&len);
+
+        /* display error */
+        if (C2F(iop).lct[0] != -1) sciprint(buffer);
 
-            /* display error */
-            if (C2F(iop).lct[0] != -1) sciprint(buffer);
-        }
         C2F(iop).lct[0] = 0;
     }
     C2F(errcontext)(); 
index ed4daa9..7d0d032 100644 (file)
@@ -2,6 +2,7 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) INRIA - Allan CORNET
+ * Copyright (C) DIGITEO - 2010 - Allan CORNET
  * 
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
 #ifndef __ERROR_INTERNAL_H__
 #define __ERROR_INTERNAL_H__
 
-#define ERROR_FROM_FORTRAN 0
-#define ERROR_FROM_C 1
-
-
 /**
 * error_internal
 * @param [in] n : error code
 * @param [in] buffer : string error
-* @param [in] mode : ERROR_FROM_FORTRAN (not use buffer) or ERROR_FROM_C
 * @return 0
 */
-int error_internal(int *n,char *buffer,int mode);
+int error_internal(int *n, char *buffer);
 
 #endif /* __ERROR_INTERNAL_H__ */
 /*--------------------------------------------------------------------------*/ 
index 740639a..1de6f51 100644 (file)
@@ -1,15 +1,15 @@
 /*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) INRIA
- * Copyright (C) DIGITEO - 2010 - Allan CORNET
- * 
- * This file must be used under the terms of the CeCILL.
- * This source file is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.  The terms
- * are also available at    
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
+* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+* Copyright (C) INRIA
+* Copyright (C) DIGITEO - 2010-2011 - Allan CORNET
+* 
+* This file must be used under the terms of the CeCILL.
+* This source file is licensed as described in the file COPYING, which
+* you should have received as part of this distribution.  The terms
+* are also available at    
+* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+*
+*/
 #include <string.h>
 #include <stdlib.h>
 #include "MALLOC.h"
@@ -19,6 +19,9 @@
 #ifdef _MSC_VER
 #include "strdup_windows.h"
 #endif
+#include "freeArrayOfString.h"
+/*--------------------------------------------------------------------------*/
+static char **splitErrorMessage(const char *msg, int *nbLines);
 /*--------------------------------------------------------------------------*/
 int C2F(linestore)(int *n)
 {
@@ -47,12 +50,34 @@ int C2F(funnamestore)(char *str, int *n, int lenstr)
 int C2F(msgstore)(char *str, int *n)
 {
     int iRes = 0;
-    char *msg = strdup(str);
+
+    char **multilines = NULL;
+    int nbLines = 0;
+    int i = 0;
+    char *msg = NULL;
+
+    if (str == NULL) return 1;
+    msg = strdup(str);
     if (msg)
     {
         msg[*n] = 0;
     }
-    iRes = appendStringToLastErrorMessage(msg);
+
+    multilines = splitErrorMessage(msg, &nbLines);
+    if (multilines)
+    {
+        for (i = 0; i < nbLines; i++)
+        {
+            iRes = appendStringToLastErrorMessage(multilines[i]);
+            if (iRes) break;
+        }
+        freeArrayOfString(multilines, nbLines);
+        multilines = NULL;
+    }
+    else
+    {
+        iRes = appendStringToLastErrorMessage(msg);
+    }
 
     if (msg)
     {
@@ -68,4 +93,86 @@ int GetLastErrorCode(void)
     return getLastErrorValue();
 }
 /*--------------------------------------------------------------------------*/
+static char **splitErrorMessage(const char *msg, int *nbLines)
+{
+    const char* separator = "\n";
+    int removeEmptyField = 1;
+
+    size_t sizeSeparator = strlen(separator);
+    char** currentSplit  = NULL;
+    size_t nbSep = 0;
+    size_t nbEmptyField = 0;
+    size_t sizeSplit = 0;
+    size_t currentSep = 0;
+    char* pos = NULL;
+    char* currentPos = NULL;
+    char *str = strdup(msg);
+
+    *nbLines = 0;
+
+    if (msg == NULL) 
+    {
+        return NULL;
+    }
+
+    pos = str;
+    currentPos = str;
+
+    while( pos = strstr( pos, separator ) ) 
+    {
+        memset( pos, '\0', sizeSeparator );
+        if ( pos == str || ( pos != str && !*(pos-1) ) )
+        {
+            ++nbEmptyField;
+        }
+        ++nbSep;
+        currentPos = (pos += sizeSeparator);
+    }
+    if ( currentPos == str || ( currentPos != str && !*currentPos ) )
+    {
+        ++nbEmptyField;
+    }
 
+    sizeSplit = (nbSep + 1) - (removeEmptyField?nbEmptyField:0);
+    if (!sizeSplit) 
+    {
+        if (str)
+        {
+            FREE(str);
+            str = NULL;
+        }
+        return NULL;
+    }
+
+    currentSplit = (char **)MALLOC( (sizeSplit) * sizeof(char*) );
+    if (!currentSplit) 
+    {
+        if (str)
+        {
+            FREE(str);
+            str = NULL;
+        }
+        return NULL;
+    }
+    pos = str;
+    while( currentSep < sizeSplit ) 
+    {
+        if ( !( removeEmptyField && !*pos ) )
+        {
+            currentSplit[currentSep++] = strdup(pos);
+        }
+
+        while( *pos++ );
+        pos += sizeSeparator - 1;
+    }
+
+    if (str)
+    {
+        FREE(str);
+        str = NULL;
+    }
+
+    *nbLines = (int)sizeSplit;
+    return currentSplit;
+}
+/*--------------------------------------------------------------------------*/
index 3fca38f..e317960 100644 (file)
@@ -283,9 +283,9 @@ lib /DEF:"$(ProjectDir)api_scilab_Import.def" /SUBSYSTEM:WINDOWS /MACHINE:$(Plat
     <ClCompile Include="DllmainOutput_Stream.c" />
     <ClCompile Include="do_xxprintf.c" />
     <ClCompile Include="errmds.c" />
-    <ClCompile Include="errmsg.c" />
     <ClCompile Include="erro.c" />
     <ClCompile Include="error.c" />
+    <ClCompile Include="errorTable.c" />
     <ClCompile Include="error_internal.c" />
     <ClCompile Include="..\cpp\getDiaryDate.cpp" />
     <ClCompile Include="..\cpp\getFullFilename.cpp" />
@@ -316,8 +316,8 @@ lib /DEF:"$(ProjectDir)api_scilab_Import.def" /SUBSYSTEM:WINDOWS /MACHINE:$(Plat
     <ClInclude Include="..\..\includes\do_error_number.h" />
     <ClInclude Include="..\..\includes\dynlib_output_stream.h" />
     <ClInclude Include="..\..\includes\errmds.h" />
-    <ClInclude Include="errmsg.h" />
     <ClInclude Include="..\..\includes\erro.h" />
+    <ClInclude Include="errorTable.h" />
     <ClInclude Include="error_internal.h" />
     <ClInclude Include="..\cpp\getDiaryDate.hxx" />
     <ClInclude Include="..\cpp\getFullFilename.hxx" />
index 0aee082..86029ff 100644 (file)
@@ -50,9 +50,6 @@
     <ClCompile Include="errmds.c">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="errmsg.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="erro.c">
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="set_xxprintf.c">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="errorTable.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\includes\basout.h">
     <ClInclude Include="..\..\includes\errmds.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="errmsg.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\includes\erro.h">
       <Filter>Header Files</Filter>
     </ClInclude>
     <ClInclude Include="set_xxprintf.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="errorTable.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="..\..\locales\en_US\output_stream.pot">