Remove memory leaks
[scilab.git] / scilab / modules / output_stream / src / c / errorTable.c
1 /*
2  * ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) DIGITEO - 2010-2011 - Allan CORNET
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12 #include <string.h>
13 #include <stdio.h>
14 #include <stdarg.h>
15 #include "localization.h"
16 #include "stack-c.h"
17 #include "MALLOC.h"
18 #include "stackinfo.h"
19 #include "inffic.h"
20 #ifdef _MSC_VER
21 #include "strdup_Windows.h"
22 #endif
23 #include "errorTable.h"
24 #include "lasterror.h"
25 #include "Scierror.h"
26 #include "strsubst.h"
27 /*--------------------------------------------------------------------------*/
28 typedef enum
29 {
30     CVNAME_READING_TYPE_1 = 0,
31     CVNAME_READING_TYPE_2 = 1,
32     CVNAME_READING_TYPE_3 = 2,
33     CVNAME_READING_TYPE_4 = 3,
34     CVNAME_READING_TYPE_5 = 4,
35     CVNAME_READING_TYPE_6 = 5,
36 } CVNAME_TYPE;
37 /*--------------------------------------------------------------------------*/
38 extern int C2F(errmgr)(); /* fortran */
39 /*--------------------------------------------------------------------------*/
40 static void strip_blank(char *source);
41 static char *getConvertedNameFromStack(int cvnametype);
42 static char *defaultStringError(void);
43 /*--------------------------------------------------------------------------*/
44 int errorTable(int iErr)
45 {
46     int errtyp = 0; /* by default error can be catched */
47     int iValueReturned = 0;
48
49     /* clean last error */
50     clearInternalLastError();
51
52     switch (iErr)
53     {
54         case 1:
55         {
56             iValueReturned = Scierror(iErr, _("Incorrect assignment.\n"));
57         }
58         break;
59         case 2:
60         {
61             iValueReturned = Scierror(iErr, _("Invalid factor.\n"));
62             errtyp = 1;
63             C2F(errmgr)(&iErr, &errtyp);
64         }
65         break;
66         case 3:
67         {
68             iValueReturned = Scierror(iErr, _("Waiting for right parenthesis.\n"));
69             errtyp = 1;
70             C2F(errmgr)(&iErr, &errtyp);
71         }
72         break;
73         case 4:
74         {
75             /* bug 6435 */
76             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_6);
77             if (NameVarOnStack)
78             {
79                 if (NameVarOnStack[0] != '0')
80                 {
81                     iValueReturned = Scierror(iErr, _("Undefined variable: %s\n"), NameVarOnStack);
82                     FREE(NameVarOnStack);
83                     NameVarOnStack = NULL;
84                     break;
85                 }
86
87                 FREE(NameVarOnStack);
88                 NameVarOnStack = NULL;
89             }
90             iValueReturned = Scierror(iErr, _("Undefined variable.\n"));
91         }
92         break;
93         case 5:
94         {
95             iValueReturned = Scierror(iErr, _("Inconsistent column/row dimensions.\n"));
96         }
97         break;
98         case 6:
99         {
100             iValueReturned = Scierror(iErr, _("Inconsistent row/column dimensions.\n"));
101         }
102         break;
103         case 7:
104         {
105             iValueReturned = Scierror(iErr, _("Dot cannot be used as modifier for this operator.\n"));
106         }
107         break;
108         case 8:
109         {
110             iValueReturned = Scierror(iErr, _("Inconsistent addition.\n"));
111         }
112         break;
113         case 9:
114         {
115             iValueReturned = Scierror(iErr, _("Inconsistent subtraction.\n"));
116         }
117         break;
118         case 10:
119         {
120             iValueReturned = Scierror(iErr, _("Inconsistent multiplication.\n"));
121         }
122         break;
123         case 11:
124         {
125             iValueReturned = Scierror(iErr, _("Inconsistent right division.\n"));
126         }
127         break;
128         case 12:
129         {
130             iValueReturned = Scierror(iErr, _("Inconsistent left division.\n"));
131         }
132         break;
133         case 13:
134         {
135             iValueReturned = Scierror(iErr, _("Redefining permanent variable.\n"));
136         }
137         break;
138         case 14:
139         {
140             iValueReturned = Scierror(iErr, _("Eye variable undefined in this context.\n"));
141         }
142         break;
143         case 15:
144         {
145             iValueReturned = Scierror(iErr, _("Submatrix incorrectly defined.\n"));
146         }
147         break;
148         case 16:
149         {
150             iValueReturned = Scierror(iErr, _("Incorrect command!\n"));
151             errtyp = 1; /* error not recoverable */
152             C2F(errmgr)(&iErr, &errtyp);
153         }
154         break;
155         case 17:
156         {
157             int Memory_used_for_variables = 0;
158             int Intermediate_Memory = 0;
159             int Total_Memory_available = 0;
160             char msgErr[bsiz];
161             char msgTmp[bsiz];
162
163             Intermediate_Memory = getIntermediateMemoryNeeded();
164             C2F(getstackinfo)(&Total_Memory_available, &Memory_used_for_variables);
165
166             strcpy(msgErr, _("stack size exceeded!\n"));
167             strcat(msgErr, _("Use stacksize function to increase it.\n"));
168
169             sprintf(msgTmp, _("Memory used for variables: %d\n"), Memory_used_for_variables);
170             strcat(msgErr, msgTmp);
171
172             sprintf(msgTmp, _("Intermediate memory needed: %d\n"), Intermediate_Memory);
173             strcat(msgErr, msgTmp);
174
175             sprintf(msgTmp, _("Total memory available: %d\n"), Total_Memory_available);
176             strcat(msgErr, msgTmp);
177
178             iValueReturned = Scierror(iErr, msgErr);
179         }
180         break;
181         case 18:
182         {
183             iValueReturned = Scierror(iErr, _("Too many variables!\n"));
184         }
185         break;
186         case 19:
187         {
188             iValueReturned = Scierror(iErr, _("Problem is singular.\n"));
189         }
190         break;
191         case 20:
192         {
193             if (Err == 1)
194             {
195                 iValueReturned = Scierror(iErr, _("Wrong type for first argument: Square matrix expected.\n"));
196             }
197             else
198             {
199                 iValueReturned = Scierror(iErr, _("Wrong type for argument %d: Square matrix expected.\n"), Err);
200             }
201         }
202         break;
203         case 21:
204         {
205             iValueReturned = Scierror(iErr, _("Invalid index.\n"));
206         }
207         break;
208         case 22:
209         {
210             iValueReturned = Scierror(iErr, _("Recursion problems. Sorry...\n"));
211         }
212         break;
213         case 23:
214         {
215             iValueReturned = Scierror(iErr, _("Matrix norms available are 1, 2, inf, and fro.\n"));
216         }
217         break;
218         case 24:
219         {
220             iValueReturned = Scierror(iErr, _("Convergence problem...\n"));
221         }
222         break;
223         case 25:
224         {
225             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_2);
226             if (NameVarOnStack)
227             {
228                 iValueReturned = Scierror(iErr, _("Bad call to primitive: %s\n"), NameVarOnStack);
229                 FREE(NameVarOnStack);
230                 NameVarOnStack = NULL;
231             }
232         }
233         break;
234         case 26:
235         {
236             iValueReturned = Scierror(iErr, _("Too complex recursion! (recursion tables are full)\n"));
237             /* break recursion */
238             C2F(recu).pt = Min(C2F(recu).pt, psiz);
239             errtyp = 1; /* error not recoverable */
240             C2F(errmgr)(&iErr, &errtyp);
241         }
242         break;
243         case 27:
244         {
245             iValueReturned = Scierror(iErr, _("Division by zero...\n"));
246         }
247         break;
248         case 28:
249         {
250             iValueReturned = Scierror(iErr, _("Empty function...\n"));
251         }
252         break;
253         case 29:
254         {
255             iValueReturned = Scierror(iErr, _("Matrix is not positive definite.\n"));
256         }
257         break;
258         case 30:
259         {
260             iValueReturned = Scierror(iErr, _("Invalid exponent.\n"));
261         }
262         break;
263         case 31:
264         {
265             iValueReturned = Scierror(iErr, _( "Incorrect string.\n"));
266             errtyp = 1; /* error not recoverable */
267             C2F(errmgr)(&iErr, &errtyp);
268         }
269         break;
270         case 32:
271         {
272             iValueReturned = Scierror(iErr, _("Singularity of log or tan function.\n"));
273         }
274         break;
275         case 33:
276         {
277             iValueReturned = Scierror(iErr, _("Too many ':'\n"));
278         }
279         break;
280         case 34:
281         {
282             iValueReturned = Scierror(iErr, _("Incorrect control instruction syntax.\n"));
283             errtyp = 1; /* error not recoverable */
284             C2F(errmgr)(&iErr, &errtyp);
285         }
286         break;
287         case 35:
288         {
289             switch (C2F(recu).ids[C2F(recu).pt * nsiz - nsiz]) /* find instruction type */
290             {
291                 case 1: /* if */
292                     iValueReturned = Scierror(iErr, _("Syntax error in a '%s' instruction.\n"), "if");
293                     break;
294
295                 case 2: /* while */
296                     iValueReturned = Scierror(iErr, _("Syntax error in a '%s' instruction.\n"), "while");
297                     break;
298
299                 default: /* select/case */
300                     iValueReturned = Scierror(iErr, _("Syntax error in a '%s' instruction.\n"), "select/case");
301                     break;
302             }
303             errtyp = 1; /* error not recoverable */
304             C2F(errmgr)(&iErr, &errtyp);
305         }
306         break;
307         case 36:
308         {
309             if (Err == 1)
310             {
311                 iValueReturned = Scierror(iErr, _("Wrong first argument.\n"));
312             }
313             else
314             {
315                 iValueReturned = Scierror(iErr, _("Wrong input argument %d.\n"), Err);
316             }
317         }
318         break;
319         case 37:
320         {
321             if (Err > 0)
322                 iValueReturned = Scierror(iErr, _("Incorrect function at line %d.\n"), Err);
323             else
324                 iValueReturned = Scierror(iErr, _("Incorrect function.\n"));
325         }
326         break;
327         case 38:
328         {
329             iValueReturned = Scierror(iErr, _("Wrong file name.\n"));
330         }
331         break;
332         case 39:
333         {
334             iValueReturned = Scierror(iErr, _("Incorrect number of input arguments.\n"));
335         }
336         break;
337         case 40:
338         {
339             iValueReturned = Scierror(iErr, _("Waiting for end of command.\n"));
340             errtyp = 1; /* error not recoverable */
341             C2F(errmgr)(&iErr, &errtyp);
342         }
343         break;
344         case 41:
345         {
346             iValueReturned = Scierror(iErr, _("Incompatible output argument.\n"));
347         }
348         break;
349         case 42:
350         {
351             iValueReturned = Scierror(iErr, _("Incompatible input argument.\n"));
352         }
353         break;
354         case 43:
355         {
356             iValueReturned = Scierror(iErr, _("Not implemented in scilab...\n"));
357         }
358         break;
359         case 44:
360         {
361             if (Err == 1)
362             {
363                 iValueReturned = Scierror(iErr, _("Wrong first argument.\n"));
364             }
365             else
366             {
367                 iValueReturned = Scierror(iErr, _("Wrong argument %d.\n"), Err);
368             }
369         }
370         break;
371         case 45:
372         {
373             iValueReturned = Scierror(iErr, _("null matrix (argument # %d).\n"), Err);
374         }
375         break;
376         case 46:
377         {
378             iValueReturned = Scierror(iErr, _("Incorrect syntax.\n"));
379             errtyp = 1; /* error not recoverable */
380             C2F(errmgr)(&iErr, &errtyp);
381         }
382         break;
383         case 47:
384         {
385             iValueReturned = Scierror(iErr, _(" end or else is missing...\n"));
386             errtyp = 1; /* error not recoverable */
387             C2F(errmgr)(&iErr, &errtyp);
388         }
389         break;
390         case 48:
391         {
392             iValueReturned = Scierror(iErr, _(" input line longer than buffer size: %d\n"), bsiz);
393         }
394         break;
395         case 49:
396         {
397             iValueReturned = Scierror(iErr, _("Incorrect file or format.\n"));
398         }
399         break;
400         case 50:
401         {
402             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_5);
403             if (NameVarOnStack)
404             {
405                 iValueReturned = Scierror(iErr, _("subroutine not found: %s\n"), NameVarOnStack);
406                 FREE(NameVarOnStack);
407                 NameVarOnStack = NULL;
408             }
409         }
410         break;
411         case 51:
412         {
413             /* no message  */
414             iValueReturned = Scierror(iErr, "");
415         }
416         break;
417         case 52:
418         {
419             iValueReturned = Scierror(iErr, _("Wrong type for argument %d: Real matrix expected.\n"), Err);
420         }
421         break;
422         case 53:
423         {
424             iValueReturned = Scierror(iErr, _("Wrong type for input argument %d: Real or complex matrix expected.\n"), Err);
425         }
426         break;
427         case 54:
428         {
429             iValueReturned = Scierror(iErr, _("Wrong type for input argument %d: Polynomial expected.\n"), Err);
430         }
431         break;
432         case 55:
433         {
434             iValueReturned = Scierror(iErr, _("Wrong type for argument %d: String expected.\n"), Err);
435         }
436         break;
437         case 56:
438         {
439             iValueReturned = Scierror(iErr, _("Wrong type for argument %d: List expected.\n"), Err);
440         }
441         break;
442         case 57:
443         {
444             iValueReturned = Scierror(iErr, _("Problem with comparison symbol...\n"));
445         }
446         break;
447         case 58:
448         {
449             if (Rhs == 0)
450             {
451                 iValueReturned = Scierror(iErr, _("Wrong number of input arguments: This function has no input argument.\n"));
452             }
453             else
454             {
455                 iValueReturned = Scierror(iErr, _("Wrong number of input arguments."));
456             }
457         }
458         break;
459         case 59:
460         {
461             if (Lhs == 0)
462             {
463                 iValueReturned = Scierror(iErr, _("Wrong number of output arguments: This function has no output argument.\n"));
464             }
465             else
466             {
467                 iValueReturned = Scierror(iErr, _("Wrong number of output arguments.\n"));
468             }
469         }
470         break;
471         case 60:
472         {
473             iValueReturned = Scierror(iErr, _("Wrong size for argument: Incompatible dimensions.\n"));
474         }
475         break;
476         case 61:
477         {
478             iValueReturned = Scierror(iErr, _("Direct access : give format.\n"));
479         }
480         break;
481         case 62:
482         {
483             iValueReturned = Scierror(iErr, _("End of file at line %d.\n"), Err);
484         }
485         break;
486         case 63:
487         {
488             iValueReturned = Scierror(iErr, _("%d graphic terminal?\n"), Err);
489         }
490         break;
491         case 64:
492         {
493             iValueReturned = Scierror(iErr, _("Integration fails.\n"));
494         }
495         break;
496         case 65:
497         {
498             iValueReturned = Scierror(iErr, _("%d: logical unit already used.\n"), Err);
499         }
500         break;
501         case 66:
502         {
503             iValueReturned = Scierror(iErr, _("Too many files opened!\n"));
504         }
505         break;
506         case 67:
507         {
508             iValueReturned = Scierror(iErr, _("Unknown file format.\n"));
509         }
510         break;
511         case 68:
512         {
513             char msgErr[bsiz];
514             sprintf(msgErr, _("Fatal error!!! Your variables have been saved in the file : %s\n"), get_sci_data_strings(SAVE_ID));
515             strcat(msgErr, _("Bad call to a scilab function ?\n"));
516             strcat(msgErr, _("Otherwise, send a bug report to :"));
517             strcat(msgErr, "http://bugzilla.scilab.org/\n");
518             iValueReturned = Scierror(iErr, msgErr);
519         }
520         break;
521         case 69:
522         {
523             iValueReturned = Scierror(iErr, _("Floating point exception.\n"));
524         }
525         break;
526         case 70:
527         {
528             iValueReturned = Scierror(iErr, _("Too many arguments in fort (max 30).\n"));
529         }
530         break;
531         case 71:
532         {
533             iValueReturned = Scierror(iErr, _("This variable is not valid in fort.\n"));
534         }
535         break;
536         case 72:
537         {
538             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_2);
539             if (NameVarOnStack)
540             {
541                 iValueReturned = Scierror(iErr, _("%s is not valid in this context.\n"), NameVarOnStack);
542                 FREE(NameVarOnStack);
543                 NameVarOnStack = NULL;
544             }
545         }
546         break;
547         case 73:
548         {
549             iValueReturned = Scierror(iErr, _("Error while linking.\n"));
550         }
551         break;
552         case 74:
553         {
554             iValueReturned = Scierror(iErr, _("Leading coefficient is zero.\n"));
555         }
556         break;
557         case 75:
558         {
559             iValueReturned = Scierror(iErr, _("Too high degree (max 100).\n"));
560         }
561         break;
562         case 76:
563         {
564             iValueReturned = Scierror(iErr, _("for x=val with type(val)=%d  is not implemented in Scilab.\n"), Err);
565         }
566         break;
567         case 77:
568         {
569             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_1);
570             if (NameVarOnStack)
571             {
572                 iValueReturned = Scierror(iErr, _("%s: Wrong number of input arguments.\n"), NameVarOnStack);
573                 FREE(NameVarOnStack);
574                 NameVarOnStack = NULL;
575             }
576         }
577         break;
578         case 78:
579         {
580             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_1);
581             if (NameVarOnStack)
582             {
583                 iValueReturned = Scierror(iErr, _("%s: Wrong number of output arguments.\n"), NameVarOnStack);
584                 FREE(NameVarOnStack);
585                 NameVarOnStack = NULL;
586             }
587         }
588         break;
589         case 79:
590         {
591             iValueReturned = Scierror(iErr, _("Indexing not allowed for output arguments of resume.\n"), Err);
592         }
593         break;
594         case 80:
595         {
596             iValueReturned = Scierror(iErr, _("Incorrect function (argument n: %d).\n"), Err);
597         }
598         break;
599         case 81:
600         {
601             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
602             if (NameVarOnStack)
603             {
604                 iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Real or complex matrix expected.\n"), NameVarOnStack, Err);
605                 FREE(NameVarOnStack);
606                 NameVarOnStack = NULL;
607             }
608         }
609         break;
610         case 82:
611         {
612             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
613             if (NameVarOnStack)
614             {
615                 iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Real matrix expected.\n"), NameVarOnStack, Err);
616                 FREE(NameVarOnStack);
617                 NameVarOnStack = NULL;
618             }
619         }
620         break;
621         case 83:
622         {
623             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
624             if (NameVarOnStack)
625             {
626                 iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Real vector expected.\n"), NameVarOnStack, Err);
627                 FREE(NameVarOnStack);
628                 NameVarOnStack = NULL;
629             }
630         }
631         break;
632         case 84:
633         {
634             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
635             if (NameVarOnStack)
636             {
637                 iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Scalar expected.\n"), NameVarOnStack, Err);
638                 FREE(NameVarOnStack);
639                 NameVarOnStack = NULL;
640             }
641         }
642         break;
643         case 85:
644         {
645             iValueReturned = Scierror(iErr, _("Host does not answer...\n"));
646         }
647         break;
648         case 86:
649         {
650             iValueReturned = Scierror(iErr, _("Uncontrollable system.\n"));
651         }
652         break;
653         case 87:
654         {
655             iValueReturned = Scierror(iErr, _("Unobservable system.\n"));
656         }
657         break;
658         case 88:
659         {
660             iValueReturned = Scierror(iErr, _("%s: singular or asymmetric problem.\n"), "sfact");
661         }
662         break;
663         case 89:
664         {
665             iValueReturned = Scierror(iErr, _("Wrong size for argument %d.\n"), Err);
666         }
667         break;
668         case 90:
669         {
670             iValueReturned = Scierror(iErr, _("Wrong type for argument %d: Transfer matrix expected.\n"), Err);
671         }
672         break;
673         case 91:
674         {
675             iValueReturned = Scierror(iErr, _("Wrong type for argument %d: In state space form expected.\n"), Err);
676         }
677         break;
678         case 92:
679         {
680             iValueReturned = Scierror(iErr, _("Wrong type for argument %d: Rational matrix expected.\n"), Err);
681         }
682         break;
683         case 93:
684         {
685             iValueReturned = Scierror(iErr, _("Wrong type for argument %d: In continuous time expected.\n"), Err);
686         }
687         break;
688         case 94:
689         {
690             iValueReturned = Scierror(iErr, _("Wrong type for argument %d: In discrete time expected.\n"), Err);
691         }
692         break;
693         case 95:
694         {
695             iValueReturned = Scierror(iErr, _("Wrong type for argument %d: SISO expected.\n"), Err);
696         }
697         break;
698         case 96:
699         {
700             iValueReturned = Scierror(iErr, _("time domain of argument %d is not defined.\n"), Err);
701         }
702         break;
703         case 97:
704         {
705             iValueReturned = Scierror(iErr, _("Wrong type for argument %d: A system in state space or transfer matrix form expected.\n"), Err);
706         }
707         break;
708         case 98:
709         {
710             iValueReturned = Scierror(iErr, _("Variable returned by scilab argument function is incorrect.\n"));
711         }
712         break;
713         case 99:
714         {
715             if (Err != 1)
716             {
717                 iValueReturned = Scierror(iErr, _("Elements of %dth argument must be in increasing order.\n"), Err);
718             }
719             else
720             {
721                 iValueReturned = Scierror(iErr, _("Elements of first argument are not (strictly) increasing.\n"));
722             }
723         }
724         break;
725         case 100:
726         {
727             if (Err != 1)
728             {
729                 iValueReturned = Scierror(iErr, _("Elements of %dth argument are not in (strictly) decreasing order.\n"), Err);
730             }
731             else
732             {
733                 iValueReturned = Scierror(iErr, _("Elements of first argument are not in (strictly) decreasing order.\n"));
734             }
735         }
736         break;
737         case 101:
738         {
739             if (Err != 1)
740             {
741                 iValueReturned = Scierror(iErr, _("Last element of %dth argument <> first.\n"), Err);
742             }
743             else
744             {
745                 iValueReturned = Scierror(iErr, _("Last element of first argument does not match the first one.\n"));
746             }
747         }
748         break;
749         case 102:
750         {
751             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_2);
752             if (NameVarOnStack)
753             {
754                 iValueReturned = Scierror(iErr, _("Variable or function %s are not in file.\n"), NameVarOnStack);
755                 FREE(NameVarOnStack);
756                 NameVarOnStack = NULL;
757             }
758         }
759         break;
760         case 103:
761         {
762             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_3);
763             if (NameVarOnStack)
764             {
765                 iValueReturned = Scierror(iErr, _("Variable %s is not a valid rational function.\n"), NameVarOnStack);
766                 FREE(NameVarOnStack);
767                 NameVarOnStack = NULL;
768             }
769         }
770         break;
771         case 104:
772         {
773             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_3);
774             if (NameVarOnStack)
775             {
776                 iValueReturned = Scierror(iErr, _("Variable %s is not a valid state space representation.\n"), NameVarOnStack);
777                 FREE(NameVarOnStack);
778                 NameVarOnStack = NULL;
779             }
780         }
781         break;
782         case 105:
783         {
784             iValueReturned = Scierror(iErr, _("Undefined function.\n"));
785         }
786         break;
787         case 106:
788         {
789             iValueReturned = Scierror(iErr, _("Function name already used.\n"));
790         }
791         break;
792         case 107:
793         {
794             iValueReturned = Scierror(iErr, _("Too many functions are defined (maximum #:%d).\n"), Err);
795         }
796         break;
797         case 108:
798         {
799             iValueReturned = Scierror(iErr, _("Too complex for scilab, may be a too long control instruction.\n"));
800         }
801         break;
802         case 109:
803         {
804             iValueReturned = Scierror(iErr, _("Too large, can't be displayed.\n"));
805         }
806         break;
807         case 110:
808         {
809             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_2);
810             if (NameVarOnStack)
811             {
812                 iValueReturned = Scierror(iErr, _("%s was a function when compiled but is now a primitive!\n"), NameVarOnStack);
813                 FREE(NameVarOnStack);
814                 NameVarOnStack = NULL;
815             }
816         }
817         break;
818         case 111:
819         {
820             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_2);
821             if (NameVarOnStack)
822             {
823                 iValueReturned = Scierror(iErr, _("Trying to re-define function %s.\n"), NameVarOnStack);
824                 FREE(NameVarOnStack);
825                 NameVarOnStack = NULL;
826             }
827         }
828         break;
829         case 112:
830         {
831             iValueReturned = Scierror(iErr, _("No more memory.\n"));
832         }
833         break;
834         case 113:
835         {
836             iValueReturned = Scierror(iErr, _("Too large string.\n"));
837         }
838         break;
839         case 114:
840         {
841             iValueReturned = Scierror(iErr, _("Too many linked routines.\n"));
842         }
843         break;
844         case 115:
845         {
846             char msgErr[bsiz];
847             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"));
848             strcat(msgErr, "http://bugzilla.scilab.org/\n");
849             iValueReturned = Scierror(iErr, msgErr);
850         }
851         break;
852         case 116:
853         {
854             iValueReturned = Scierror(iErr, _("Wrong value for argument %d.\n"), Err);
855         }
856         break;
857         case 117:
858         {
859             iValueReturned = Scierror(iErr, _("List element number %d is Undefined.\n"), Err);
860         }
861         break;
862         case 118:
863         {
864             iValueReturned = Scierror(iErr, _("Wrong type for argument %d: Named variable not an expression expected.\n"), Err);
865         }
866         break;
867         case 119:
868         {
869             /* no message  */
870             iValueReturned = Scierror(iErr, "");
871         }
872         break;
873         case 120:
874         {
875             iValueReturned = Scierror(iErr, _("Indices for non-zero elements must be given by a 2 column matrix.\n"));
876         }
877         break;
878         case 121:
879         {
880             iValueReturned = Scierror(iErr, _("Incompatible indices for non-zero elements.\n"));
881         }
882         break;
883         case 122:
884         {
885             iValueReturned = Scierror(iErr, _("Logical unit number should be larger than %d.\n"), Err);
886         }
887         break;
888         case 123:
889         {
890             iValueReturned = Scierror(iErr, _("Function not bounded from below.\n"));
891         }
892         break;
893         case 124:
894         {
895             /* no message  */
896             iValueReturned = Scierror(iErr, "");
897         }
898         break;
899         case 125:
900         {
901             iValueReturned = Scierror(iErr, _("Problem may be unbounded: too high distance between two consecutive iterations.\n"));
902         }
903         break;
904         case 126:
905         {
906             iValueReturned = Scierror(iErr, _("Inconsistent constraints.\n"));
907         }
908         break;
909         case 127:
910         {
911             iValueReturned = Scierror(iErr, _("No feasible solution.\n"));
912         }
913         break;
914         case 128:
915         {
916             iValueReturned = Scierror(iErr, _("Degenerate starting point.\n"));
917         }
918         break;
919         case 129:
920         {
921             iValueReturned = Scierror(iErr, _("No feasible point has been found.\n"));
922         }
923         break;
924         case 130:
925         {
926             iValueReturned = Scierror(iErr, _("Optimization fails: back to initial point.\n"));
927         }
928         break;
929         case 131:
930         {
931             iValueReturned = Scierror(iErr, _("%s: Stop requested by simulator (ind=0)\n"), "optim");
932         }
933         break;
934         case 132:
935         {
936             iValueReturned = Scierror(iErr, _("%s: Wrong input parameters.\n"), "optim");
937         }
938         break;
939         case 133:
940         {
941             iValueReturned = Scierror(iErr, _("Too small memory.\n"));
942         }
943         break;
944         case 134:
945         {
946             iValueReturned = Scierror(iErr, _("%s: Problem with initial constants in simul.\n"), "optim");
947         }
948         break;
949         case 135:
950         {
951             iValueReturned = Scierror(iErr, _("%s: Bounds and initial guess are incompatible.\n"), "optim");
952         }
953         break;
954         case 136:
955         {
956             iValueReturned = Scierror(iErr, _("%s: This method is NOT implemented.\n"), "optim");
957         }
958         break;
959         case 137:
960         {
961             iValueReturned = Scierror(iErr, _("NO hot restart available in this method.\n"));
962         }
963         break;
964         case 138:
965         {
966             iValueReturned = Scierror(iErr, _("%s: Incorrect stopping parameters.\n"), "optim");
967         }
968         break;
969         case 139:
970         {
971             iValueReturned = Scierror(iErr, _("%s: Incorrect bounds.\n"), "optim");
972         }
973         break;
974         case 140:
975         {
976
977             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_6);
978             if (NameVarOnStack)
979             {
980                 iValueReturned = Scierror(iErr, _("Variable : %s must be a list\n"), NameVarOnStack);
981                 FREE(NameVarOnStack);
982                 NameVarOnStack = NULL;
983             }
984
985         }
986         break;
987         case 141:
988         {
989             iValueReturned = Scierror(iErr, _("Incorrect function (argument n: %d).\n"), Err);
990         }
991         break;
992         case 142:
993         {
994             iValueReturned = Scierror(iErr, _("Hot restart: dimension of working table (argument n:%d).\n"), Err);
995         }
996         break;
997         case 143:
998         {
999             iValueReturned = Scierror(iErr, _("%s: df0 must be positive !\n"), "optim");
1000         }
1001         break;
1002         case 144:
1003         {
1004             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_1);
1005             if (NameVarOnStack)
1006             {
1007                 char msgFormat[bsiz * 2];
1008                 sprintf(msgFormat, "%s%s", _("Undefined operation for the given operands.\n"), _("check or define function %s for overloading.\n"));
1009                 iValueReturned = Scierror(iErr, msgFormat, NameVarOnStack);
1010                 FREE(NameVarOnStack);
1011                 NameVarOnStack = NULL;
1012             }
1013         }
1014         break;
1015
1016         /* error 145 to 199  not used */
1017
1018         /*
1019         messages from 201 to 203 and 205 to 214 are no more used by error
1020         (see Scierror  in stack1.c)
1021         */
1022         case 200:
1023         {
1024             /* no message  */
1025             iValueReturned = Scierror(iErr, "");
1026         }
1027         break;
1028         case 201:
1029         {
1030             /* not used  */
1031             /* only for compatibility */
1032             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
1033             if (NameVarOnStack)
1034             {
1035                 iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Real or complex matrix expected.\n"), NameVarOnStack, Err);
1036                 FREE(NameVarOnStack);
1037                 NameVarOnStack = NULL;
1038             }
1039         }
1040         break;
1041         case 202:
1042         {
1043             /* not used  */
1044             /* only for compatibility */
1045             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
1046             if (NameVarOnStack)
1047             {
1048                 iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Real matrix expected.\n"), NameVarOnStack, Err);
1049                 FREE(NameVarOnStack);
1050                 NameVarOnStack = NULL;
1051             }
1052         }
1053         break;
1054         case 203:
1055         {
1056             /* not used  */
1057             /* only for compatibility */
1058             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
1059             if (NameVarOnStack)
1060             {
1061                 iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Real vector expected.\n"), NameVarOnStack, Err);
1062                 FREE(NameVarOnStack);
1063                 NameVarOnStack = NULL;
1064             }
1065         }
1066         break;
1067         case 204:
1068         {
1069             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
1070             if (NameVarOnStack)
1071             {
1072                 iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Scalar expected.\n"), NameVarOnStack, Err);
1073                 FREE(NameVarOnStack);
1074                 NameVarOnStack = NULL;
1075             }
1076         }
1077         break;
1078         case 205:
1079         {
1080             int minvalue = C2F(recu).pstk[C2F(recu).pt];
1081             int maxvalue = C2F(recu).pstk[C2F(recu).pt + 1];
1082
1083             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
1084             if (NameVarOnStack)
1085             {
1086                 iValueReturned = Scierror(iErr, _("%s: Wrong size for argument %d: (%d,%d) expected.\n"), NameVarOnStack, Err, minvalue, maxvalue);
1087                 FREE(NameVarOnStack);
1088                 NameVarOnStack = NULL;
1089             }
1090         }
1091         break;
1092         case 206:
1093         {
1094             int vectorsize = C2F(recu).pstk[C2F(recu).pt];
1095
1096             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
1097             if (NameVarOnStack)
1098             {
1099                 iValueReturned = Scierror(iErr, _("%s: Wrong size for argument %d: %d expected.\n"), NameVarOnStack, Err, vectorsize);
1100                 FREE(NameVarOnStack);
1101                 NameVarOnStack = NULL;
1102             }
1103         }
1104         break;
1105         case 207:
1106         {
1107             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
1108             if (NameVarOnStack)
1109             {
1110                 iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Matrix of strings expected.\n"), NameVarOnStack, Err);
1111                 FREE(NameVarOnStack);
1112                 NameVarOnStack = NULL;
1113             }
1114         }
1115         break;
1116         case 208:
1117         {
1118             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
1119             if (NameVarOnStack)
1120             {
1121                 iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Boolean matrix expected.\n"), NameVarOnStack, Err);
1122                 FREE(NameVarOnStack);
1123                 NameVarOnStack = NULL;
1124             }
1125         }
1126         break;
1127         case 209:
1128         {
1129             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
1130             if (NameVarOnStack)
1131             {
1132                 iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Matrix expected.\n"), NameVarOnStack, Err);
1133                 FREE(NameVarOnStack);
1134                 NameVarOnStack = NULL;
1135             }
1136         }
1137         break;
1138         case 210:
1139         {
1140             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
1141             if (NameVarOnStack)
1142             {
1143                 iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: List expected.\n"), NameVarOnStack, Err);
1144                 FREE(NameVarOnStack);
1145                 NameVarOnStack = NULL;
1146             }
1147         }
1148         break;
1149         case 211:
1150         {
1151             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
1152             if (NameVarOnStack)
1153             {
1154                 iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Function or string (external function) expected.\n"), NameVarOnStack, Err);
1155                 FREE(NameVarOnStack);
1156                 NameVarOnStack = NULL;
1157             }
1158         }
1159         break;
1160         case 212:
1161         {
1162             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
1163             if (NameVarOnStack)
1164             {
1165                 iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Polynomial expected.\n"), NameVarOnStack, Err);
1166                 FREE(NameVarOnStack);
1167                 NameVarOnStack = NULL;
1168             }
1169         }
1170         break;
1171         case 213:
1172         {
1173             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
1174             if (NameVarOnStack)
1175             {
1176                 iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Working int matrix expected.\n"), NameVarOnStack, Err);
1177                 FREE(NameVarOnStack);
1178                 NameVarOnStack = NULL;
1179             }
1180         }
1181         break;
1182         case 214:
1183         {
1184             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
1185             if (NameVarOnStack)
1186             {
1187                 iValueReturned = Scierror(iErr, _("%s: Wrong type for argument %d: Vector expected.\n"), NameVarOnStack, Err);
1188                 FREE(NameVarOnStack);
1189                 NameVarOnStack = NULL;
1190             }
1191         }
1192         break;
1193         case 215:
1194         {
1195             if (Err != 1)
1196             {
1197                 iValueReturned = Scierror(iErr, _("%dth argument type must be boolean.\n"), Err);
1198             }
1199             else
1200             {
1201                 iValueReturned = Scierror(iErr, _("Argument type must be boolean.\n"));
1202             }
1203         }
1204         break;
1205         case 216:
1206         {
1207             iValueReturned = Scierror(iErr, _("Wrong type for argument %d: Boolean or scalar expected.\n"), Err);
1208         }
1209         break;
1210         case 217:
1211         {
1212             iValueReturned = Scierror(iErr, _("Wrong type for argument %d: Sparse matrix of scalars expected.\n"), Err);
1213         }
1214         break;
1215         case 218:
1216         {
1217             iValueReturned = Scierror(iErr, _("Wrong type for argument %d: Handle to sparse lu factors expected.\n"), Err);
1218         }
1219         break;
1220         case 219:
1221         {
1222             iValueReturned = Scierror(iErr, _("Wrong type argument %d: Sparse or full scalar matrix expected.\n"), Err);
1223         }
1224         break;
1225         case 220:
1226         {
1227             iValueReturned = Scierror(iErr, _("Null variable cannot be used here.\n"));
1228         }
1229         break;
1230         case 221:
1231         {
1232             iValueReturned = Scierror(iErr, _("A sparse matrix entry is defined with two different values.\n"));
1233         }
1234         break;
1235         case 222:
1236         {
1237             iValueReturned = Scierror(iErr, _("%s not yet implemented for full input parameter.\n"), "lusolve");
1238         }
1239         break;
1240         case 223:
1241         {
1242             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_1);
1243             if (NameVarOnStack)
1244             {
1245                 iValueReturned = Scierror(iErr, _("It is not possible to redefine the %s primitive this way (see clearfun).\n"), NameVarOnStack);
1246                 FREE(NameVarOnStack);
1247                 NameVarOnStack = NULL;
1248             }
1249         }
1250         break;
1251         case 224:
1252         {
1253             iValueReturned = Scierror(iErr, _("Type data base is full.\n"));
1254         }
1255         break;
1256         case 225:
1257         {
1258             iValueReturned = Scierror(iErr, _("This data type is already defined.\n"));
1259         }
1260         break;
1261         case 226:
1262         {
1263             iValueReturned = Scierror(iErr, _("Inequality comparison with empty matrix.\n"));
1264         }
1265         break;
1266         case 227:
1267         {
1268             iValueReturned = Scierror(iErr, _("Missing index.\n"));
1269         }
1270         break;
1271         case 228:
1272         {
1273             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_1);
1274             if (NameVarOnStack)
1275             {
1276                 iValueReturned = Scierror(iErr, _("reference to the cleared global variable %s.\n"), NameVarOnStack);
1277                 FREE(NameVarOnStack);
1278                 NameVarOnStack = NULL;
1279             }
1280         }
1281         break;
1282         case 229:
1283         {
1284             iValueReturned = Scierror(iErr, _("Operands of / and \\ operations must not contain NaN of Inf.\n"));
1285         }
1286         break;
1287         case 230:
1288         {
1289             iValueReturned = Scierror(iErr, _("semi def fails.\n"));
1290         }
1291         break;
1292         case 231:
1293         {
1294             iValueReturned = Scierror(iErr, _("Wrong type for first input argument: Single string expected.\n"));
1295         }
1296         break;
1297         case 232:
1298         {
1299             iValueReturned = Scierror(iErr, _("Entry name not found.\n"));
1300         }
1301         break;
1302         case 233:
1303         {
1304             iValueReturned = Scierror(iErr, _("Maximum number of dynamic interfaces reached.\n"));
1305         }
1306         break;
1307         case 234:
1308         {
1309             iValueReturned = Scierror(iErr, _("%s: expecting more than one argument.\n"), "link");
1310         }
1311         break;
1312         case 235:
1313         {
1314             iValueReturned = Scierror(iErr, _("%s: problem with one of the entry point.\n"), "link");
1315         }
1316         break;
1317         case 236:
1318         {
1319             iValueReturned = Scierror(iErr, _("%s: the shared archive was not loaded.\n"), "link");
1320         }
1321         break;
1322         case 237:
1323         {
1324             iValueReturned = Scierror(iErr, _("%s: Only one entry point allowed on this operating system.\n"), "link");
1325         }
1326         break;
1327         case 238:
1328         {
1329             iValueReturned = Scierror(iErr, _("%s: First argument cannot be a number.\n"), "link");
1330         }
1331         break;
1332         case 239:
1333         {
1334             iValueReturned = Scierror(iErr, _("You cannot link more functions, maxentry reached.\n"));
1335         }
1336         break;
1337         case 240:
1338         {
1339             /* OBSOLETE */
1340             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_5);
1341             if (NameVarOnStack)
1342             {
1343                 iValueReturned = Scierror(iErr, _("File \"%s\" already exists or directory write access denied.\n"), NameVarOnStack);
1344                 FREE(NameVarOnStack);
1345                 NameVarOnStack = NULL;
1346             }
1347         }
1348         break;
1349         case 241:
1350         {
1351             /* OBSOLETE */
1352             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_5);
1353             if (NameVarOnStack)
1354             {
1355                 iValueReturned = Scierror(iErr, _("File \"%s\" does not exist or read access denied.\n"), NameVarOnStack);
1356                 FREE(NameVarOnStack);
1357                 NameVarOnStack = NULL;
1358             }
1359         }
1360         break;
1361         case 242:
1362         {
1363             iValueReturned = Scierror(iErr, _("Binary direct access files must be opened by 'file'.\n"));
1364         }
1365         break;
1366         case 243:
1367         {
1368             iValueReturned = Scierror(iErr, _("C file logical unit not allowed here.\n"));
1369         }
1370         break;
1371         case 244:
1372         {
1373             iValueReturned = Scierror(iErr, _("Fortran file logical unit not allowed here.\n"));
1374         }
1375         break;
1376         case 245:
1377         {
1378             iValueReturned = Scierror(iErr, _("No input file associated to logical unit %d.\n"), Err);
1379         }
1380         break;
1381         case 246:
1382         {
1383             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_6);
1384             if (NameVarOnStack)
1385             {
1386                 char msgFormat[bsiz * 2];
1387                 sprintf(msgFormat, "%s%s", _("Function not defined for given argument type(s),\n"), _("  check arguments or define function %s for overloading.\n"));
1388                 iValueReturned = Scierror(iErr, msgFormat, NameVarOnStack);
1389                 FREE(NameVarOnStack);
1390                 NameVarOnStack = NULL;
1391             }
1392             else
1393             {
1394                 iValueReturned = Scierror(iErr, _("Function not defined for given argument type(s),\n"));
1395             }
1396         }
1397         break;
1398         case 247:
1399         {
1400             iValueReturned = Scierror(iErr, _("Wrong value for argument %d: the lu handle is no more valid.\n"), Err);
1401         }
1402         break;
1403         case 248:
1404         {
1405             iValueReturned = Scierror(iErr, _("Wrong value for argument %d: Valid variable name expected.\n"), Err);
1406         }
1407         break;
1408         case 249:
1409         {
1410             iValueReturned = Scierror(iErr, _("Wrong value for argument %d: Empty string expected.\n"), Err);
1411         }
1412         break;
1413         case 250:
1414         {
1415             iValueReturned = Scierror(iErr, _("Recursive extraction is not valid in this context.\n"));
1416         }
1417         break;
1418         case 251:
1419         {
1420             iValueReturned = Scierror(iErr, _("%s: ipar dimensioned at least 11.\n"), "bvode");
1421         }
1422         break;
1423         case 252:
1424         {
1425             iValueReturned = Scierror(iErr, _("%s: ltol must be of size ipar(4).\n"), "bvode");
1426         }
1427         break;
1428         case 253:
1429         {
1430             iValueReturned = Scierror(iErr, _("%s: fixpnt must be of size ipar(11).\n"), "bvode");
1431         }
1432         break;
1433         case 254:
1434         {
1435             iValueReturned = Scierror(iErr, _("%s: ncomp < 20 requested.\n"), "bvode");
1436         }
1437         break;
1438         case 255:
1439         {
1440             iValueReturned = Scierror(iErr, _("%s: m must be of size ncomp.\n"), "bvode");
1441         }
1442         break;
1443         case 256:
1444         case 257:
1445         {
1446             iValueReturned = Scierror(iErr, _("%s: sum(m) must be less than 40.\n"), "bvode");
1447         }
1448         break;
1449         case 258:
1450         {
1451             iValueReturned = Scierror(iErr, _("%s: input data error.\n"), "bvode");
1452         }
1453         break;
1454         case 259:
1455         {
1456             iValueReturned = Scierror(iErr, _("%s: no. of subintervals exceeds storage.\n"), "bvode");
1457         }
1458         break;
1459         case 260:
1460         {
1461             iValueReturned = Scierror(iErr, _("%s: The colocation matrix is singular.\n"), "bvode");
1462         }
1463         break;
1464         case 261:
1465         {
1466             iValueReturned = Scierror(iErr, _("Interface property table is full.\n"));
1467         }
1468         break;
1469         case 262:
1470         {
1471             int maxglobalvariables = isizt - C2F(vstk).isiz - 1;
1472             iValueReturned = Scierror(iErr, _("Too many global variables! Max number is %d.\n"), maxglobalvariables);
1473         }
1474         break;
1475         case 263:
1476         {
1477             iValueReturned = Scierror(iErr, _("Error while writing in file: disk full or deleted file.\n"));
1478         }
1479         break;
1480         case 264:
1481         {
1482             iValueReturned = Scierror(iErr, _("Wrong value for argument %d: Must not contain NaN or Inf.\n"), Err);
1483         }
1484         break;
1485         case 265:
1486         {
1487             iValueReturned = Scierror(iErr, _("%s and %s must have equal number of rows.\n"), "A", "B");
1488         }
1489         break;
1490         case 266:
1491         {
1492             iValueReturned = Scierror(iErr, _("%s and %s must have equal number of columns.\n"), "A", "B");
1493         }
1494         break;
1495         case 267:
1496         {
1497             iValueReturned = Scierror(iErr, _("%s and %s must have equal dimensions.\n"), "A", "B");
1498         }
1499         break;
1500         case 268:
1501         {
1502             iValueReturned = Scierror(iErr, _("Invalid return value for function passed in arg %d.\n"), Err);
1503         }
1504         break;
1505         case 269:
1506         {
1507             iValueReturned = Scierror(iErr, _("Wrong value for argument %d: eigenvalues must have negative real parts.\n"), Err);
1508         }
1509         break;
1510         case 270:
1511         {
1512             iValueReturned = Scierror(iErr, _("Wrong value for argument %d: eigenvalues modulus must be less than one.\n"), Err);
1513         }
1514         break;
1515         case 271:
1516         {
1517             iValueReturned = Scierror(iErr, _("Size varying argument a*eye(), (arg %d) not allowed here.\n"), Err);
1518         }
1519         break;
1520         case 272:
1521         {
1522             iValueReturned = Scierror(iErr, _("endfunction is missing.\n"));
1523         }
1524         break;
1525         case 273:
1526         {
1527             iValueReturned = Scierror(iErr, _("Instruction left hand side: waiting for a dot or a left parenthesis.\n"));
1528         }
1529         break;
1530         case 274:
1531         {
1532             iValueReturned = Scierror(iErr, _("Instruction left hand side: waiting for a name.\n"));
1533         }
1534         break;
1535         case 275:
1536         {
1537             iValueReturned = Scierror(iErr, _("varargout keyword cannot be used here.\n"));
1538         }
1539         break;
1540         case 276:
1541         {
1542             iValueReturned = Scierror(iErr, _("Missing operator, comma, or semicolon.\n"));
1543             errtyp = 1; /* error not recoverable */
1544             C2F(errmgr)(&iErr, &errtyp);
1545         }
1546         break;
1547         case 277:
1548         {
1549             iValueReturned = Scierror(iErr, _("Too many commands defined.\n"));
1550         }
1551         break;
1552         case 278:
1553         {
1554             char *NameVarOnStack = getConvertedNameFromStack(CVNAME_READING_TYPE_4);
1555             if (NameVarOnStack)
1556             {
1557                 if (NameVarOnStack[0] != '0')
1558                 {
1559                     iValueReturned = Scierror(iErr, _("%s: Input arguments should have the same formal variable name.\n"), NameVarOnStack);
1560                 }
1561                 else
1562                 {
1563                     iValueReturned = Scierror(iErr, _("Input arguments should have the same formal variable name.\n"));
1564                 }
1565                 FREE(NameVarOnStack);
1566                 NameVarOnStack = NULL;
1567             }
1568         }
1569         break;
1570         case 279:
1571         case 280:
1572         {
1573             /* no message  */
1574             iValueReturned = Scierror(iErr, "");
1575         }
1576         break;
1577
1578         default:
1579         {
1580             char *buffer = defaultStringError();
1581             if (buffer)
1582             {
1583                 iValueReturned = Scierror(iErr, buffer);
1584                 FREE(buffer);
1585                 buffer = NULL;
1586             }
1587         }
1588         break;
1589     }
1590     return iValueReturned;
1591 }
1592 /*--------------------------------------------------------------------------*/
1593 static void strip_blank(char *source)
1594 {
1595     char *p;
1596     p = source;
1597     /* look for end of string */
1598     while (*p != '\0') p++;
1599     while (p != source)
1600     {
1601         p--;
1602         if (*p != ' ') break;
1603         *p = '\0';
1604     }
1605 }
1606 /*--------------------------------------------------------------------------*/
1607 static char *getConvertedNameFromStack(int cvnametype)
1608 {
1609     int one = 1;
1610
1611     char local_variable_buffer[bsiz];
1612
1613     switch (cvnametype)
1614     {
1615         case CVNAME_READING_TYPE_1 :
1616         {
1617             C2F(cvname)(&C2F(recu).ids[(C2F(recu).pt + 1) * nsiz - nsiz], C2F(cha1).buf, &one, bsiz);
1618             strncpy(local_variable_buffer, C2F(cha1).buf, nlgh);
1619             local_variable_buffer[nlgh - 1] = '\0';
1620         }
1621         break;
1622
1623         case CVNAME_READING_TYPE_2 :
1624         {
1625             C2F(cvname)(&C2F(recu).ids[(C2F(recu).pt + 1) * nsiz - nsiz], local_variable_buffer, &one, nlgh);
1626             local_variable_buffer[nlgh] = '\0';
1627         }
1628         break;
1629
1630         case CVNAME_READING_TYPE_3 :
1631         {
1632             C2F(cvname)(&C2F(recu).ids[C2F(recu).pt * nsiz - nsiz], C2F(cha1).buf, &one, bsiz);
1633             strncpy(local_variable_buffer, C2F(cha1).buf, nlgh);
1634             local_variable_buffer[nlgh - 1] = '\0';
1635         }
1636         break;
1637
1638         case CVNAME_READING_TYPE_4 :
1639         {
1640 #define SHIFT_CHAR 3
1641             C2F(cvname)(&C2F(recu).ids[(C2F(recu).pt + 1) * nsiz - nsiz], C2F(cha1).buf + SHIFT_CHAR, &one, nlgh + 1);
1642             strncpy(local_variable_buffer, C2F(cha1).buf + SHIFT_CHAR, nlgh);
1643             local_variable_buffer[nlgh] = '\0';
1644         }
1645         break;
1646
1647         case CVNAME_READING_TYPE_5 :
1648         {
1649             strncpy(local_variable_buffer, C2F(cha1).buf, bsiz);
1650             local_variable_buffer[bsiz - 1] = '\0';
1651         }
1652         break;
1653
1654         case CVNAME_READING_TYPE_6 :
1655         {
1656             C2F(cvname)(&C2F(recu).ids[(C2F(recu).pt + 1) * nsiz - nsiz], C2F(cha1).buf, &one, nlgh + 1);
1657             strncpy(local_variable_buffer, C2F(cha1).buf, nlgh);
1658             local_variable_buffer[nlgh - 1] = '\0';
1659         }
1660         break;
1661
1662         default:
1663             strcpy(local_variable_buffer, _("Unknown data.\n"));
1664             break;
1665     }
1666
1667     strip_blank(local_variable_buffer);
1668     /* bug 9571: % duplicated for variable name (used in sprintf) */
1669     return strsub(local_variable_buffer, "%", "%%");
1670 }
1671 /*--------------------------------------------------------------------------*/
1672 static char *defaultStringError(void)
1673 {
1674     char *buffer = NULL;
1675     int bufl = 1;
1676
1677     while (*(unsigned char *)&C2F(cha1).buf[bufl - 1] != '\0' && bufl < 80)
1678     {
1679         ++bufl;
1680     }
1681     --bufl;
1682
1683
1684     buffer = (char*)MALLOC( ((int)strlen(C2F(cha1).buf) + 1) * sizeof(char));
1685
1686     /* remove blank */
1687     if (buffer)
1688     {
1689         strcpy(buffer, C2F(cha1).buf);
1690         strip_blank(buffer);
1691     }
1692     return buffer;
1693 }
1694 /*--------------------------------------------------------------------------*/