Return to cc CVS log

Up to [MW Coherent from dump] / coherent / a / usr / man / ALL

Annotation of coherent/a/usr/man/ALL/cc, revision 1.1

1.1     ! root        1: 
        !             2: 
        !             3: cc                           Command                           cc
        !             4: 
        !             5: 
        !             6: 
        !             7: 
        !             8: Compiler controller
        !             9: 
        !            10: cccc [_c_o_m_p_i_l_e_r _o_p_t_i_o_n_s] _f_i_l_e .... [_l_i_n_k_e_r _o_p_t_i_o_n_s]
        !            11: 
        !            12: cc is  the program that  controls compilation of  C programs.  It
        !            13: guides files of source and object code through each phase of com-
        !            14: pilation and linking.  cccc has  many options to assist in the com-
        !            15: pilation of  C programs; in essence, however, all  you need to do
        !            16: to  produce an  executable file  from your C  program is  type cccc
        !            17: followed by the name of the file or files that hold your program.
        !            18: It  checks whether  the file  names you  give it  are reasonable,
        !            19: selects the  right phase for each file,  and performs other tasks
        !            20: that ease the compilation of your programs.
        !            21: 
        !            22: ***** File Names *****
        !            23: 
        !            24: cc  assumes that each  file name  that ends  in .c or  .h is  a C
        !            25: program and passes it to the C compiler for compilation.
        !            26: 
        !            27: cc assumes  that each file  argument that ends  in .s is  in Mark
        !            28: Williams assembly  language and  processes it with  the assembler
        !            29: as.
        !            30: 
        !            31: cc also passes all files with  the suffixes .o or .a unchanged to
        !            32: the linker ld.
        !            33: 
        !            34: ***** How cc Works *****
        !            35: 
        !            36: cc normally works as follows: First, it compiles or assembles the
        !            37: source files, naming  the resulting object files by replacing the
        !            38: .cc or .ss suffixes with the  suffix .oo.  Then, it links the object
        !            39: files  with the  C  runtime startup  routine and  the standard  C
        !            40: library, and leaves the result  in file _f_i_l_e.  If only one object
        !            41: file is created  during compilation, it is deleted after linking;
        !            42: however, if more than one object file is created, or if an object
        !            43: file of  the same name existed before you  began to compile, then
        !            44: the object file or files are not deleted.
        !            45: 
        !            46: ***** Options *****
        !            47: 
        !            48: The following lists  all of cccc's command-line options.  cc passes
        !            49: some options  through to the  linker ld unchanged,  and correctly
        !            50: interprets to it the options -oo and -uu.
        !            51: 
        !            52: A number  of the options  are esoteric and normally  are not used
        !            53: when compiling a C  program.  The following are the most commonly
        !            54: used options:
        !            55: 
        !            56: 
        !            57:          -cc      Compile only; do not link
        !            58:          -ff      Include floating-point pprriinnttff
        !            59:          -ll_n_a_m_e  Pass library lliibb_n_a_m_e.aa to linker
        !            60:          -oo _n_a_m_e Call output file _n_a_m_e
        !            61:          -VV      Print verbose listing of cccc's action
        !            62: 
        !            63: 
        !            64: COHERENT Lexicon                                           Page 1
        !            65: 
        !            66: 
        !            67: 
        !            68: 
        !            69: cc                           Command                           cc
        !            70: 
        !            71: 
        !            72: 
        !            73: 
        !            74: 
        !            75: -AA  MicroEMACS option.  If an error occurs during compilation, cc
        !            76:     automatically invokes the  MicroEMACS screen editor.  The er-
        !            77:     ror or errors are displayed in one window and the source code
        !            78:     file in the other, with the cursor set to the line number in-
        !            79:     dicated by  the first error message.   Typing <ctrl-X>> moves
        !            80:     to the next error, <ctrl-X>< moves to the previous error.  To
        !            81:     recompile, close the  edited file with <ctrl-Z>.  Compilation
        !            82:     will continue  either until the program  compiles without er-
        !            83:     ror, or  until you  exit from  the editor by  typing <ctrl-U>
        !            84:     followed by <ctrl-X><ctrl-C>.
        !            85: 
        !            86: -BB[_s_t_r_i_n_g]
        !            87:     Backup option.   Use alternate  versions of the  compiler for
        !            88:     cc0, cc1,  cc2, and cc3.  If string  is supplied, cc prepends
        !            89:     it to  the names of  the phases of  the compiler to  form the
        !            90:     pathnames where these  are found.  Otherwise, cc prepends the
        !            91:     name of the current directory.  If a -t option was previously
        !            92:     given, only the parts of the compiler specified by it are af-
        !            93:     fected.  Any  number of -B  and -t options may  be used, with
        !            94:     each -t  option specifying the passes  affected by the subse-
        !            95:     quent -B option.  For example, the command
        !            96: 
        !            97:         cc -tp2 -Bnew hello.c
        !            98: 
        !            99:     compiles hheelllloo.cc using nneewwcccc22 in place of the ordinarily used
        !           100:     /lliibb/cccc22, and  using nneewwccpppp in  place of the  ordinarily used
        !           101:     /lliibb/ccpppp.
        !           102: 
        !           103: -cc  Compile option.  Suppress  linking and the removal of the ob-
        !           104:     ject files.
        !           105: 
        !           106: -DD_n_a_m_e[=_v_a_l_u_e]
        !           107:     Define  name to  the  preprocessor, as  if set  by a  #define
        !           108:     directive.  If value is present, it is used to initialize the
        !           109:     definition.
        !           110: 
        !           111: -EE  Expand option.  Run the C preprocessor ccpppp and write its out-
        !           112:     put onto the standard output.
        !           113: 
        !           114: -ff  Floating point option.  Include library routines that perform
        !           115:     floating-point   arithmetic.    Because  the   floating-point
        !           116:     routines require approximately  five kilobytes of memory, the
        !           117:     standard C library does not include them; the -ff option tells
        !           118:     the  compiler to  include  them.  If  a  program is  compiled
        !           119:     without the -ff option  but attempts to print a floating point
        !           120:     number  during  execution by  using  the e,  f,  or g  format
        !           121:     specifications to printf, the message
        !           122: 
        !           123:         You must compile with -f option for floating point
        !           124: 
        !           125:     will be printed and the program will exit.
        !           126: 
        !           127: 
        !           128: 
        !           129: 
        !           130: COHERENT Lexicon                                           Page 2
        !           131: 
        !           132: 
        !           133: 
        !           134: 
        !           135: cc                           Command                           cc
        !           136: 
        !           137: 
        !           138: 
        !           139: -II _n_a_m_e
        !           140:     IInclude option.  Specify  a directory the preprocessor should
        !           141:     search  for files  given  in #include  directives, using  the
        !           142:     following criteria: If the #iinncclluuddee statement reads
        !           143: 
        !           144:         #include "file.h"
        !           145: 
        !           146:     cccc searches for ffiillee.hh first in the source directory, then in
        !           147:     the directory named in  the -II_n_a_m_e option, and finally in the
        !           148:     system's  default  directories.   If the  #iinncclluuddee  statement
        !           149:     reads
        !           150: 
        !           151:         #include <file.h>
        !           152: 
        !           153:     cccc searches for ffiillee.hh  first in the directories named in the
        !           154:     -II_n_a_m_e option, and  then in the system's default directories.
        !           155:     Multiple -II_n_a_m_e options are executed in the order of their of
        !           156:     appearance.
        !           157: 
        !           158: -KK  Keep  option.  Do not erase  the intermediate files generated
        !           159:     during compilation.  Temporary files will be written into the
        !           160:     current directory.
        !           161: 
        !           162: -ll _n_a_m_e
        !           163:     llibrary option.   Pass the name  of a library  to the linker.
        !           164:     cc  expands -lname  into /lliibb/lliibb_n_a_m_e.aa.   If  an alternative
        !           165:     library prefix has been specified by the -tl and -Bstring op-
        !           166:     tions,  then -lname  expands to  stringlliibbname.aa.   Note that
        !           167:     this is a linker option, and so must appear at the end of the
        !           168:     cc command line, or it will not be processed correctly.
        !           169: 
        !           170: -MM _s_t_r_i_n_g
        !           171:     Machine option.  Use  an alternate version of cc0, cc1, cc1a,
        !           172:     cc1b,  cc2, cc3,  as, lib*.a,  and  crts0.o, named  by fixing
        !           173:     string  between the  directory  name and  the  pass and  file
        !           174:     names.
        !           175: 
        !           176: -nn   Instruct the  linker  ld to  bind the  output with  separate
        !           177:     shared  and private  segments, and which  each starting  on a
        !           178:     separate  hardware-segment  boundary.   This  allows  several
        !           179:     processes to  simultaneously use one copy  of the shared seg-
        !           180:     ment.  Note that programs  linked with this option will run a
        !           181:     little more slowly than  if they were not so linked; however,
        !           182:     if a  program forks  (e.g., kkeerrmmiitt) or  will be used  by more
        !           183:     than  one user  at a time  (e.g., MicroEMACS),  this slightly
        !           184:     slower time  will be more than offset  by the program's being
        !           185:     spared having to read an entire copy of itself from the disk.
        !           186: 
        !           187: -NN[pp00112233ssddllrrtt]_s_t_r_i_n_g
        !           188:     Name option.  Rename a specified pass to string.  The letters
        !           189:     p0123sdlrt refer,  respectively, to cpp, cc0,  cc1, cc2, cc3,
        !           190:     the assembler, the linker, the libraries, the run-time start-
        !           191:     up, and the temporary files.
        !           192: 
        !           193: 
        !           194: 
        !           195: 
        !           196: COHERENT Lexicon                                           Page 3
        !           197: 
        !           198: 
        !           199: 
        !           200: 
        !           201: cc                           Command                           cc
        !           202: 
        !           203: 
        !           204: 
        !           205: -oo _n_a_m_e
        !           206:     Output option.   Rename the executable file  from the default
        !           207:     to _n_a_m_e.  If this option  is not used, the executable will be
        !           208:     named after the first .cc or .oo file on the command line.
        !           209: 
        !           210: -OO  Optimize  option.  Run the  code generated by  the C compiler
        !           211:     through the  peephole optimizer.  The optimizer  pass is man-
        !           212:     datory for  the i8086, Z8000, and  M68000 compilers, and need
        !           213:     not be requested.  It is optional for the PDP11 compiler, but
        !           214:     is recommended  for all files  except those that  consist en-
        !           215:     tirely of initialized tables of data.
        !           216: 
        !           217: -qq[pp00112233ss]
        !           218:     Quit  option.    Terminate  compilation  after   running  the
        !           219:     specified pass.   The letters pp00112233ss  refer, respectively, to
        !           220:     cpp, cc0, cc1, cc2,  cc3, and the assembler.  For example, to
        !           221:     terminate compilation after running the parser cc0, type -qq00.
        !           222: 
        !           223: -QQ  Quiet option.  Suppress all messages.
        !           224: 
        !           225: -SS  Suppress  the object-writing and link  phases, and invoke the
        !           226:     disassembler cc3.  This  option produces an assembly-language
        !           227:     version of a C program for examination, for example if a com-
        !           228:     piler  problem is  suspected.   The assembly-language  output
        !           229:     file name replaces the .c suffix with .s.  This is equivalent
        !           230:     to the -VVAASSMM option.
        !           231: 
        !           232: -tt[pp0011aabb2233ssddllrrtt]
        !           233:     Take option.   Use alternate versions of  the compiler phases
        !           234:     and  other files  specified in the  following string.   If no
        !           235:     following string  is given, the cccc  uses alternate version of
        !           236:     every phase of the compiler, except the preprocessor.  If the
        !           237:     -tt option is followed by  a -BB option, cccc prepends the prefix
        !           238:     string named  in the -BB option to the  phases and files named
        !           239:     in the  -tt option; otherwise, the it  looks for the alternate
        !           240:     forms in the current directory.
        !           241: 
        !           242: -UU _n_a_m_e
        !           243:     Undefine symbol  name.  Use  this option to  undefine symbols
        !           244:     that the preprocessor defines implicitly, such as the name of
        !           245:     the native system or machine.
        !           246: 
        !           247: -VV  Verbose  option.  cccc prints onto the  standard output a step-
        !           248:     by-step description of each action it takes.
        !           249: 
        !           250: VV_s_t_r_i_n_g
        !           251:     Variant option.   Toggle (i.e., turn  on or off)  the variant
        !           252:     _s_t_r_i_n_g during  the compilation.  Variants that  are marked oonn
        !           253:     are turned  on by  default.  Options marked  SSttrriicctt: generate
        !           254:     messages that warn  of the conditions in question.  cc recog-
        !           255:     nizes the following variants:
        !           256: 
        !           257: -VVAASSMM
        !           258:    Output assembly-language code.  Identical to -SS option, above.
        !           259:    It can  be used with  the -VVLLIINNEESS option,  described below, to
        !           260: 
        !           261: 
        !           262: COHERENT Lexicon                                           Page 4
        !           263: 
        !           264: 
        !           265: 
        !           266: 
        !           267: cc                           Command                           cc
        !           268: 
        !           269: 
        !           270: 
        !           271:    generate a  line-numbered file of  assembly language.  Default
        !           272:    is ooffff.
        !           273: 
        !           274: -VVCCOOMMMM
        !           275:    Permit .ccoomm-style data items.  Default is oonn.
        !           276: 
        !           277: -VVFFLLOOAATT
        !           278:    Include floating  point pprriinnttff  routines.  Same as  -f option,
        !           279:    above.
        !           280: 
        !           281: -VVLLIINNEESS
        !           282:    Generate line number information.  Can be used with the option
        !           283:    -VVAASSMM, described  above, to generate  assembly language output
        !           284:    that uses line numbers.  Default is ooffff.
        !           285: 
        !           286: -VVQQUUIIEETT
        !           287:    Suppress all  messages.  Identical  to -Q option.   Default is
        !           288:    ooffff.
        !           289: 
        !           290: -VVSSBBOOOOKK
        !           291:    Strict: note  deviations from _T_h_e _C  _P_r_o_g_r_a_m_m_i_n_g _L_a_n_g_u_a_g_e, ed.
        !           292:    1.  Default is ooffff.
        !           293: 
        !           294: -VVSSCCCCOONN
        !           295:    Strict: note constant conditional.  Default is ooffff.
        !           296: 
        !           297: -VVSSIINNUU
        !           298:    Implement  struct-in-union  rules  instead of  Berkeley-member
        !           299:    resolution rules.   Default is  ooffff, i.e., Berkeley  rules are
        !           300:    the default.
        !           301: 
        !           302: -VVSSLLCCOONN
        !           303:    Strict:  iinntt constant  promoted to lloonngg  because value  is too
        !           304:    big.  Default is oonn.
        !           305: 
        !           306: -VVSSMMEEMMBB
        !           307:    Strict: check use  of structure/union members for adherence to
        !           308:    standard rules of C.  Default is oonn.
        !           309: 
        !           310: -VVSSNNRREEGG
        !           311:    Strict: register declaration reduced to auto.  Default is oonn.
        !           312: 
        !           313: -VVSSPPVVAALL
        !           314:    Strict: pointer value truncated.  Default is ooffff.
        !           315: 
        !           316: -VVSSRRTTVVCC
        !           317:    Strict: risky types in truth contexts.  Default is ooffff.
        !           318: 
        !           319: -VVSSTTAATT
        !           320:    Give statistics on optimization.
        !           321: 
        !           322: -VVSS
        !           323:    Turn on all strict checking.  Default is oonn.
        !           324: 
        !           325: 
        !           326: 
        !           327: 
        !           328: COHERENT Lexicon                                           Page 5
        !           329: 
        !           330: 
        !           331: 
        !           332: 
        !           333: cc                           Command                           cc
        !           334: 
        !           335: 
        !           336: 
        !           337: -VVSSUURREEGG
        !           338:    Strict: note unused registers.  Default is ooffff.
        !           339: 
        !           340: -VVSSUUVVAARR
        !           341:    Strict: note unused variables.  Default is oonn.
        !           342: 
        !           343: -VV33GGRRAAPPHH
        !           344:    Translate ANSI trigraphs.  Default is ooffff.
        !           345: 
        !           346: ***** See  Also *****  as, C language,  cc0, cc1, cc2,  cc3, com-
        !           347: mands, cpp, ld
        !           348: _T_h_e _C _L_a_n_g_u_a_g_e, tutorial
        !           349: 
        !           350: 
        !           351: 
        !           352: 
        !           353: 
        !           354: 
        !           355: 
        !           356: 
        !           357: 
        !           358: 
        !           359: 
        !           360: 
        !           361: 
        !           362: 
        !           363: 
        !           364: 
        !           365: 
        !           366: 
        !           367: 
        !           368: 
        !           369: 
        !           370: 
        !           371: 
        !           372: 
        !           373: 
        !           374: 
        !           375: 
        !           376: 
        !           377: 
        !           378: 
        !           379: 
        !           380: 
        !           381: 
        !           382: 
        !           383: 
        !           384: 
        !           385: 
        !           386: 
        !           387: 
        !           388: 
        !           389: 
        !           390: 
        !           391: 
        !           392: 
        !           393: 
        !           394: COHERENT Lexicon                                           Page 6
        !           395: 
        !           396: 

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