errmsg.c File Reference

#include <string.h>
#include <stdio.h>
#include "machine.h"
#include "stack-c.h"
#include "MALLOC.h"
#include "msg_errors.h"

Include dependency graph for errmsg.c:

Go to the source code of this file.

Defines

#define MSGOUT(msg)   C2F(msgout)(&io, &lunit, msg, strlen(msg));

Functions

int C2F() freemsgtable ()
int C2F() errstore ()
int C2F() funnamestore ()
int C2F() linestore ()
int C2F() showstack ()
int C2F() inffic ()
int C2F() cvname ()
int C2F() prntid ()
int C2F() msgout ()
int C2F() errmsg (integer *n, integer *errtyp)


Define Documentation

#define MSGOUT ( msg   )     C2F(msgout)(&io, &lunit, msg, strlen(msg));

Definition at line 12 of file errmsg.c.

Referenced by errmsg().


Function Documentation

int C2F() cvname (  ) 

Referenced by Add_a_Scilab_primitive_in_hashtable(), C2F(), callscifun(), errmsg(), Get_Iname(), getGlobalNamefromId(), getLocalNamefromId(), isoptlw(), optvarget(), parse(), run(), scistring(), and str2name().

Here is the caller graph for this function:

int C2F() errmsg ( integer n,
integer errtyp 
)

Definition at line 24 of file errmsg.c.

References buf, C2F, cvname(), errstore(), FREE, freemsgtable(), funnamestore(), i, L, linestore(), lunit, MALLOC, MSGOUT, n, NULL, SCI_ERRMSG1, SCI_ERRMSG10, SCI_ERRMSG105, SCI_ERRMSG106, SCI_ERRMSG109, SCI_ERRMSG11, SCI_ERRMSG112, SCI_ERRMSG113, SCI_ERRMSG114, SCI_ERRMSG12, SCI_ERRMSG123, SCI_ERRMSG126, SCI_ERRMSG127, SCI_ERRMSG128, SCI_ERRMSG129, SCI_ERRMSG13, SCI_ERRMSG130, SCI_ERRMSG131, SCI_ERRMSG132, SCI_ERRMSG133, SCI_ERRMSG134, SCI_ERRMSG135, SCI_ERRMSG136, SCI_ERRMSG137, SCI_ERRMSG138, SCI_ERRMSG139, SCI_ERRMSG14, SCI_ERRMSG143, SCI_ERRMSG15, SCI_ERRMSG16, SCI_ERRMSG18, SCI_ERRMSG19, SCI_ERRMSG2, SCI_ERRMSG21, SCI_ERRMSG22, SCI_ERRMSG220, SCI_ERRMSG222, SCI_ERRMSG224, SCI_ERRMSG225, SCI_ERRMSG226, SCI_ERRMSG227, SCI_ERRMSG23, SCI_ERRMSG230, SCI_ERRMSG231, SCI_ERRMSG232, SCI_ERRMSG234, SCI_ERRMSG235, SCI_ERRMSG236, SCI_ERRMSG238, SCI_ERRMSG24, SCI_ERRMSG243, SCI_ERRMSG244, SCI_ERRMSG251, SCI_ERRMSG252, SCI_ERRMSG253, SCI_ERRMSG254, SCI_ERRMSG255, SCI_ERRMSG256, SCI_ERRMSG257, SCI_ERRMSG258, SCI_ERRMSG259, SCI_ERRMSG260, SCI_ERRMSG261, SCI_ERRMSG265, SCI_ERRMSG266, SCI_ERRMSG267, SCI_ERRMSG27, SCI_ERRMSG272, SCI_ERRMSG275, SCI_ERRMSG276, SCI_ERRMSG277, SCI_ERRMSG28, SCI_ERRMSG29, SCI_ERRMSG3, SCI_ERRMSG30, SCI_ERRMSG32, SCI_ERRMSG33, SCI_ERRMSG38, SCI_ERRMSG39, SCI_ERRMSG4, SCI_ERRMSG41, SCI_ERRMSG42, SCI_ERRMSG43, SCI_ERRMSG49, SCI_ERRMSG5, SCI_ERRMSG57, SCI_ERRMSG6, SCI_ERRMSG60, SCI_ERRMSG61, SCI_ERRMSG64, SCI_ERRMSG66, SCI_ERRMSG67, SCI_ERRMSG69, SCI_ERRMSG7, SCI_ERRMSG70, SCI_ERRMSG71, SCI_ERRMSG73, SCI_ERRMSG74, SCI_ERRMSG75, SCI_ERRMSG8, SCI_ERRMSG85, SCI_ERRMSG86, SCI_ERRMSG87, SCI_ERRMSG88, and SCI_ERRMSG9.

