Return to message.c CVS log

Up to [MW Coherent from dump] / coherent / b / bin / ld386

Annotation of coherent/b/bin/ld386/message.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * ld/message.c
                      3:  * Print messages of various origins.
                      4:  * And misc functions.
                      5:  */
                      6: 
                      7: #include "ld.h"
                      8: #include <errno.h>
                      9: 
                     10: extern char *memset();
                     11: 
                     12: /*
                     13:  * Fatal error; print message and exit
                     14:  */
                     15: void
                     16: fatal(args)
                     17: char *args;
                     18: {
                     19:        if (!Qflag)
                     20:                fprintf(stderr, "%s: %r\n", argv0, &args);
                     21:        exit(1);
                     22: }
                     23: 
                     24: void
                     25: message(args)
                     26: char * args;
                     27: {
                     28:        errCount++;
                     29:        if (Qflag)
                     30:                return;
                     31:        fprintf(stderr, "%s: %r\n", argv0, &args);
                     32: }
                     33: 
                     34: void
                     35: watch_message(args)
                     36: char * args;
                     37: {
                     38:        fprintf(stderr, "%s: %r\n", argv0, &args);
                     39: }
                     40: 
                     41: /*
                     42:  * message plus command prototype
                     43:  */
                     44: void
                     45: help()
                     46: {
                     47:        static char document[] =
                     48:                "Usage ld\n"
                     49:                "\t-d\t\tDefine commons even if undefined symbols\n"
                     50:                "\t-e entry\tSet entry point\n"
                     51:                "\t-K\t\tCompile kernel\n"
                     52:                "\t-l lib\t\tUse library\n"
                     53:                "\t-o outfile\tSet output filename default is a.out\n"
                     54:                "\t-r\t\tRetain relocation information\n"
                     55:                "\t-s\t\tStrip symbol table\n"
                     56:                "\t-u sym\t\tUndefine sym\n"
                     57:                "\t-w\t\tWatch messages enabled\n"
                     58:                "\t-X\t\tDiscard local symbols beginning .L\n"
                     59:                "\t-x\t\tDiscard all local symbols\n";
                     60: 
                     61:        printf(document);
                     62:        exit(0);
                     63: }
                     64: 
                     65: usage()
                     66: {
                     67:        fprintf(stderr,
                     68: "usage: ld [-drswxX?] [-o out] [-e entry] [-u sym] file ... [-l lib] ...\n");
                     69:        exit(1);
                     70: }
                     71: 
                     72: /*
                     73:  * message with filename
                     74:  */
                     75: void
                     76: filemsg(fname, args)
                     77: char   *fname, *args;
                     78: {
                     79:        message( "file '%s': %r", fname, &args );
                     80: }
                     81: 
                     82: /*
                     83:  * Message with module and file name
                     84:  */
                     85: void
                     86: modmsg(fname, mname, args)
                     87: char * fname;
                     88: char * mname;
                     89: char * args;
                     90: {
                     91:        if (mname[0] == 0)
                     92:                filemsg(fname, "%r", &args );
                     93: 
                     94:        else
                     95:                filemsg(fname, "module '%.*s': %r",
                     96:                        DIRSIZ, mname, &args );
                     97: }
                     98: 
                     99: /*
                    100:  * Message for module passed by pointer
                    101:  */
                    102: void
                    103: mpmsg(mp, args)
                    104: mod_t * mp;
                    105: char  * args;
                    106: {
                    107:        modmsg(mp->fname, mp->mname, "%r", &args);
                    108: }
                    109: 
                    110: /*
                    111:  * Module is corrupt message.
                    112:  */
                    113: void
                    114: corrupt(mp)
                    115: {
                    116:        mpmsg(mp, "is corrupt");
                    117:        /* This does not make sense as an object module. */
                    118:        exit (1);
                    119: }
                    120: 
                    121: /*
                    122:  * Message for symbol passed by pointer
                    123:  */
                    124: void
                    125: spmsg(sp, args)
                    126: sym_t  *sp;
                    127: char   *args;
                    128: {
                    129:        static char msg[] = "symbol '%s' %r";
                    130:        char work[SYMNMLEN + 1], *name;
                    131: 
                    132:        name = symName(&(sp->sym), work);
                    133: 
                    134:        if (sp->mod == NULL)
                    135:                message(msg, name, &args);
                    136:        else
                    137:                mpmsg(sp->mod, msg, name, &args);
                    138: }
                    139: 
                    140: /*
                    141:  * Warning message for symbol passed by pointer
                    142:  */
                    143: void
                    144: spwarn(sp, args)
                    145: sym_t  *sp;
                    146: char   *args;
                    147: {
                    148:        static char msg[] = "warning: symbol '%s' %r";
                    149:        char work[SYMNMLEN + 1], *name;
                    150: 
                    151:        if (qflag)
                    152:                return;
                    153: 
                    154:        errCount--;     /* don't increment count */
                    155:        name = symName(&(sp->sym), work);
                    156: 
                    157:        if (sp->mod == NULL)
                    158:                message(msg, name, &args);
                    159:        else
                    160:                mpmsg(sp->mod, msg, name, &args);
                    161: }
                    162: 
                    163: /*
                    164:  * Open a file or die in the attempt.
                    165:  */
                    166: int
                    167: qopen(fn, type)
                    168: char *fn;
                    169: {
                    170:        int fd;
                    171: 
                    172:        if (type)
                    173:                fd = creat(fn, 0666);
                    174:        else
                    175:                fd = open(fn, 0);
                    176: 
                    177:        if (-1 == fd) {
                    178:                filemsg(fn, "Cannot open.");    /**/
                    179:                exit(1);
                    180:        }
                    181:        return (fd);
                    182: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.