Return to _23 CVS log

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

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

1.1       root        1: 
                      2: 
                      3: #                     Preprocessing Operator                    #
                      4: 
                      5: 
                      6: 
                      7: 
                      8: String-ize operator
                      9: 
                     10: 
                     11: The preprocessing  operator # can be  used within the replacement
                     12: list of  a function-like macro.  It and  its operand are replaced
                     13: by a  string literal, which  names the sequence  of preprocessing
                     14: tokens that replaces the operand throughout the macro.
                     15: 
                     16: For example, the consider the macro:
                     17: 
                     18: 
                     19:         #define display(x) show((long)(x), #x)
                     20: 
                     21: 
                     22: When the preprocessor reads the following line
                     23: 
                     24: 
                     25:         display(abs(-5));
                     26: 
                     27: 
                     28: it replaces it with the following:
                     29: 
                     30: 
                     31:         show((long)(abs(-5)), "abs(-5)");
                     32: 
                     33: 
                     34: Here, the  preprocessor replaced #x  with  a string  literal that
                     35: gives the sequence of token that replaces x.
                     36: 
                     37: The following rules apply to interpreting the # operator:
                     38: 
                     39: 11.  If a  sequence of  white-space  characters occurs  within the
                     40:    preprocessing tokens that replace the argument, it is replaced
                     41:    with one space character.
                     42: 
                     43: 22.  All  white-space  characters  that  occur  before  the  first
                     44:    preprocessing token and after the last preprocessing token are
                     45:    deleted.
                     46: 
                     47: 33.  The   original  spelling  of  the   preprocessing  tokens  is
                     48:    preserved.   This means  that you must  take care  to preserve
                     49:    certain characters: a  backslash `\' should be inserted before
                     50:    every  quotation mark  `"' that  marks  a string  literal, and
                     51:    before every backslash that introduces a character constant.
                     52: 
                     53: ***** Example *****
                     54: 
                     55: The  following  uses the  operator  # to  display  the result  of
                     56: several mathematics routines.
                     57: 
                     58: 
                     59: 
                     60: 
                     61: 
                     62: 
                     63: 
                     64: COHERENT Lexicon                                           Page 1
                     65: 
                     66: 
                     67: 
                     68: 
                     69: #                     Preprocessing Operator                    #
                     70: 
                     71: 
                     72: 
                     73: #include <errno.h>
                     74: #include <math.h>
                     75: #include <stdio.h>
                     76: 
                     77: 
                     78: 
                     79: void show(value, name)
                     80: double value, char *name;
                     81: {
                     82:         if (errno)
                     83:                 perror(name);
                     84:         else
                     85:                 printf("%10g %s\n", value, name);
                     86:         errno = 0;
                     87: }
                     88: 
                     89: 
                     90: 
                     91: #define display(x) show((double)(x), #x)
                     92: 
                     93: 
                     94: 
                     95: main()
                     96: {
                     97:         extern char *gets();
                     98:         double x;
                     99:         char string[64];
                    100: 
                    101: 
                    102: 
                    103:         for(;;) {
                    104:                 printf("Enter a number: ");
                    105:                 fflush(stdout);
                    106:                 if(gets(string) == NULL)
                    107:                         break;
                    108: 
                    109: 
                    110: 
                    111:                 x = atof(string);
                    112:                 display(x);
                    113:                 display(cos(x));
                    114:                 display(sin(x));
                    115:                 display(tan(x));
                    116:                 display(acos(cos(x)));
                    117:         }
                    118: }
                    119: 
                    120: 
                    121: ***** See Also *****
                    122: 
                    123: ##, #define, C preprocessor
                    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.