Return to listing CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/listing, revision 1.1

1.1     ! root        1: #!/bin/sh -f
        !             2: # Generate a source code listing for C or C++ code with assembler code. The
        !             3: # listing is always written to stdout.
        !             4: # Author: Igor Metz <[email protected]>
        !             5: 
        !             6: # Revision 1.3  89/12/18  13:58:27  metz
        !             7: # lister must now be configured before it can be used. This is done in the
        !             8: # /bin/sh part of the code.
        !             9: # 
        !            10: # 
        !            11: # Revision 1.2  89/08/16  17:35:02  metz
        !            12: # Support for SPARC added.
        !            13: # 
        !            14: # Revision 1.1  89/08/16  16:49:22  metz
        !            15: # Initial revision
        !            16: # 
        !            17: 
        !            18: # Requires: gawk (may be it works also with nawk)
        !            19: 
        !            20: # usage:  lister filename [compiler-options]
        !            21: 
        !            22: # Method:
        !            23: # compile the source with -g option to assembler code, then merge the
        !            24: # generated assembler code with the source code. Compiler options
        !            25: # can be supplied on the command line (for example -O)
        !            26: 
        !            27: # To install lister, assign one of the supported values to the variable MYSYS:
        !            28: # mc68020  for Motorola 68020 (Sun-3, ..)
        !            29: # mc68030  for Motorola 68030 (Sun-3, ..)
        !            30: # sparc    for SPARC (SUN-4, ..)
        !            31: # i386     for i386 (Sun i386, ...)
        !            32: 
        !            33: # uncomment the line you need:
        !            34: # MYSYS=mc68020
        !            35: # MYSYS=mc68030
        !            36: # MYSYS=sparc
        !            37: # MYSYS=i386
        !            38: # MYSYS=`mach`  # this will work on Suns with SunOS > 4.0.0
        !            39: 
        !            40: exec gawk -vsys=$MYSYS '
        !            41: # commandline arguments:
        !            42: #  ARGV[0] = "gawk"
        !            43: #  ARGV[1] = processid
        !            44: #  ARGV[2] = filename
        !            45: #  ARGV[3] .. ARGV[ARGC-1] = compiler options
        !            46: BEGIN {
        !            47:   if (ARGC < 3) {
        !            48:     usage()
        !            49:     exit 1
        !            50:   }
        !            51: 
        !            52:   # Declaration of global variables
        !            53:   c_filename = ""
        !            54:   asm_filename = ""
        !            55:   cmdline = ""
        !            56:   asm_code = ""
        !            57:   c_code = ""
        !            58:   c_lineno = 0
        !            59:   oldlineno = 0
        !            60:   newlineno = 0
        !            61:   ignore_stabd = 0
        !            62:   num_of_fields = 0
        !            63: 
        !            64:   # check processor architecture and set sourcecode line_hint accordingly
        !            65:   if (sys == "sparc" || sys == "i386") {
        !            66:     line_hint = "^[ \t]*\.stabn.*"
        !            67:   }
        !            68:   else if (sys == "mc68020" || sys == "mc68030") {
        !            69:     line_hint = "^[ \t]*\.stabd.*"
        !            70:   }
        !            71:   else {
        !            72:     error("Processor type " sys " is not supported yet, sorry")
        !            73:   }
        !            74: 
        !            75:   parse_cmdline()
        !            76: 
        !            77:   printf("compiling %s to asm code\n", c_filename ) > "/dev/stderr"
        !            78: 
        !            79:   if (system(cmdline) != 0 ) {
        !            80:     error("Compilation of " c_filename " failed")
        !            81:   }
        !            82: 
        !            83:   printf("generating listing\n") > "/dev/stderr"
        !            84: 
        !            85: 
        !            86:   while ( getline asm_code < asm_filename > 0 ) {
        !            87:     if ( (ignore_stabd==0) && (asm_code ~ line_hint)) {
        !            88:       # source line hint found. Split the line into fields seperated by commas.
        !            89:       # num_of_fields is 4 for sparc, 3 for m68k
        !            90:       num_of_fields = split(asm_code, fields, ",")
        !            91:       newlineno = fields[3] + 0 # the line number we are looking for is field 3
        !            92: 
        !            93:       if (newlineno > oldlineno) {
        !            94:         while ( newlineno > c_lineno ) {
        !            95:          getline c_code < c_filename
        !            96:          c_lineno++
        !            97:          printf("%4d %s\n", c_lineno, c_code)
        !            98:        }
        !            99:        oldlineno = newlineno
        !           100:       }
        !           101:     }
        !           102:     else if ( asm_code ~ ".*Ltext[ \t]*$" ) {
        !           103:       # filename hint found
        !           104:       if ( match(asm_code, c_filename)) {
        !           105:         ignore_stabd = 0
        !           106:       }
        !           107:       else {
        !           108:         ignore_stabd = 1
        !           109:       }
        !           110:     }
        !           111:     printf("\t\t\t%s\n", asm_code)
        !           112:   }
        !           113: 
        !           114:   # general cleanup
        !           115:   system("/bin/rm " asm_filename)
        !           116: }
        !           117: 
        !           118: function usage() {
        !           119:     printf("usage: %s filename compiler-options\n", argv[0]) > "/dev/stderr"
        !           120: }
        !           121: 
        !           122: function error(s) {
        !           123:     printf("error: %s\n", s) > "/dev/stderr"
        !           124:     exit 1
        !           125: }
        !           126: 
        !           127: function parse_cmdline(    i) {
        !           128:   # construct filenames to use
        !           129:   asm_filename = "/tmp/lister" ARGV[1] ".s"
        !           130:   ARGV[1] = ""
        !           131:   c_filename = ARGV[2]
        !           132:   ARGV[2] = ""
        !           133: 
        !           134:   # construct commandline to use
        !           135:   if ( match(c_filename, ".C") || match(c_filename, ".cc") ) {
        !           136:     cmdline = "g++"
        !           137:   }
        !           138:   else if (match(c_filename, ".c")) {
        !           139:     cmdline = "gcc"
        !           140:   }
        !           141:   else {
        !           142:     error("unknown extension for file " c_filename)
        !           143:   }
        !           144: 
        !           145:   cmdline = cmdline " -g -S -o " asm_filename
        !           146: 
        !           147:   # now we append the compiler options specified by the user
        !           148:   for (i = 3; i < ARGC; i++) {
        !           149:     cmdline = cmdline " " ARGV[i]
        !           150:     ARGV[i] = "" # we do not want to treat it as an inputfile
        !           151:   }
        !           152: 
        !           153:   # last but not least: the name of the file to compile
        !           154:   cmdline = cmdline " " c_filename
        !           155: }
        !           156: 
        !           157: ' $$ $*

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