00025 {
00026         int i=0;
00027     static integer lunit=0;
00028         static integer ll=0;
00029     static integer io=0;
00030     
00031     ll = C2F(iop).lct[4];
00032     lunit = C2F(iop).wte;
00033     *errtyp = 0;
00034 
00035     C2F(linestore)(&i);
00036     C2F(funnamestore)(" ", &i,strlen(" "));
00037     C2F(freemsgtable)();
00038     C2F(errstore)(n);
00039     
00040     switch ((int)*n) 
00041     {
00042                         case 1:
00043                         {
00044                                 MSGOUT(SCI_ERRMSG1);
00045                         }
00046                         break;
00047                         case 2:
00048                         {
00049                                 MSGOUT(SCI_ERRMSG2);
00050                         *errtyp = 1;
00051                         }
00052                         break;
00053                         case 3:
00054                         {
00055                                 MSGOUT(SCI_ERRMSG3);
00056                         *errtyp = 1;
00057                         }
00058                         break;
00059                         case 4:
00060                         {
00061                                 char *Str=NULL;
00062                                 C2F(cvname)(&C2F(recu).ids[(C2F(recu).pt + 1) * 6 - 6], C2F(cha1).buf, &i, 4096L);
00063                                 Str=(char*)MALLOC( sizeof(char)*( strlen(SCI_ERRMSG4)+1+strlen(C2F(cha1).buf) ) );
00064                                 sprintf(Str,SCI_ERRMSG4,C2F(cha1).buf);
00065                                 MSGOUT(Str);
00066                                 FREE(Str);
00067                         }
00068                         break;
00069                         case 5:
00070                         {
00071                                 MSGOUT(SCI_ERRMSG5);
00072                         }
00073                         break;
00074                         case 6:
00075                         {
00076                                 MSGOUT(SCI_ERRMSG6);
00077                         }
00078                         break;
00079                         case 7:
00080                         {
00081                                 MSGOUT(SCI_ERRMSG7);
00082                         }
00083                         break;
00084                         case 8:
00085                         {
00086                                 MSGOUT(SCI_ERRMSG8);
00087                         }
00088                         break;
00089                         case 9:
00090                         {
00091                                 MSGOUT(SCI_ERRMSG9);
00092                         }
00093                         break;
00094                         case 10:
00095                         {
00096                                 MSGOUT(SCI_ERRMSG10);
00097                         }
00098                         break;
00099                         case 11:
00100                         {
00101                                 MSGOUT(SCI_ERRMSG11);
00102                         }
00103                         break;
00104                         case 12:
00105                         {
00106                                 MSGOUT(SCI_ERRMSG12);
00107                         }
00108                         break;
00109                         case 13:
00110                         {
00111                                 MSGOUT(SCI_ERRMSG13);
00112                         }
00113                         break;
00114                         case 14:
00115                         {
00116                                 MSGOUT(SCI_ERRMSG14);
00117                         }
00118                         break;
00119                         case 15:
00120                         {
00121                                 MSGOUT(SCI_ERRMSG15);
00122                         }
00123                         break;
00124                         case 16:
00125                         {
00126                                 MSGOUT(SCI_ERRMSG16);
00127                                 *errtyp = 1;
00128                         }
00129                         break;
00130                         case 17:
00131                         {
00132                         }
00133                         break;
00134                         case 18:
00135                         {
00136                                 MSGOUT(SCI_ERRMSG18);
00137                         }
00138                         break;
00139                         case 19:
00140                         {
00141                                 MSGOUT(SCI_ERRMSG19);
00142                         }
00143                         break;
00144                         case 20:
00145                         {
00146                         }
00147                         break;
00148                         case 21:
00149                         {
00150                                 MSGOUT(SCI_ERRMSG21);
00151                         }
00152                         break;
00153                         case 22:
00154                         {
00155                                 MSGOUT(SCI_ERRMSG22);
00156                         }
00157                         break;
00158                         case 23:
00159                         {
00160                                 MSGOUT(SCI_ERRMSG23);
00161                         }
00162                         break;
00163                         case 24:
00164                         {
00165                                 MSGOUT(SCI_ERRMSG24);
00166                         }
00167                         break;
00168                         case 25:
00169                         {
00170                         }
00171                         break;
00172                         case 26:
00173                         {
00174                         }
00175                         break;
00176                         case 27:
00177                         {
00178                                 MSGOUT(SCI_ERRMSG27);
00179                         }
00180                         break;
00181                         case 28:
00182                         {
00183                                 MSGOUT(SCI_ERRMSG28);
00184                         }
00185                         break;
00186                         case 29:
00187                         {
00188                                 MSGOUT(SCI_ERRMSG29);
00189                         }
00190                         break;
00191                         case 30:
00192                         {
00193                                 MSGOUT(SCI_ERRMSG30);
00194                         }
00195                         break;
00196                         case 31:
00197                         {
00198                         }
00199                         break;
00200                         case 32:
00201                         {
00202                                 MSGOUT(SCI_ERRMSG32);
00203                         }
00204                         break;
00205                         case 33:
00206                         {
00207                                 MSGOUT(SCI_ERRMSG33);
00208                         }
00209                         break;
00210                         case 34:
00211                         {
00212 
00213                         }
00214                         break;
00215                         case 35:
00216                         {
00217                         }
00218                         break;
00219                         case 36:
00220                         {
00221                         }
00222                         break;
00223                         case 37:
00224                         {
00225                         }
00226                         break;
00227                         case 38:
00228                         {
00229                                 MSGOUT(SCI_ERRMSG38);
00230                         }
00231                         break;
00232                         case 39:
00233                         {
00234                                 MSGOUT(SCI_ERRMSG39);
00235                         }
00236                         break;
00237                         case 40:
00238                         {
00239                         }
00240                         break;
00241                         case 41:
00242                         {
00243                                 MSGOUT(SCI_ERRMSG41);
00244                         }
00245                         break;
00246                         case 42:
00247                         {
00248                                 MSGOUT(SCI_ERRMSG42);
00249                         }
00250                         break;
00251                         case 43:
00252                         {
00253                                 MSGOUT(SCI_ERRMSG43);
00254                         }
00255                         break;
00256                         case 44:
00257                         {
00258                         }
00259                         break;
00260                         case 45:
00261                         {
00262                         }
00263                         break;
00264                         case 46:
00265                         {
00266                         }
00267                         break;
00268                         case 47:
00269                         {
00270                         }
00271                         break;
00272                         case 48:
00273                         {
00274                         }
00275                         break;
00276                         case 49:
00277                         {
00278                                 MSGOUT(SCI_ERRMSG49);
00279                         }
00280                         break;
00281                         case 50:
00282                         {
00283                         }
00284                         break;
00285                         case 51:
00286                         {
00287                                 /* Pas de message */
00288                         }
00289                         break;
00290                         case 52:
00291                         {
00292                         }
00293                         break;
00294                         case 53:
00295                         {
00296                         }
00297                         break;
00298                         case 54:
00299                         {
00300                         }
00301                         break;
00302                         case 55:
00303                         {
00304                         }
00305                         break;
00306                         case 56:
00307                         {
00308                         }
00309                         break;
00310                         case 57:
00311                         {
00312                                 MSGOUT(SCI_ERRMSG57);
00313                         }
00314                         break;
00315                         case 58:
00316                         {
00317                         }
00318                         break;
00319                         case 59:
00320                         {
00321                         }
00322                         break;
00323                         case 60:
00324                         {
00325                                 MSGOUT(SCI_ERRMSG60);
00326                         }
00327                         break;
00328                         case 61:
00329                         {
00330                                 MSGOUT(SCI_ERRMSG61);
00331                         }
00332                         break;
00333                         case 62:
00334                         {
00335                         }
00336                         break;
00337                         case 63:
00338                         {
00339                         }
00340                         break;
00341                         case 64:
00342                         {
00343                                 MSGOUT(SCI_ERRMSG64);
00344                         }
00345                         break;
00346                         case 65:
00347                         {
00348                         }
00349                         break;
00350                         case 66:
00351                         {
00352                                 MSGOUT(SCI_ERRMSG66);
00353                         }
00354                         break;
00355                         case 67:
00356                         {
00357                                 MSGOUT(SCI_ERRMSG67);
00358                         }
00359                         break;
00360                         case 68:
00361                         {
00362                         }
00363                         break;
00364                         case 69:
00365                         {
00366                                 MSGOUT(SCI_ERRMSG69);
00367                         }
00368                         break;
00369                         case 70:
00370                         {
00371                                 MSGOUT(SCI_ERRMSG70);
00372                         }
00373                         break;
00374                         case 71:
00375                         {
00376                                 MSGOUT(SCI_ERRMSG71);
00377                         }
00378                         break;
00379                         case 72:
00380                         {
00381                         }
00382                         break;
00383                         case 73:
00384                         {
00385                                 MSGOUT(SCI_ERRMSG73);
00386                         }
00387                         break;
00388                         case 74:
00389                         {
00390                                 MSGOUT(SCI_ERRMSG74);
00391                         }
00392                         break;
00393                         case 75:
00394                         {
00395                                 MSGOUT(SCI_ERRMSG75);
00396                         }
00397                         break;
00398                         case 76:
00399                         {
00400                         }
00401                         break;
00402                         case 77:
00403                         {
00404                         }
00405                         break;
00406                         case 78:
00407                         {
00408                         }
00409                         break;
00410                         case 79:
00411                         {
00412                                 /* pas de message */
00413                         }
00414                         break;
00415                         case 80:
00416                         {
00417                         }
00418                         break;
00419                         case 81:
00420                         {
00421                         }
00422                         break;
00423                         case 82:
00424                         {
00425                         }
00426                         break;
00427                         case 83:
00428                         {
00429                         }
00430                         break;
00431                         case 84:
00432                         {
00433                         }
00434                         break;
00435                         case 85:
00436                         {
00437                                 MSGOUT(SCI_ERRMSG85);
00438                         }
00439                         break;
00440                         case 86:
00441                         {
00442                                 MSGOUT(SCI_ERRMSG86);
00443                         }
00444                         break;
00445                         case 87:
00446                         {
00447                                 MSGOUT(SCI_ERRMSG87);
00448                         }
00449                         break;
00450                         case 88:
00451                         {
00452                                 MSGOUT(SCI_ERRMSG88);
00453                         }
00454                         break;
00455                         case 89:
00456                         {
00457                         }
00458                         break;
00459                         case 90:
00460                         {
00461                         }
00462                         break;
00463                         case 91:
00464                         {
00465                         }
00466                         break;
00467                         case 92:
00468                         {
00469                         }
00470                         break;
00471                         case 93:
00472                         {
00473                         }
00474                         break;
00475                         case 94:
00476                         {
00477                         }
00478                         break;
00479                         case 95:
00480                         {
00481                         }
00482                         break;
00483                         case 96:
00484                         {
00485                         }
00486                         break;
00487                         case 97:
00488                         {
00489                         }
00490                         break;
00491                         case 98:
00492                         {
00493                         }
00494                         break;
00495                         case 99:
00496                         {
00497                         }
00498                         break;
00499                         case 100:
00500                         {
00501                         }
00502                         break;
00503                         case 101:
00504                         {
00505                         }
00506                         break;
00507                         case 102:
00508                         {
00509                         }
00510                         break;
00511                         case 103:
00512                         {
00513                         }
00514                         break;
00515                         case 104:
00516                         {
00517                         }
00518                         break;
00519                         case 105:
00520                         {
00521                                 MSGOUT(SCI_ERRMSG105);
00522                         }
00523                         break;
00524                         case 106:
00525                         {
00526                                 MSGOUT(SCI_ERRMSG106);
00527                         }
00528                         break;
00529                         case 107:
00530                         {
00531                         }
00532                         break;
00533                         case 108:
00534                         {
00535                         }
00536                         break;
00537                         case 109:
00538                         {
00539                                 MSGOUT(SCI_ERRMSG109);
00540                         }
00541                         break;
00542                         case 110:
00543                         {
00544                         }
00545                         break;
00546                         case 111:
00547                         {
00548                         }
00549                         break;
00550                         case 112:
00551                         {
00552                                 MSGOUT(SCI_ERRMSG112);
00553                         }
00554                         break;
00555                         case 113:
00556                         {
00557                                 MSGOUT(SCI_ERRMSG113);
00558                         }
00559                         break;
00560                         case 114:
00561                         {
00562                                 MSGOUT(SCI_ERRMSG114);
00563                         }
00564                         break;
00565                         case 115:
00566                         {
00567                         }
00568                         break;
00569                         case 116:
00570                         {
00571                         }
00572                         break;
00573                         case 117:
00574                         {
00575                         }
00576                         break;
00577                         case 118:
00578                         {
00579                         }
00580                         break;
00581                         case 119:
00582                         {
00583                                 /* pas de message */
00584                         }
00585                         break;
00586                         case 120:
00587                         {
00588                         }
00589                         break;
00590                         case 121:
00591                         {
00592                         }
00593                         break;
00594                         case 122:
00595                         {
00596                         }
00597                         break;
00598                         case 123:
00599                         {
00600                                 MSGOUT(SCI_ERRMSG123);
00601                         }
00602                         break;
00603                         case 124:
00604                         {
00605                                 /* pas de message */
00606                         }
00607                         break;
00608                         case 125:
00609                         {
00610                         }
00611                         break;
00612                         case 126:
00613                         {
00614                                 MSGOUT(SCI_ERRMSG126);
00615                         }
00616                         break;
00617                         case 127:
00618                         {
00619                                 MSGOUT(SCI_ERRMSG127);
00620                         }
00621                         break;
00622                         case 128:
00623                         {
00624                                 MSGOUT(SCI_ERRMSG128);
00625                         }
00626                         break;
00627                         case 129:
00628                         {
00629                                 MSGOUT(SCI_ERRMSG129);
00630                         }
00631                         break;
00632                         case 130:
00633                         {
00634                                 MSGOUT(SCI_ERRMSG130);
00635                         }
00636                         break;
00637                         case 131:
00638                         {
00639                                 MSGOUT(SCI_ERRMSG131);
00640                         }
00641                         break;
00642                         case 132:
00643                         {
00644                                 MSGOUT(SCI_ERRMSG132);
00645                         }
00646                         break;
00647                         case 133:
00648                         {
00649                                 MSGOUT(SCI_ERRMSG133);
00650                         }
00651                         break;
00652                         case 134:
00653                         {
00654                                 MSGOUT(SCI_ERRMSG134);
00655                         }
00656                         break;
00657                         case 135:
00658                         {
00659                                 MSGOUT(SCI_ERRMSG135);
00660                         }
00661                         break;
00662                         case 136:
00663                         {
00664                                 MSGOUT(SCI_ERRMSG136);
00665                         }
00666                         break;
00667                         case 137:
00668                         {
00669                                 MSGOUT(SCI_ERRMSG137);
00670                         }
00671                         break;
00672                         case 138:
00673                         {
00674                                 MSGOUT(SCI_ERRMSG138);
00675                         }
00676                         break;
00677                         case 139:
00678                         {
00679                                 MSGOUT(SCI_ERRMSG139);
00680                         }
00681                         break;
00682                         case 140:
00683                         {/* pas de message */
00684                         }
00685                         break;
00686                         case 141:
00687                         {
00688                         }
00689                         break;
00690                         case 142:
00691                         {
00692                         }
00693                         break;
00694                         case 143:
00695                         {
00696                                 MSGOUT(SCI_ERRMSG143);
00697                         }
00698                         break;
00699                         case 144:
00700                         {
00701                         }
00702                         break;
00703                         /*
00704                         messages from 201 to 203 and 205 to 214 are no more used by error 
00705                         (see Scierror  in stack1.c)
00706                         */
00707                         case 200:
00708                         {
00709                                 /* pas de message */
00710                         }
00711                         break;
00712                         case 201:
00713                         {
00714                         }
00715                         break;
00716                         case 202:
00717                         {
00718                         }
00719                         break;
00720                         case 203:
00721                         {
00722                         }
00723                         break;
00724                         case 204:
00725                         {
00726                         }
00727                         break;
00728                         case 205:
00729                         {
00730                         }
00731                         break;
00732                         case 206:
00733                         {
00734                         }
00735                         break;
00736                         case 207:
00737                         {
00738                         }
00739                         break;
00740                         case 208:
00741                         {
00742                         }
00743                         break;
00744                         case 209:
00745                         {
00746                         }
00747                         break;
00748                         case 210:
00749                         {
00750                         }
00751                         break;
00752                         case 211:
00753                         {
00754                         }
00755                         break;
00756                         case 212:
00757                         {
00758                         }
00759                         break;
00760                         case 213:
00761                         {
00762                         }
00763                         break;
00764                         case 214:
00765                         {
00766                         }
00767                         break;
00768                         case 215:
00769                         {
00770                         }
00771                         break;
00772                         case 216:
00773                         {
00774                         }
00775                         break;
00776                         case 217:
00777                         {
00778                         }
00779                         break;
00780                         case 218:
00781                         {
00782                         }
00783                         break;
00784                         case 219:
00785                         {
00786                         }
00787                         break;
00788                         case 220:
00789                         {
00790                                 MSGOUT(SCI_ERRMSG220);
00791                         }
00792                         break;
00793                         case 221:
00794                         {
00795                         }
00796                         break;
00797                         case 222:
00798                         {
00799                                 MSGOUT(SCI_ERRMSG222);
00800                         }
00801                         break;
00802                         case 223:
00803                         {
00804                         }
00805                         break;
00806                         case 224:
00807                         {
00808                                 MSGOUT(SCI_ERRMSG224);
00809                         }
00810                         break;
00811                         case 225:
00812                         {
00813                                 MSGOUT(SCI_ERRMSG225);
00814                         }
00815                         break;
00816                         case 226:
00817                         {
00818                                 MSGOUT(SCI_ERRMSG226);
00819                         }
00820                         break;
00821                         case 227:
00822                         {
00823                                 MSGOUT(SCI_ERRMSG227);
00824                         }
00825                         break;
00826                         case 228:
00827                         {
00828                         }
00829                         break;
00830                         case 229:
00831                         {
00832                                 /* pas de message */
00833                         }
00834                         break;
00835                         case 230:
00836                         {
00837                                 MSGOUT(SCI_ERRMSG230);
00838                         }
00839                         break;
00840                         case 231:
00841                         {
00842                                 MSGOUT(SCI_ERRMSG231);
00843                         }
00844                         break;
00845                         case 232:
00846                         {
00847                                 MSGOUT(SCI_ERRMSG232);
00848                         }
00849                         break;
00850                         case 233:
00851                         {
00852                         }
00853                         break;
00854                         case 234:
00855                         {
00856                                 MSGOUT(SCI_ERRMSG234);
00857                         }
00858                         break;
00859                         case 235:
00860                         {
00861                                 MSGOUT(SCI_ERRMSG235);
00862                         }
00863                         break;
00864                         case 236:
00865                         {
00866                                 MSGOUT(SCI_ERRMSG236);
00867                         }
00868                         break;
00869                         case 237:
00870                         {
00871                         }
00872                         break;
00873                         case 238:
00874                         {
00875                                 MSGOUT(SCI_ERRMSG238);
00876                         }
00877                         break;
00878                         case 239:
00879                         {
00880                         }
00881                         break;
00882                         case 240:
00883                         {
00884                         }
00885                         break;
00886                         case 241:
00887                         {
00888                         }
00889                         break;
00890                         case 242:
00891                         {
00892                         }
00893                         break;
00894                         case 243:
00895                         {
00896                                 MSGOUT(SCI_ERRMSG243);
00897                         }
00898                         break;
00899                         case 244:
00900                         {
00901                                 MSGOUT(SCI_ERRMSG244);
00902                         }
00903                         break;
00904                         case 245:
00905                         {
00906                         }
00907                         break;
00908                         case 246:
00909                         {
00910                         }
00911                         break;
00912                         case 247:
00913                         {
00914                                 /* pas de message */
00915                         }
00916                         break;
00917                         case 248:
00918                         {
00919                         }
00920                         break;
00921                         case 249:
00922                         {
00923                         }
00924                         break;
00925                         case 250:
00926                         {
00927                         }
00928                         break;
00929                         case 251:
00930                         {
00931                                 MSGOUT(SCI_ERRMSG251);
00932                         }
00933                         break;
00934                         case 252:
00935                         {
00936                                 MSGOUT(SCI_ERRMSG252);
00937                         }
00938                         break;
00939                         case 253:
00940                         {
00941                                 MSGOUT(SCI_ERRMSG253);
00942                         }
00943                         break;
00944                         case 254:
00945                         {
00946                                 MSGOUT(SCI_ERRMSG254);
00947                         }
00948                         break;
00949                         case 255:
00950                         {
00951                                 MSGOUT(SCI_ERRMSG255);
00952                         }
00953                         break;
00954                         case 256:
00955                         {
00956                                 MSGOUT(SCI_ERRMSG256);
00957                         }
00958                         break;
00959                         case 257:
00960                         {
00961                                 MSGOUT(SCI_ERRMSG257);
00962                         }
00963                         break;
00964                         case 258:
00965                         {
00966                                 MSGOUT(SCI_ERRMSG258);
00967                         }
00968                         break;
00969                         case 259:
00970                         {
00971                                 MSGOUT(SCI_ERRMSG259);
00972                         }
00973                         break;
00974                         case 260:
00975                         {
00976                                 MSGOUT(SCI_ERRMSG260);
00977                         }
00978                         break;
00979                         case 261:
00980                         {
00981                                 MSGOUT(SCI_ERRMSG261);
00982                         }
00983                         break;
00984                         case 262:
00985                         {
00986                         }
00987                         break;
00988                         case 263:
00989                         {
00990                         }
00991                         break;
00992                         case 264:
00993                         {
00994                         }
00995                         break;
00996                         case 265:
00997                         {
00998                                 MSGOUT(SCI_ERRMSG265);
00999                         }
01000                         break;
01001                         case 266:
01002                         {
01003                                 MSGOUT(SCI_ERRMSG266);
01004                         }
01005                         break;
01006                         case 267:
01007                         {
01008                                 MSGOUT(SCI_ERRMSG267);
01009                         }
01010                         break;
01011                         case 268:
01012                         {
01013                         }
01014                         break;
01015                         case 269:
01016                         {
01017                         }
01018                         break;
01019                         case 270:
01020                         {
01021                         }
01022                         break;
01023                         case 271:
01024                         {
01025                         }
01026                         break;
01027                         case 272:
01028                         {
01029                                 MSGOUT(SCI_ERRMSG272);
01030                         }
01031                         break;
01032                         case 273:
01033                         {
01034                         }
01035                         break;
01036                         case 274:
01037                         {
01038                         }
01039                         break;
01040                         case 275:
01041                         {
01042                                 MSGOUT(SCI_ERRMSG275);
01043                         }
01044                         break;
01045                         case 276:
01046                         {
01047                                 MSGOUT(SCI_ERRMSG276);
01048                         }
01049                         break;
01050                         case 277:
01051                         {
01052                                 MSGOUT(SCI_ERRMSG277);
01053                         }
01054                         break;
01055                         case 278:
01056                         {
01057                                 /* pas de message */
01058                         }
01059                         break;
01060                         case 279:
01061                         {
01062                                 /* pas de message */
01063                         }
01064                         break;
01065                         case 280:
01066                         {
01067                                 /* pas de message */
01068                         }
01069                         break;
01070                         
01071                         default:
01072                         {
01073                                 integer bufl;
01074                                 /* message d'erreur soft */
01075                                 /* Bug 1422 corrected - Francois VOGEL June 2006 */
01076                                 bufl = 1;
01077                                 while(*(unsigned char *)&C2F(cha1).buf[bufl - 1] != '\0' && bufl < 80) 
01078                                 {
01079                                         ++bufl;
01080                                 }
01081                                 --bufl;
01082                                 MSGOUT(C2F(cha1).buf);
01083                         }
01084                         break;
01085     }
01086                 return 0; 
01087 }

Here is the call graph for this function:

int C2F() errstore (  ) 

Referenced by errmsg(), and Scierror_internal().

Here is the caller graph for this function:

int C2F() freemsgtable (  ) 

Definition at line 52 of file msgstore.c.

Referenced by errmsg(), lasterror(), and Scierror_internal().

00053 {
00054   int k;
00055   for (k=0 ; k< msg_line_counter ; k++)
00056     FREE(msg_buff[k]);
00057   msg_line_counter=0;
00058   err_n = 0;
00059 }

Here is the caller graph for this function:

int C2F() funnamestore (  ) 

Referenced by errmsg().

Here is the caller graph for this function:

int C2F() inffic (  ) 

Referenced by CreateButtons().

Here is the caller graph for this function:

int C2F() linestore (  ) 

Referenced by errmsg().

Here is the caller graph for this function:

int C2F() msgout (  ) 

int C2F() prntid (  ) 

int C2F() showstack (  ) 


Generated on Sun Mar 4 15:14:50 2007 for Scilab [trunk] by  doxygen 1.5.1