Return to c_language CVS log

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

Annotation of coherent/a/usr/man/ALL/c_language, revision 1.1.1.1

1.1       root        1: 
                      2: 
                      3: C language                   Overview                  C language
                      4: 
                      5: 
                      6: 
                      7: 
                      8: The following summarizes how COHERENT implements the C language.
                      9: 
                     10: Identifiers
                     11:     Characters allowed: AA-ZZ, aa-zz, _, 00-99
                     12:     Case sensitive.
                     13:     Number of significant characters in a variable name:
                     14:         at compile time:112288
                     15:         at link time:1166
                     16:     C appends `_' to end of external identifiers
                     17: 
                     18: Reserved Identifiers (Keywords)
                     19:     See CC kkeeyywwoorrddss, above.
                     20: 
                     21: Data Formats (bits)
                     22:     cchhaarr           8
                     23:     uunnssiiggnneedd cchhaarr  8
                     24:     ddoouubbllee        64
                     25:     ffllooaatt         32
                     26:     iinntt           16
                     27:     uunnssiiggnneedd iinntt  16
                     28:     lloonngg          32
                     29:     uunnssiiggnneedd lloonngg 32
                     30:     pointer       16
                     31: 
                     32: Limits
                     33:     Maximum bitfield size:  16 bits
                     34:     Maximum number of ccaassees in a sswwiittcchh:  no formal limit
                     35:     Maximum block nesting depth:  no formal limit
                     36:     Maximum parentheses nesting depth:  no formal limit
                     37:     Maximum structure size:  64 kilobytes
                     38: 
                     39: Preprocessor Instructions:
                     40:     #define #ifdef
                     41:     #else   #ifndef
                     42:     #elif   #include
                     43:     #endif  #line
                     44:     #if     #undef
                     45: 
                     46: Structure Name-Spaces
                     47:     Supports both Berkeley and Kernighan-Ritchie conventions
                     48:     for structure in union.
                     49: 
                     50: Register Variables
                     51:     Two available for iinntts
                     52:     Two available for pointers
                     53: 
                     54: Function Linkage
                     55:     Return values for iinntts: AX
                     56:     Return values for lloonnggs: DX:AX
                     57:     Return values for SMALL-model pointers: AX
                     58:     Return values for LARGE-model pointers: DX:AX
                     59:     Return values for ddoouubbllees in DX:AX
                     60:     Parameters pushed on stack in reverse order, cchhaarrs and sshhoorrtts pushed
                     61:        as words, lloonnggs and pointers pushed as lloonnggs, structures
                     62: 
                     63: 
                     64: COHERENT Lexicon                                           Page 1
                     65: 
                     66: 
                     67: 
                     68: 
                     69: C language                   Overview                  C language
                     70: 
                     71: 
                     72: 
                     73:        copied onto stack
                     74:     Caller must clear parameters off stack
                     75:     Stack frame linkage is done through SP register
                     76: 
                     77: ***** Special Features and Optimizations *****
                     78: 
                     79: 
                     80: * Branch optimization is performed: this uses the smallest branch
                     81:   instruction for the required range.
                     82: 
                     83: * Unreached code is eliminated.
                     84: 
                     85: * Duplicate instruction sequences are removed.
                     86: 
                     87: * Jumps to jumps are eliminated.
                     88: 
                     89: *  Multiplication and  division  by constant  powers  of two  are
                     90:   changed to shifts when the results are the same.
                     91: 
                     92: * Sequences  that can be resolved at  compile time are identified
                     93:   and resolved.
                     94: 
                     95: ***** See Also *****
                     96: 
                     97: argc, argv,  C keywords,  C preprocessor, header  files, Lexicon,
                     98: libraries, linker-defined symbols, main()
                     99: 
                    100: 
                    101: 
                    102: 
                    103: 
                    104: 
                    105: 
                    106: 
                    107: 
                    108: 
                    109: 
                    110: 
                    111: 
                    112: 
                    113: 
                    114: 
                    115: 
                    116: 
                    117: 
                    118: 
                    119: 
                    120: 
                    121: 
                    122: 
                    123: 
                    124: 
                    125: 
                    126: 
                    127: 
                    128: 
                    129: 
                    130: COHERENT Lexicon                                           Page 2
                    131: 
                    132: 

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