Annotation of freem/src/merr.c, revision 1.4
1.1 snw 1: /*
1.4 ! snw 2: * $Id: merr.c,v 1.3 2025/03/09 19:50:47 snw Exp $
1.1 snw 3: * stuff for handling program bogosity
4: *
5: *
1.2 snw 6: * Author: Serena Willis <snw@coherent-logic.com>
1.1 snw 7: * Copyright (C) 1998 MUG Deutschland
1.3 snw 8: * Copyright (C) 2020, 2025 Coherent Logic Development LLC
1.1 snw 9: *
10: *
11: * This file is part of FreeM.
12: *
13: * FreeM is free software: you can redistribute it and/or modify
14: * it under the terms of the GNU Affero Public License as published by
15: * the Free Software Foundation, either version 3 of the License, or
16: * (at your option) any later version.
17: *
18: * FreeM is distributed in the hope that it will be useful,
19: * but WITHOUT ANY WARRANTY; without even the implied warranty of
20: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21: * GNU Affero Public License for more details.
22: *
23: * You should have received a copy of the GNU Affero Public License
24: * along with FreeM. If not, see <https://www.gnu.org/licenses/>.
25: *
1.4 ! snw 26: * $Log: merr.c,v $
! 27: * Revision 1.3 2025/03/09 19:50:47 snw
! 28: * Second phase of REUSE compliance and header reformat
! 29: *
1.3 snw 30: *
31: * SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
32: * SPDX-License-Identifier: AGPL-3.0-or-later
1.1 snw 33: **/
34:
35: #include <string.h>
36: #include <stdlib.h>
37:
38: #include "mpsdef.h"
39: #include "merr.h"
40: #include "jobtab.h"
41:
42: merr_stackent merr_stack[NESTLEVLS + 1];
43: char etrap[256];
44: char ecode[256];
45: char user_ecode[256];
46: int estack;
47: int etrap_lvl = 0;
48: int merr_topstk = 0;
49:
50: typedef struct err_lut {
51: int ecode;
52: const char *canonical_name;
53: } err_lut;
54:
55: err_lut errtab[] = {
56: {0, "ZOK"},
57: {1, "ZINRPT"},
58: {2, "ZBKERR"},
59: {3, "ZNOSTAND"},
60: {4, "ZUNDEF"},
61: {5, "ZLBLUNDEF"},
62: {6, "ZMISSOPD"},
63: {7, "ZMISSOP"},
64: {8, "ZILLOP"},
65: {9, "ZQUOTER"},
66: {10, "ZCOMMAER"},
67: {11, "ZASSIGNER"},
68: {12, "ZARGER"},
69: {13, "ZSPACER"},
70: {14, "ZBRAER"},
71: {15, "ZLVLERR"},
72: {16, "ZDIVER"},
73: {17, "ZILLFUN"},
74: {18, "ZFUNARG"},
75: {19, "ZZTERR"},
76: {20, "ZNEXTER"},
77: {21, "ZSELER"},
78: {22, "ZCMMND"},
79: {23, "ZARGLIST"},
80: {24, "ZINVEXPR"},
81: {25, "ZINVREF"},
82: {26, "ZMXSTR"},
83: {27, "ZTOOPARA"},
84: {28, "ZNOPEN"},
85: {29, "ZNODEVICE"},
86: {30, "ZPROTECT"},
87: {31, "ZGLOBER"},
88: {32, "ZFILERR"},
89: {33, "ZPGMOV"},
90: {34, "ZSTKOV"},
91: {35, "ZSTORE"},
92: {36, "ZNOREAD"},
93: {37, "ZNOWRITE"},
94: {38, "ZNOPGM"},
95: {39, "ZNAKED"},
96: {40, "ZSBSCR"},
97: {41, "ZISYNTX"},
98: {42, "ZDBDGD"},
99: {43, "ZKILLER"},
100: {44, "ZHUPER"},
101: {45, "ZMXNUM"},
102: {46, "ZNOVAL"},
103: {47, "ZTYPEMISMATCH"},
104: {48, "ZMEMOV"},
105: {49, "ZNAMERES"},
106: {50, "ZSCKCREAT"},
107: {51, "ZSCKIFAM"},
108: {52, "ZSCKITYP"},
109: {53, "ZSCKIPRT"},
110: {54, "ZSCKCERR"},
111: {55, "ZSCKAERR"},
112: {56, "ZSCKACON"},
113: {57, "ZSCKNCON"},
114: {58, "ZSCKEOPT"},
115: {59, "ZSCKERCV"},
116: {60, "ZSCKESND"},
117: {61, "ZNORPI"},
118: {62, "ZCREDEF"},
119: {63, "ZCMODIFY"},
120: {64, "ZFILEXWR"},
121: {65, "ZINEWMUL"},
122: {66, "ZINVHORO"},
123: {67, "ZTYPMISMATCH"},
124: {68, "ZINVTYPE"},
125: {69, "ZINVLIBOPT"},
126: {80, "ZECODEINV"},
127: {81, "ZASSERT"},
128: {82, "ZUSERERR"},
129: {83, "ZOBJFLDACCV"},
130: {84, "ZOBJCONFLICT"},
131: {85, "ZOBJPRIVOVFL"},
132: {86, "ZOBJACINVALID"},
133: {128, "ZSYNTERR"},
134: {140, "M1"},
135: {141, "M2"},
136: {142, "M3"},
137: {143, "M4"},
138: {144, "M5"},
139: {145, "M6"},
140: {146, "M7"},
141: {147, "M8"},
142: {148, "M9"},
143: {149, "M10"},
144: {150, "M11"},
145: {151, "M12"},
146: {152, "M13"},
147: {153, "M14"},
148: {154, "M15"},
149: {155, "M16"},
150: {156, "M17"},
151: {157, "M18"},
152: {158, "M19"},
153: {159, "M20"},
154: {160, "M21"},
155: {161, "M22"},
156: {162, "M23"},
157: {163, "M24"},
158: {164, "M25"},
159: {165, "M26"},
160: {166, "M27"},
161: {167, "M28"},
162: {168, "M29"},
163: {169, "M30"},
164: {170, "M31"},
165: {171, "M32"},
166: {172, "M33"},
167: {173, "M34"},
168: {174, "M35"},
169: {175, "M36"},
170: {176, "M37"},
171: {177, "M38"},
172: {178, "M39"},
173: {179, "M40"},
174: {180, "M41"},
175: {181, "M42"},
176: {182, "M43"},
177: {183, "M44"},
178: {184, "M45"},
179: {185, "M46"},
180: {186, "M47"},
181: {187, "M48"},
182: {188, "M49"},
183: {189, "M50"},
184: {190, "M51"},
185: {191, "M52"},
186: {192, "M53"},
187: {193, "M54"},
188: {194, "M55"},
189: {195, "M56"},
190: {196, "M57"},
191: {197, "M58"},
192: {198, "M59"},
193: {199, "M60"},
194: {214, "M75"},
195: {240, "M101"},
196: {241, "M102"},
197: {242, "M103"},
198: {243, "M104"},
199: {254, "ZASYNC"},
200: {255, "ZCTRLB"},
201: {-1, NULL}
202: };
203:
204: inline int merr_raise(int num)
205: {
206:
207: if (merr_in_break ()) {
208: ierr = num - CTRLB;
209: }
210: else {
211: ierr = num;
212: }
213:
214: if (num != OK) {
215: merr_set_ecode_ierr ();
216:
217: stcpy (merr_stack[nstx].MCODE, code);
218: stcpy (merr_stack[nstx].ECODE, ecode);
219:
220: if (direct_mode == 1 && nstx == 0) {
221: stcpy (merr_stack[nstx].PLACE, "@\201\0");
222: }
223: else {
224: if (!rtn_get_offset (merr_stack[nstx].PLACE)) {
225: stcpy (merr_stack[nstx].PLACE, "???\201");
226: }
227: }
228:
229: if (nstx > merr_topstk) merr_topstk = nstx;
230: }
231:
232: return ierr;
233: }
234:
235: inline int merr(void)
236: {
237: return ierr < OK ? ierr + CTRLB : ierr;
238: }
239:
240: short merr_in_break(void)
241: {
242: if (ierr < OK) {
243: return TRUE;
244: }
245: else {
246: return FALSE;
247: }
248: }
249:
250: void merr_set_break(void)
251: {
252: if (!merr_in_break ()) {
253: ierr = ierr - CTRLB;
254: }
255: }
256:
257: void merr_clear_break(void)
258: {
259: if (merr_in_break ()) {
260: ierr = ierr + CTRLB;
261: }
262: }
263:
264: int merr_num_to_code (int num, char *code)
265: {
266:
267: err_lut *p;
268:
269: for (p = errtab; p->canonical_name != NULL; ++p) {
270:
271: if (p->ecode == num) {
272: strcpy (code, p->canonical_name);
273: return 1;
274: }
275:
276: }
277:
278: return -1;
279:
280: }
281:
282: int merr_code_to_num (char *code)
283: {
284:
285: err_lut *p;
286:
287: for (p = errtab; p->canonical_name != NULL; ++p) {
288:
289: if (strcmp (p->canonical_name, code) == 0) {
290: return p->ecode;
291: }
292:
293: }
294:
295: return -1;
296:
297: }
298:
299: void merr_set_ecode_ierr (void)
300: {
301: char *cod;
302: char *t;
303:
304: cod = (char *) malloc (256 * sizeof (char));
305: NULLPTRCHK(cod,"merr_set_ecode_ierr");
306:
307: t = (char *) malloc (256 * sizeof (char));
308: NULLPTRCHK(t,"merr_set_ecode_ierr");
309:
310: if ((merr_num_to_code (merr (), cod)) == -1) goto done;
311:
312: snprintf (t, 255, ",%s,\201", cod);
313: merr_set_ecode (t);
314:
315: job_set_ecode (pid, cod);
316:
317: done:
318:
319: free (cod);
320: free (t);
321: return;
322:
323: }
324:
325: int merr_set_ecode (char *t_code)
326: {
327: int ec;
328: char *tmp;
329:
330: if (t_code[0] == '\201') {
331: stcpy (ecode, "\201");
332: return 0;
333: }
334:
335: if (t_code[1] != 'M' && t_code[1] != 'Z' && t_code[1] != 'U') {
336: return M101;
337: }
338:
339: stcpy (ecode, t_code);
340:
341: if (stcmp (t_code, "") == 0) {
342: merr_clear ();
343: stcpy (t_code, ",ZOK,");
344: stcpy (user_ecode, t_code);
345: }
346:
347: tmp = strtok (t_code, ",");
348:
349: /* caller may set ierr with return value */
350: if (ecode[1] == 'U') {
351: stcpy (user_ecode, ecode);
352: return USERERR;
353: }
354: else {
355: ec = merr_code_to_num (tmp);
356: return (ec);
357: }
358: }
359:
360: void merr_dump (int num, char *rtn, char *nsn, char *tcod, int tpos)
361: {
362: char *tbuf;
363: char *dbuf;
364: char *nem;
365: char *nrt;
366: char *real_ecode;
367: err_lut *p;
368:
369: tbuf = (char *) malloc (STRLEN * sizeof (char));
370: NULLPTRCHK(tbuf,"merr_dump");
371:
372: dbuf = (char *) malloc (STRLEN * sizeof (char));
373: NULLPTRCHK(dbuf,"merr_dump");
374:
375: nem = (char *) malloc (STRLEN * sizeof (char));
376: NULLPTRCHK(nem,"merr_dump");
377:
378: nrt = (char *) malloc (STRLEN * sizeof (char));
379: NULLPTRCHK(nrt,"merr_dump");
380:
381: real_ecode = (char *) malloc (STRLEN * sizeof (char));
382: NULLPTRCHK(real_ecode,"merr_dump");
383:
384: stcpy (nrt, rtn);
385: stcnv_m2c (nrt);
386:
387: stcpy (nem, errmes[num]);
388: stcnv_m2c (nem);
389:
390: for (p = errtab; p->canonical_name != NULL; ++p) {
391:
392: if (p->ecode == num) {
393:
394: if (strcmp (p->canonical_name, "ZUSERERR") == 0) {
395: stcpy (real_ecode, &user_ecode[1]);
396: stcnv_m2c (real_ecode);
397: real_ecode [strlen (real_ecode) - 1] = NUL;
398:
1.4 ! snw 399: snprintf (tbuf, STRLEN, "^$JOB\202%d\202USER_ERRORS\202%s\201", pid, &user_ecode[1]);
1.1 snw 400: tbuf [stlen (tbuf) - 1] = '\201';
401:
402: global (get_sym, tbuf, dbuf);
403:
404: if (merr () == OK) {
405: stcpy (nem, dbuf);
406: stcnv_m2c (nem);
407: }
408: else {
409: merr_clear ();
410: }
411:
412: }
413: else {
414: strcpy (real_ecode, p->canonical_name);
415: }
416:
1.4 ! snw 417:
! 418:
1.1 snw 419: if (!stlen (err_suppl)) {
1.4 ! snw 420: snprintf (tbuf, STRLEN, "\r\n>> Error %s: %s in %s.%s::%s [$STACK = %d]\r\n\201", real_ecode, nem, shm_env, nsn, nrt, nstx);
1.1 snw 421: }
422: else {
423: stcnv_m2c (err_suppl);
1.4 ! snw 424: snprintf (tbuf, STRLEN, "\r\n>> Error %s: %s (%s) in %s::%s [$STACK = %d]\r\n\201", real_ecode, nem, err_suppl, nsn, nrt, nstx);
1.1 snw 425: err_suppl[0] = EOL;
426: }
427: write_m (tbuf);
428: write_m (">> \201");
429: write_m (tcod);
430: write_m ("\r\n\201");
431: write_t (tpos);
432: write_m ("^\201");
433:
434: goto done;
435: }
436:
437: }
438:
439:
440: done:
441:
442: free (tbuf);
443: free (dbuf);
444: free (nem);
445: free (nrt);
446: free (real_ecode);
447:
448: return;
449: }
450:
451:
452: void merr_set_iochan_err(int channel, short frm_err, char *err_text)
453: {
454: if (channel > MAXDEV || channel < 0) {
455: merr_raise (ARGLIST);
456: return;
457: }
458:
459: devstat[channel].mdc_err = 1;
460: devstat[channel].frm_err = frm_err;
461:
462: strncpy (devstat[channel].err_txt, err_text, 79);
463:
464: return;
465: }
466:
467: void merr_clear_iochan_err(int channel)
468: {
469: if (channel > MAXDEV || channel < 0) {
470: merr_raise (ARGLIST);
471: return;
472: }
473:
474: devstat[channel].mdc_err = 1;
475: devstat[channel].frm_err = OK;
476: devstat[channel].err_txt[0] = '\0';
477:
478: return;
479:
480: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to merr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src