![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mkconf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / conf_79|
Return to mkconf.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / conf_79 |
1.1 root 1: #define _DDI_DKI 1
2: #define _SYSV4 1
3:
4: /*
5: * This file contains routines for writing processed configuration data from
6: * 'mkdev.c' out into a C-language configuration file, "conf.c".
7: */
8:
9: /*
10: *-IMPORTS:
11: * <sys/compat.h>
12: * CONST
13: * PROTO
14: * ARGS ()
15: * LOCAL
16: * <kernel/v_types.h>
17: * NODEV
18: * major_t
19: * minor_t
20: * <stddef.h>
21: * size_t
22: * offsetof ()
23: * NULL
24: * <stdio.h>
25: * FILE
26: * stdout
27: * fopen ()
28: * fclose ()
29: * fprintf ()
30: * <time.h>
31: * time_t
32: * strftime ()
33: * localtime ()
34: * "ehand.h"
35: * ehand_t
36: * PUSH_HANDLER ()
37: * POP_HANDLER ()
38: * CHAIN_ERROR ()
39: * throw_error ()
40: * "mdev.h"
41: * MD_ENABLED
42: * mdev_t
43: * mdevices ()
44: * "sdev.h"
45: * sdev_sort ()
46: * "symbol.h"
47: * symbol_t
48: * "assign.h"
49: * extinfo_t
50: */
51:
52: #include <sys/compat.h>
53: #include <kernel/v_types.h>
54: #include <stddef.h>
55: #include <stdio.h>
56: #include <time.h>
57:
58: #include "ehand.h"
59: #include "mdev.h"
60: #include "sdev.h"
61: #include "symbol.h"
62: #include "assign.h"
63:
64: #include "mkconf.h"
65:
66:
67: /*
68: * We define a table to ease the otherwise tedious process of building the
69: * output for the entry point specifications.
70: *
71: * Sadly, we can't use the MDEV_... constants in this table.
72: */
73:
74: struct extern_tab {
75: CONST char * flags;
76: char func;
77: CONST char * outstr;
78: };
79:
80: LOCAL struct extern_tab _exttab [] = {
81: /*
82: * For STREAMS we have to generate an external reference to the
83: * STREAMS function table. We also have to generate stubs for the
84: * character-device entry points to map the SysV calling sequence
85: * into calls to the STREAMS-device entry points.
86: *
87: * Rather than generate those stubs here, we simply call up a generic
88: * template-style macro that will generate all the stubs we need. This
89: * is necessary since we may also be generating stubs for mapping from
90: * some non-SVR4 calling convention to SVR4 for regular devices, and
91: * the macro can deal with that, building the non-SVR4 to STREAMS
92: * mapping in one step.
93: *
94: * The stub generation happens in the second part of this table along
95: * with stub generation for regular devices.
96: */
97:
98: { "Sc", 0, "DECLARE_STREAMS (%s)" },
99: { "S!c", 0, "DECLARE_MODULE (%s)" },
100:
101:
102: /*
103: * Now the regular device entry-point stuff.
104: */
105:
106: { "b", 0, "DECLARE_STRATEGY (%s)" },
107: { "b", 0, "DECLARE_PRINT (%s)" },
108:
109:
110: /*
111: * We assume that a STREAMS driver will only define the entry points
112: * below if it is also capable of acting as a block device or if the
113: * entry is applicable regardless of type.
114: *
115: * For practical reasons other parts of this system may not permit
116: * combination STREAMS and block drivers, because with a common entry
117: * point table for both types of device the block-mode entry points
118: * like open () will conflict with the stub generated for STREAMS.
119: */
120:
121: { NULL, MDEV_OPEN, "DECLARE_OPEN (%s)" },
122: { NULL, MDEV_CLOSE, "DECLARE_CLOSE (%s)" },
123: { NULL, MDEV_READ, "DECLARE_READ (%s)" },
124: { NULL, MDEV_WRITE, "DECLARE_WRITE (%s)" },
125: { NULL, MDEV_IOCTL, "DECLARE_IOCTL (%s)" },
126: { NULL, MDEV_CHPOLL, "DECLARE_CHPOLL (%s)" },
127:
128: { NULL, MDEV_INIT, "DECLARE_INIT (%s)" },
129: { NULL, MDEV_STARTUP, "DECLARE_STARTUP (%s)" },
130: { NULL, MDEV_EXIT, "DECLARE_EXIT (%s)" },
131: { NULL, MDEV_HALT, "DECLARE_HALT (%s)" },
132:
133:
134: /*
135: * The SVR4-MP DDI/DDK defines an optional mmap () entry point
136: * for character devices, yet there is no function code for
137: * this defined in the System Files and Devices manual. Block
138: * drivers have the same problem with the size () entry.
139: */
140:
141: { "b", MDEV_SIZE, "DECLARE_SIZE (%s)" },
142: { "c", MDEV_MMAP, "DECLARE_MMAP (%s)" }
143:
144: /*
145: * The fork (), exec (), kenter () and kexit () entry points aren't
146: * defined for device drivers. In fact, I'm not sure what they *are*
147: * for unless it's for system services - processes that run in the
148: * kernel at higher priority than any user process (but usually at a
149: * lower priority than real-time processes).
150: *
151: * Since what Coherent has can barely be called a scheduler, these
152: * aren't defined here.
153: */
154: };
155:
156:
157: /*
158: * Optionally write based on function test.
159: */
160:
161: #ifdef USE_PROTO
162: LOCAL void (write_func) (FILE * out, mdev_t * mdevp, struct extern_tab * tab)
163: #else
164: LOCAL void
165: write_func ARGS ((out, mdevp, tab))
166: FILE * out;
167: mdev_t * mdevp;
168: struct extern_tab * tab;
169: #endif
170: {
171: CONST char * fcheck;
172:
173: if (out == NULL || mdevp == NULL || tab == NULL)
174: throw_error ("NULL pointer passed to write_func ()");
175:
176: if (tab->outstr == NULL)
177: throw_error ("bad table parameter passed to write_func ()");
178:
179: if ((fcheck = tab->flags) != NULL) {
180: /*
181: * Test for the logical "and" of the functions specified.
182: */
183:
184: while (* fcheck) {
185:
186: if (* fcheck == '!') {
187:
188: if (mdev_flag (mdevp, * ++ fcheck))
189: return;
190: fcheck ++;
191: } else if (! mdev_flag (mdevp, * fcheck ++))
192: return;
193: }
194: }
195:
196: if (tab->func && ! mdev_func (mdevp, tab->func))
197: return;
198:
199: (void) fprintf (out, tab->outstr, mdevp->md_prefix->s_data);
200: (void) fputc ('\n', out);
201: }
202:
203:
204: /*
205: * Output "extern" declarations for device-driver entry points.
206: */
207:
208: #ifdef USE_PROTO
209: LOCAL void (write_extern) (FILE * out, mdev_t * mdevp)
210: #else
211: LOCAL void
212: write_extern ARGS ((out, mdevp))
213: FILE * out;
214: mdev_t * mdevp;
215: #endif
216: {
217: int i;
218:
219: if (mdevp == NULL)
220: throw_error ("NULL 'mdevp' passed to write_extern ()");
221:
222: /*
223: * Test to see whether it is a driver we are dealing with.
224: */
225:
226: if (mdev_flag (mdevp, MDEV_BLOCK) || mdev_flag (mdevp, MDEV_CHAR) ||
227: mdev_flag (mdevp, MDEV_STREAM)) {
228:
229: (void) fprintf (out, "/* entry points for \"%s\" driver */\n\n",
230: mdevp->md_devname->s_data);
231: (void) fprintf (out, "extern int %sdevflag;\n",
232: mdevp->md_prefix->s_data);
233: } else
234: (void) fprintf (out, "/* entry points for \"%s\" facility */\n\n",
235: mdevp->md_devname->s_data);
236:
237: for (i = 0 ; i < sizeof (_exttab) / sizeof (* _exttab) ; i ++)
238: write_func (out, mdevp, & _exttab [i]);
239:
240: if (mdevp->md_interrupt)
241: (void) fprintf (out, "DECLARE_INTR (%s)\n",
242: mdevp->md_prefix->s_data);
243:
244: (void) fprintf (out, "\n\n");
245: }
246:
247:
248: /*
249: * Output all the extern declarations needed to generate the tables.
250: */
251:
252: #ifdef USE_PROTO
253: void (write_externs) (FILE * out)
254: #else
255: void
256: write_externs ARGS ((out))
257: FILE * out;
258: #endif
259: {
260: mdev_t * mdevp;
261:
262: for (mdevp = mdevices () ; mdevp != NULL ; mdevp = mdevp->md_next)
263: if (mdevp->md_configure == MD_ENABLED)
264: write_extern (out, mdevp);
265: }
266:
267:
268: /*
269: * Write a table of (init, start, exit, halt) routines.
270: */
271:
272: #ifdef USE_PROTO
273: LOCAL void (write_ISEH) (FILE * out, char func, CONST char * name,
274: CONST char * capsname)
275: #else
276: LOCAL void
277: write_ISEH ARGS ((out, func, name, capsname))
278: FILE * out;
279: char func;
280: CONST char * name;
281: CONST char * capsname;
282: #endif
283: {
284: mdev_t * mdevp;
285: int any = 0;
286:
287: for (mdevp = mdevices () ; mdevp != NULL ; mdevp = mdevp->md_next) {
288:
289: if (mdevp->md_configure != MD_ENABLED ||
290: ! mdev_func (mdevp, func))
291: continue;
292:
293: if (! any) {
294:
295: any = 1;
296: (void) fprintf (out, "%s_t %stab [] = {\n", name, name);
297: } else
298: (void) fprintf (out, ",\n");
299:
300: (void) fprintf (out, "\t%s (%s)", capsname,
301: mdevp->md_prefix->s_data);
302: }
303:
304: if (any) {
305: (void) fprintf (out, "\n};\n\nunsigned int n%s = sizeof "
306: "(%stab) / sizeof (* %stab);\n\n",
307: name, name, name);
308: } else
309: (void) fprintf (out, "%s_t %stab [1];\n\nunsigned int n%s"
310: "= 0;\n\n",
311: name, name, name);
312: }
313:
314:
315: /*
316: * Write the init, startup, exit and halt-routine tables.
317: */
318:
319: #ifdef USE_PROTO
320: void (write_misc) (FILE * out)
321: #else
322: void
323: write_misc ARGS ((out))
324: FILE * out;
325: #endif
326: {
327: write_ISEH (out, MDEV_INIT, "init", "INIT");
328: write_ISEH (out, MDEV_STARTUP, "start","START");
329: write_ISEH (out, MDEV_EXIT, "exit", "EXIT");
330: write_ISEH (out, MDEV_HALT, "halt", "HALT");
331: }
332:
333:
334: /*
335: * A table to help simplify the process of writing out device-switch table
336: * entries.
337: */
338:
339: typedef struct {
340: char func;
341: CONST char * str;
342: CONST char * nullstr;
343: } devtab_t;
344:
345:
346: LOCAL devtab_t _cdevswtab [] = {
347: { MDEV_OPEN, "OPEN (%s)", "NULL_OPEN" },
348: { MDEV_CLOSE, "CLOSE (%s)", "NULL_CLOSE" },
349: { MDEV_READ, "READ (%s)", "NULL_READ" },
350: { MDEV_WRITE, "WRITE (%s)", "NULL_WRITE" },
351: { MDEV_IOCTL, "\n\t\tIOCTL (%s)",
352: "\n\t\tNULL_IOCTL" },
353: { MDEV_CHPOLL, "CHPOLL (%s)", "NULL_CHPOLL" },
354: { MDEV_MMAP, "MMAP (%s)", "NULL_MMAP" },
355: { 0, NULL, NULL }
356: };
357:
358:
359: LOCAL devtab_t _bdevswtab [] = {
360: { MDEV_OPEN, "OPEN (%s)", "NULL_OPEN" },
361: { MDEV_CLOSE, "CLOSE (%s)", "NULL_CLOSE" },
362: { 0, "STRATEGY (%s)", NULL },
363: { 0, "PRINT (%s)", NULL },
364: { MDEV_SIZE, "SIZE (%s)", "NULL_SIZE" },
365: { 0, NULL, NULL }
366: };
367:
368:
369: /*
370: * Output an entry for a device-switch table.
371: */
372:
373: #ifdef USE_PROTO
374: LOCAL void (write_devsw_line) (FILE * out, mdev_t * mdevp, devtab_t * devtab)
375: #else
376: LOCAL void
377: write_devsw_line ARGS ((out, mdevp, devtab))
378: FILE * out;
379: mdev_t * mdevp;
380: devtab_t * devtab;
381: #endif
382: {
383: (void) fprintf (out, "_ENTRY (& %sdevflag, ",
384: mdevp->md_prefix->s_data);
385:
386: while (devtab->str != NULL) {
387:
388: if (devtab->func == 0 || mdev_func (mdevp, devtab->func))
389: (void) fprintf (out, devtab->str,
390: mdevp->md_prefix->s_data);
391: else
392: (void) fprintf (out, devtab->nullstr);
393:
394: if ((++ devtab)->str != NULL)
395: (void) fprintf (out, ", ");
396: }
397:
398: (void) fprintf (out, ")");
399: }
400:
401:
402: /*
403: * Write an cdevsw [] and bdevsw [] tables.
404: */
405:
406: #ifdef USE_PROTO
407: LOCAL void (write_devsw) (FILE * out, extinfo_t * extinfop)
408: #else
409: LOCAL void
410: write_devsw ARGS ((out, extinfop))
411: FILE * out;
412: extinfo_t * extinfop;
413: #endif
414: {
415: int i;
416:
417: if (extinfop->ei_ncdevs > 0) {
418:
419: (void) fprintf (out, "cdevsw_t cdevsw [] = {\n");
420:
421: for (i = 0 ; i < extinfop->ei_ncdevs ; i ++) {
422: mdev_t * mdevp = extinfop->ei_cdevsw [i];
423:
424: if (i > 0)
425: (void) fprintf (out, ",\n");
426:
427: if (mdevp == NULL)
428: (void) fprintf (out, "\tNULL_CDEVSW ()");
429: else if (mdev_flag (mdevp, MDEV_STREAM) != 0) {
430:
431: (void) fprintf (out, "\tSTREAMS_ENTRY (%s)",
432: mdevp->md_prefix->s_data);
433: } else {
434:
435: (void) fprintf (out, "\tCDEVSW");
436:
437: write_devsw_line (out, mdevp, _cdevswtab);
438: }
439: }
440:
441: (void) fprintf (out, "\n};\n\nunsigned int ncdevsw = sizeof "
442: "(cdevsw) / sizeof (* cdevsw);\n\n");
443: } else {
444:
445: (void) fprintf (out, "cdevsw_t cdevsw [1];\n\n");
446: (void) fprintf (out, "unsigned int ncdevsw = 0;\n\n");
447: }
448:
449:
450: if (extinfop->ei_nbdevs > 0) {
451:
452: (void) fprintf (out, "bdevsw_t bdevsw [] = {\n");
453:
454: for (i = 0 ; i < extinfop->ei_nbdevs ; i ++) {
455:
456: if (i > 0)
457: (void) fprintf (out, ",\n");
458:
459: if (extinfop->ei_bdevsw [i] != NULL) {
460:
461: (void) fprintf (out, "\tBDEVSW");
462:
463: write_devsw_line (out,
464: extinfop->ei_bdevsw [i],
465: _bdevswtab);
466: } else
467: (void) fprintf (out, "\tNULL_BDEVSW ()");
468: }
469:
470: (void) fprintf (out, "\n};\n\nunsigned int nbdevsw = sizeof "
471: "(bdevsw) / sizeof (* bdevsw);\n\n");
472: } else {
473:
474: (void) fprintf (out, "bdevsw_t bdevsw [1];\n\n");
475: (void) fprintf (out, "unsigned int nbdevsw = 0;\n\n");
476: }
477: }
478:
479:
480: /*
481: * Write a STREAMS module table.
482: */
483:
484: #ifdef USE_PROTO
485: LOCAL void (write_modtab) (FILE * out, extinfo_t * extinfop)
486: #else
487: LOCAL void
488: write_modtab ARGS ((out, extinfop))
489: FILE * out;
490: extinfo_t * extinfop;
491: #endif
492: {
493: int i;
494:
495: if (extinfop->ei_nmodules > 0) {
496:
497: (void) fprintf (out, "modsw_t modsw [] = {\n");
498:
499: for (i = 0 ; i < extinfop->ei_nmodules ; i ++) {
500:
501: if (i > 0)
502: (void) fprintf (out, ",\n");
503:
504: (void) fprintf (out, "\tMODSW_ENTRY (%s)",
505: extinfop->ei_modules [i]->md_devname->s_data);
506: }
507:
508: (void) fprintf (out, "\n};\n\nunsigned int nmodsw = sizeof "
509: "(modsw) / sizeof (* modsw);\n\n");
510: } else {
511:
512: (void) fprintf (out, "modsw_t modsw [1];\n\n");
513: (void) fprintf (out, "unsigned int nmodsw = 0;\n\n");
514: }
515: }
516:
517:
518: /*
519: * Write the external-to-internal device number mapping tables.
520: */
521:
522: #ifdef USE_PROTO
523: LOCAL void (write_mappings) (FILE * out, extinfo_t * extinfop)
524: #else
525: LOCAL void
526: write_mappings ARGS ((out, extinfop))
527: FILE * out;
528: extinfo_t * extinfop;
529: #endif
530: {
531: int i;
532:
533: (void) fprintf (out, "major_t _maxmajor = %d;\n\n",
534: extinfop->ei_nemajors);
535:
536: (void) fprintf (out, "major_t _major [] = {");
537:
538: for (i = 0 ; i < extinfop->ei_nemajors ; i ++) {
539:
540: if (i % 8 == 0)
541: (void) fprintf (out, "\n\t");
542:
543: if (extinfop->ei_etoimajor [i] == NODEV)
544: (void) fprintf (out, "NODEV, ");
545: else
546: (void) fprintf (out, "%d, ",
547: extinfop->ei_etoimajor [i]);
548: }
549:
550: (void) fprintf (out, "NODEV\n};\n\n");
551:
552: (void) fprintf (out, "minor_t _minor [] = {");
553:
554: for (i = 0 ; i < extinfop->ei_nemajors ; i ++) {
555:
556: if (i % 16 == 0)
557: (void) fprintf (out, "\n\t");
558:
559: (void) fprintf (out, "%d, ", extinfop->ei_minoroffset [i]);
560: }
561:
562: (void) fprintf (out, "0\n};\n\n");
563: }
564:
565:
566: /*
567: * Selection predicate for choosing "sdevice" entries that specify interrupt
568: * vectors.
569: */
570:
571: #ifdef USE_PROTO
572: LOCAL int (sel_vector) (sdev_t * sdevp)
573: #else
574: LOCAL int
575: sel_vector ARGS ((sdevp))
576: sdev_t * sdevp;
577: #endif
578: {
579: return sdevp->sd_itype > 0;
580: }
581:
582:
583: /*
584: * Comparison predicate for sorting "sdevice" entries by vector number.
585: */
586:
587: #ifdef USE_PROTO
588: LOCAL int (cmp_vector) (sdev_t * left, sdev_t * right)
589: #else
590: LOCAL int
591: cmp_vector ARGS ((left, right))
592: sdev_t * left;
593: sdev_t * right;
594: #endif
595: {
596: return left->sd_vector < right->sd_vector;
597: }
598:
599:
600: /*
601: * Function for generating tables of interrupt information.
602: */
603:
604: #ifdef USE_PROTO
605: LOCAL void (write_vectors) (FILE * out)
606: #else
607: LOCAL void
608: write_vectors ARGS ((out))
609: FILE * out;
610: #endif
611: {
612: sdlist_t veclist;
613: sdev_t * sdevp;
614: int i;
615: unsigned long masks [MAX_IPL + 1];
616:
617:
618: /*
619: * We select all the "sdevice" entries that request vectors and sort
620: * them into order by vector so it's simple to determine what is
621: * going on.
622: */
623:
624: sdev_sort (& veclist, sel_vector, cmp_vector,
625: offsetof (sdev_t, sd_link));
626:
627:
628: /*
629: * A first pass through the list determines which vectors are being
630: * used at which priority to build masks for the various levels.
631: */
632:
633: for (i = 0 ; i <= MAX_IPL ; i ++)
634: masks [i] = 0;
635:
636: for (sdevp = veclist.sdl_first ; sdevp != NULL ;
637: sdevp = sdevp->sd_link) {
638:
639: masks [sdevp->sd_ipl] = 1UL << sdevp->sd_vector;
640: }
641:
642: (void) fprintf (out, "intmask_t _masktab [] = {");
643:
644: for (i = 0 ; i < MAX_IPL ; i ++) {
645:
646: if (i % 4 == 0)
647: (void) fprintf (out, "\n\t");
648:
649: (void) fprintf (out, "0x%xUL, ", masks [i]);
650:
651: masks [i + 1] |= masks [i];
652: }
653:
654: (void) fprintf (out, "\n\t0xFFFFFFFFUL\n};\n\n");
655:
656:
657: /*
658: * Now we generate thunks for the various interrupt entry points that
659: * can wrap up any mask-manipulation magic.
660: */
661:
662: i = -1;
663:
664: for (sdevp = veclist.sdl_first ; sdevp != NULL ;
665: sdevp = sdevp->sd_link) {
666:
667: if (sdevp->sd_vector != i) {
668: if (i != -1)
669: (void) fprintf (out, "END_THUNK (%d)\n\n", i);
670:
671: i = sdevp->sd_vector;
672:
673: (void) fprintf (out, "BEGIN_THUNK (%d, 0x%xUL)\n",
674: i, masks [sdevp->sd_ipl]);
675: }
676:
677: (void) fprintf (out, "\tCALL_INTR (%d, %s)\n", i,
678: sdevp->sd_mdevp->md_prefix->s_data);
679: }
680:
681: if (i != -1)
682: (void) fprintf (out, "END_THUNK (%d)\n\n", i);
683:
684:
685: /*
686: * Now build a simple table which we can use to install the interrupt
687: * thunks we have built.
688: */
689:
690:
691: if (i == -1) {
692:
693: (void) fprintf (out, "intr_t inttab [1];\n\unsigned int "
694: "nintr = 0;\n\n");
695: return;
696: }
697:
698: (void) fprintf (out, "intr_t inttab [] = {\n");
699:
700:
701: i = -1;
702:
703: for (sdevp = veclist.sdl_first ; sdevp != NULL ;
704: sdevp = sdevp->sd_link) {
705:
706: if (sdevp->sd_vector != i) {
707: if (i != -1)
708: (void) fprintf (out, ",\n");
709:
710: i = sdevp->sd_vector;
711:
712: (void) fprintf (out, "\tINTR_THUNK (%d)", i);
713: }
714: }
715:
716: (void) fprintf (out, "\n};\n\nunsigned int nintr = sizeof (inttab) /"
717: " sizeof (* inttab);\n\n");
718: }
719:
720: #if _REMINDER
721: /*
722: * We output a bogus definition which needs the address of some functions we
723: * want around to use this file...
724: */
725:
726: #ifdef USE_PROTO
727: LOCAL void (write_reminder) (FILE * out)
728: #else
729: LOCAL void
730: write_reminder ARGS ((out))
731: FILE * out;
732: #endif
733: {
734: (void) fprintf (out, "/*\n * Make sure that the functions which use"
735: " this file are out there\n */\n\n");
736: (void) fprintf (out, "__EXTERN_C_BEGIN__\n\n");
737: (void) fprintf (out, "void\t\tSTREAMS_INIT\t__PROTO ((void));\n");
738: (void) fprintf (out, "\n__EXTERN_C_END__\n\n");
739: (void) fprintf (out, "\nvoid (* __bogus []) __PROTO ((void)) = {\n");
740: (void) fprintf (out, "\tSTREAMS_INIT\n};\n");
741: }
742: #endif /* ! _REMINDER */
743:
744:
745: /*
746: * Write out a C-language configuration file with definitions for all the data
747: * the implementation needs compiled from the plain-text configuration
748: * database.
749: */
750:
751: #ifdef __USE_PROTO__
752: int (write_conf_c) (CONST char * name, extinfo_t * extinfop)
753: #else
754: int
755: write_conf_c ARGS ((name, extinfop))
756: CONST char * name;
757: extinfo_t * extinfop;
758: #endif
759: {
760: time_t gentime;
761: char timebuf [70];
762: FILE * out;
763: ehand_t err;
764:
765: if (name == NULL)
766: out = stdout;
767: else if ((out = fopen (name, "w")) == NULL)
768: throw_error ("Unable to open output file for writing");
769:
770: if (PUSH_HANDLER (err) == 0) {
771: time (& gentime);
772:
773: fprintf (out, "/*\n");
774: fprintf (out, " * The code in this file was automatically "
775: "generated. Do not hand-modify!\n");
776:
777: #ifdef __COHERENT__
778: strncpy (timebuf, asctime (localtime (& gentime)),
779: sizeof (timebuf) - 1);
780: timebuf [sizeof (timebuf) - 1] = 0;
781: #else
782: strftime (timebuf, sizeof (timebuf) - 1, "%x %X %Z",
783: localtime (& gentime));
784: #endif
785:
786: fprintf (out, " * Generated at %s\n", timebuf);
787: fprintf (out, " */\n\n");
788: fprintf (out, "#define _KERNEL\t\t1\n");
789: fprintf (out, "#define _DDI_DKI\t1\n\n");
790: fprintf (out, "#include <kernel/confinfo.h>\n\n");
791:
792: write_externs (out);
793: write_misc (out);
794: write_devsw (out, extinfop);
795: write_modtab (out, extinfop);
796: write_mappings (out, extinfop);
797: write_vectors (out);
798:
799: #if _REMINDER
800: write_reminder (out);
801: #endif
802: if (out != stdout)
803: fclose (out);
804: } else {
805: if (out != stdout)
806: fclose (out);
807: CHAIN_ERROR (err);
808: }
809:
810: POP_HANDLER (err);
811: return 0;
812: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.