home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / tools / scc / sample.log < prev    next >
Encoding:
Text File  |  1994-06-04  |  20.6 KB  |  507 lines
  1. #************************************ 
  2. #                                     
  3. #     Software Change Control (SCC)   
  4. #        Version 1.09   06-21-91                           
  5. #                                     
  6. #            Softime Systems          
  7. #             P.O Box 2447            
  8. #     Lake Ronkonkoma LI. NY 11779    
  9. #            (516) 981-8386           
  10. #                                     
  11. # Copyright (c) 1990-91 Walter Erickson
  12. #          ALL RIGHTS RESERVED
  13. #                                     
  14. #                                     
  15. #   Out LOG               = sample.log
  16. #         type            = LONG
  17. #         day/month/year  = 4/6/1994  
  18. #         hr:min:sec      = 22:16:9  
  19. #                                     
  20. #   In  MASTER (old)      = sample.v1
  21. #         lines           = 284
  22. #         length          = 9329       
  23. #         day/month/year  = 23/6/1991  
  24. #         hr:min:sec      = 21:20:5  
  25. #         hash            = 532800
  26. #                                     
  27. #   In  MASTER (new)      = sample.v2
  28. #         lines           = 360
  29. #         length          = 12687       
  30. #         day/month/year  = 23/6/1991  
  31. #         hr:min:sec      = 21:17:9  
  32. #         hash            = 765596
  33. #                                     
  34. #   ------- SCC Build Options ------- 
  35. #                                     
  36. #   Strip   End White = No
  37. #   Ignore  Case      = Yes
  38. #   Ignore  White     = Yes
  39. #   Ignore  Numbers   = Yes
  40. #                                     
  41. # User ID# SW1  0693-010106                                  
  42. #************************************ 
  43.  
  44.  
  45. #
  46. #Change 1
  47. #
  48. # ... line 0: is a place-holder for sample.v1
  49. # ... 71 (New) lines inserted into sample.v2
  50. #
  51. +    1:            *** Please Read the following information ***
  52. +    2: 
  53. +    3:    You can make this sample.log file by running the batch file named
  54. +    4:  sample.bat (see readme.scc).
  55. +    5:                                                     
  56. +    6:    This file should be viewed from within the SCC VIEW utility.
  57. +    7:  Therefor start SCC by typing in at the prompt "SCC /v,sample.log" or
  58. +    8:  use SCC VIEW menu selection. This will bring up the SCC VIEW utility
  59. +    9:  with this file displayed. Then continue reading the following.
  60. +   10: 
  61. +   11:    The comments on the right hand side such as "Ignore numbers",
  62. +   12:  "Ignore white space" are only to aid in the
  63. +   13: 
  64. +   14:                                                     Ignore numbers       
  65. +   15:                                                     Ignore white space       
  66. +   16: 
  67. +   17:  interpretation of how various option settings has on the SCC generated
  68. +   18:  log. These comments are put in as part of the original text file and
  69. +   19:  are not generated by SCC.             
  70. +   20: 
  71. +   21:    Some of the "LOG" options set (see above log header) for this
  72. +   22:  example should be set as:
  73. +   23: 
  74. +   24:      Strip  End White = No     strip ending white space from Old/New
  75. +   25:      Ignore Case      = Yes
  76. +   26:      Ignore White     = Yes
  77. +   27:      Ignore Numbers   = Yes
  78. +   28: 
  79. +   29:   If you have a color monitor, please note:
  80. +   30: 
  81. +   31:   1) Main "text" screen attributes   (foreground/background):
  82. +   32:      
  83. +   33:         o CONTROL      = High  White & Blue  Background.
  84. +   34:         o Old Document = Light White & Blue  Background.
  85. +   35:         o New Document = Yellow      & Blue  Background.
  86. +   36: 
  87. +   37:   2) Cursor line attributes:
  88. +   38: 
  89. +   39:         o Cursor       = Black       & Cyan  Background.
  90. +   40: 
  91. +   41:   For the help menu, press the F1 key.
  92. +   42: 
  93. +   43:      When the cursor is on a Log line and its left control side has
  94. +   44:   either a '-', or '+' then one of the following line operations apply.
  95. +   45:   
  96. +   46:   Log status   Operation          
  97. +   47:   ----------   ---------          
  98. +   48:          '-'   " Deleted  Line   "
  99. +   49:          '+'   " Inserted Line   "
  100. +   50: 
  101. +   51:      When the cursor is on a Log line and its left control side equals
  102. +   52:   a blank character ' ' then both old/new lines are identical except
  103. +   53:   for one or more of the following attributes.
  104. +   54: 
  105. +   55:   Log status   Operation          
  106. +   56:   ----------   ---------         
  107. +   57:          ' '   Common Lines      old/new lines are identical
  108. +   58:          ' '   Moved  Line       old/new lines are identical
  109. +   59:          ' '   Ignore White Sp   
  110. +   60:          ' '   Ignore Numbers    
  111. +   61:          ' '   Ignore Case       
  112. +   62:          ' '   Multi  Match      
  113. +   63: 
  114. +   64:      The above Log status (along with different SCC Log option 
  115. +   65:   settings) can help generate a "filtered" SCC change control report.
  116. +   66:   This report will show what is important (delete or insert status)
  117. +   67:   and what is not important (blank status) in your file.
  118. +   68:      For example you may want to ignore the '-' or '+' (delete or
  119. +   69:   insert) status characters for such lines containing differences of
  120. +   70:   only "White Space", "Upper/Lower Case" etc.
  121. +   71: 
  122.     72:   START OF EXAMPLES.....
  123.     73: 
  124.     74: 
  125.     75: 
  126.     76: 
  127.     77: 
  128. #
  129. #Change 2
  130. #
  131. # ... (at line 7:), 6 lines deleted from sample.v1
  132. # ... 12 (New) lines inserted into sample.v2
  133. #
  134.          * 1-MARCH-89 sample.v1                              Ignore numbers       
  135.          *                                                   moved line       
  136. -        * Function is by Walter Erickson                    old line   (deleted)       
  137.         # i n c l u d e  < s t d i o . h >                   Ignore white space
  138. -             * put a proper terminating '                   close match       
  139.                 #include <string.h>                          Ignore white space       
  140. +   78:                                                      new line   (added)
  141. +   79: /**********************************                  new line   (added)
  142.     80:  *                                                   moved line       
  143. +   81:       * put a poxxper terminoting                    close match 
  144.     82:  * 9-MARCH-90 sample.v2                              Ignore numbers       
  145. +   83:  * INPUT                                             new line   (added)       
  146. +   84:  *   string pointer                                  new line   (added)       
  147. +   85:  *   tab size                                        new line   (added)       
  148. +   86:  *                                                   new line   (added)       
  149. +   87:  * RETURN                                            new line   (added)       
  150.     88: #include <stdio.h>                                   Ignore white space
  151.     89: #include <string.h>                                  Ignore white space       
  152.     90: 
  153.     91: void DE_detab  (char *buffer, int line_size, int tab_size);
  154.     92: 
  155.     93: 
  156.     94: void DE_detab(string, max_lenth, tab_size)
  157.     95: char *string;
  158.     96: int  max_lenth;
  159.     97: 
  160. #
  161. #Change 3
  162. #
  163. # ... (at line 21:), 1 lines deleted from sample.v1
  164. # ... 1 (New) lines inserted into sample.v2
  165. #
  166.         int  tab_size;                                       Strip end white
  167.     98: int  tab_size;                                       Strip end white            
  168.     99: {
  169.    100:    int i;
  170.    101:    int index;
  171.    102:    int lenth;
  172.    103:    int delta;
  173.    104:    int move_from;
  174.    105:    int move_to;
  175.    106: 
  176.    107:   /*-----------------------------------------*
  177. #
  178. #Change 4
  179. #
  180. # ... (at line 31:), 11 lines deleted from sample.v1
  181. # ... 10 (New) lines inserted into sample.v2
  182. #
  183. -          * make for a proper trailing '\0' in string       close match
  184.            *-----------------------------------------*/      moved line
  185. -             * put aa preper termenating '                  close match 
  186. -             string[max_lenth] = '\0';                      old line   (deleted)       
  187.            let string 2 = \"uic\""},                         moved line       
  188.            let string 1 = \"brown\""},                       moved line       
  189. -          now is  y                                         close match
  190.            now is the time                                   Ignore case       
  191.            T h e   q  uic  k                                 Ignore white space
  192.            goto 1234                                         Ignore numbers       
  193.            register unsigned i;                              moved line
  194. +  108:    * make room for a pxoper trailing '\0' string     close match
  195.    109:    *-----------------------------------------*/      moved line
  196.    110:    register unsigned i;                              moved line
  197. +  111:       * put a proper terminating                     close match 
  198.    112:    NOW IS THE TIME                                   Ignore case       
  199. +  113:    Now is  x                                         close match
  200.    114:    The quick                                         Ignore white space
  201.    115:    goto 670                                          Ignore numbers       
  202.    116:    let string 1 = \"brown\""},                       moved line       
  203.    117:    let string 2 = \"uic\""},                         moved line       
  204.    118:   /*--------------------------------------*
  205.    119:    * This lets us reference elements of array as 1 to n
  206.    120:    *--------------------------------------*/
  207.    121:    (char *)base     -= element_width;
  208.    122: 
  209.    123:   /*--------------------------------------*
  210.    124:    * The following assignments to static variables reduce the
  211.    125:    * overhead of subroutine calls later.
  212.    126:    *--------------------------------------*/
  213.    127:    static_width      = element_width;
  214.    128:    static_compare    = compare;
  215.    129:    static_n_elements = n_elements;
  216.    130:    static_base       = base;
  217.    131: 
  218.    132:   /*--------------------------------------*
  219.    133:    * 
  220.    134:    *--------------------------------------*/
  221.    135:    temp_element      = malloc (element_width);
  222.    136: 
  223.    137:    if (temp_element == NULL){
  224. #
  225. #Change 5
  226. #
  227. # ... (at line 62:), 2 lines deleted from sample.v1
  228. #
  229. -              fputs ("Unable to allocate                    old line   (deleted)       
  230. -                   stderr);                                 old line   (deleted)       
  231.    138: 
  232.    139:   /*--------------------------------------*
  233.    140:    * 
  234.    141:    *--------------------------------------*/
  235.    142:    for (i = n_elements; i>1; i--){
  236.    143:        swap (1, i);
  237.    144:        heasaaafy (1, i-1);
  238.    145:    }
  239.    146:  
  240.    147:   /*--------------------------------------*
  241.    148:    * 
  242.    149:    *--------------------------------------*/
  243.    150: }
  244.    151: 
  245.    152: 
  246.    153: 
  247.    154: 
  248.    155: 
  249.    156: 
  250.    157: /*--------------------------------------*
  251.    158:  *
  252.    159:  *--------------------------------------*/
  253.    160: static void pascal
  254.    161: swap (i, j)
  255.    162: unsigned i;
  256.    163: unsigned j;
  257.    164: {
  258.    165:     register int temp_int;
  259.    166:     long         temp_long;
  260.    167: 
  261. #
  262. #Change 6
  263. #
  264. # ... (at line 94:), 2 lines deleted from sample.v1
  265. # ... 2 (New) lines inserted into sample.v2
  266. #
  267. -          The quick                                         close match
  268. -          The qk brown                                      close match
  269. +  168:    The quick brown                                   close match
  270. +  169:    The quick brown                                   close match
  271.    170:     switch (static){
  272.    171: 
  273.    172:         case sizeof (int):                  temp_int = ((int *) static_base) [i];
  274.    173:                            ((int *) static_base) [i] = ((int *) static_base) [j];
  275.    174:                            ((int *) static_base) [j] = temp_int;
  276.    175:                            break;
  277.    176:     
  278.    177:         case sizeof(long):                  temp_long = ((long *) static_base) [i];
  279.    178:                            ((long *) static_base) [i] = ((long *) static_base) [j];
  280.    179:                            ((long *) static_base) [j] = temp_long;
  281.    180:                            break;
  282.    181:     
  283.    182:         case sizeof(char):                   temp_int = ((char *) static_base) [i];
  284.    183:                            ((char *) static_base) [i] = ((char *) static_base) [j];
  285.    184:                            ((char *) static_base) [j] = (char) temp_int;
  286.    185:                            break;
  287.    186:     
  288.    187:         default:           memcpy(temp_element,
  289.    188:                                  (char *)static_base + i*static_width,
  290.    189:                                   static_width);
  291.    190:     
  292.    191:                            memcpy((char *) static_base + i*static_width,
  293.    192:                                   (char *) static_base + j*static_width,
  294.    193:                                   static_width);
  295.    194:     
  296.    195:                            memcpy((char *) static_base + j*static_width,
  297.    196:                                   temp_element,
  298.    197:                                   static_width);
  299.    198:     
  300.    199:                            break;
  301.    200:     }
  302.    201: }
  303.    202: 
  304.    203: 
  305.    204: 
  306.    205: 
  307.    206: 
  308.    207: 
  309.    208: /*--------------------------------------*
  310.    209:  *
  311.    210:  *
  312.    211:  *--------------------------------------*/
  313.    212: static void pascal
  314.    213: buildheap()
  315.    214: {
  316.    215:     register unsigned element_number;
  317.    216:   
  318.    217:    /*--------------------------------------*
  319.    218:     * 
  320.    219:     *--------------------------------------*/
  321.    220:     for (element_number = static_n_elements >> 1;
  322.    221:          element_number >= 1;
  323.    222:          element_number -- ){
  324.    223:   
  325.    224:         heasaaafy(element_number, static_n_elements);
  326.    225:     }
  327.    226: 
  328.    227: }
  329.    228: 
  330.    229: 
  331.    230: 
  332.    231: 
  333.    232: 
  334.    233: 
  335.    234: /*--------------------------------------*
  336.    235:  *
  337.    236:  *
  338.    237:  *--------------------------------------*/
  339.    238: static void pascal
  340.    239: heasaaafy (i,j)
  341.    240: unsigned i;
  342.    241: unsigned j;
  343.    242: {
  344.    243: 
  345.    244:    /*--------------------------------------*
  346.    245:     * The following are static to avoid recursive stack overhead
  347.    246:     *--------------------------------------*/
  348.    247:     static unsigned son1i;
  349.    248:     static unsigned son2i;
  350.    249:     static unsigned k;
  351.    250:   
  352.    251:     static void *pson1;
  353.    252:     static void *pson2;
  354. #
  355. #Change 7
  356. #
  357. # ... (at line 179:), 7 lines deleted from sample.v1
  358. # ... 7 (New) lines inserted into sample.v2
  359. #
  360. -           static void *saaa;                               old line   (deleted)       
  361.                                                              moved line       
  362.             *---------------------------                     moved line       
  363.             pson1 = pointer (son1i);                         Ignore white space       
  364.             saaa    = pointer (i);                           moved line       
  365.             son1i = son1 (i);                                moved line       
  366. -           switch (Count (i, j)){                           close match       
  367. +  253:                                                      new line   (added)       
  368.    254:     *---------------------------                     moved line       
  369.    255:     son1i = son1 (i);                                moved line       
  370. +  256:     switch (child_count (i, j)){                     close match       
  371.    257:     pson1 = pointer        (son1i);                  Ignore white space       
  372.    258:     saaa    = pointer (i);                           moved line       
  373.    259:                                                      moved line       
  374.    260:       case 0:
  375.    261:   
  376.    262:          /*--------------------------------------*
  377.    263:           * 
  378.    264:           *--------------------------------------*/
  379.    265:           break;
  380.    266:   
  381. #
  382. #Change 8
  383. #
  384. # ... (at line 193:), 1 lines deleted from sample.v1
  385. # ... 1 (New) lines inserted into sample.v2
  386. #
  387.               case 2:                                        Strip end white
  388.    267:       case 2:                                        Strip end white 
  389.    268:          /*--------------------------------------*
  390.    269:           * 
  391.    270:           *--------------------------------------*/
  392.    271:           k = (*static_compare) (pson1, pson2) > 0 ? son1i : son2i;
  393.    272:           if ((*static_compare) (saaa, pointer (k)) < 0){
  394.    273:   
  395.    274:              /*--------------------------------------*
  396.    275:               * 
  397.    276:               *--------------------------------------*/
  398.    277:               swap (i, k);
  399.    278:               heasaaafy (k, j);
  400.    279:           }
  401.    280:           break;
  402.    281:   
  403.    282:       case 1:
  404.    283:   
  405.    284:          /*--------------------------------------*
  406.    285:           * 
  407.    286:           *--------------------------------------*/
  408.    287:           if ((*static_compare) (saaa, pson1) < 0){
  409.    288:   
  410.    289:              /*--------------------------------------*
  411.    290:               * 
  412.    291:               *--------------------------------------*/
  413.    292:               swap (i, son1i);
  414.    293:               heasaaafy (son1i, j);
  415.    294:   
  416.    295:           }
  417.    296:           break;
  418.    297:     }
  419.    298: }
  420.    299: 
  421.    300:   /*---------------------------------------------*
  422.    301:    * scan and replace all TAB char within string
  423.    302:    *---------------------------------------------*/
  424.    303:    for (index=0; string[index] && (index<max_lenth); index++){
  425.    304: 
  426.    305:       if (string[index] == '\t'){
  427.    306:          if (tab_size == 0){
  428.    307: 
  429.    308:            /*---------------------------------------------*
  430.    309:             * remove TAB by closing string
  431.    310:             *---------------------------------------------*/
  432.    311:             lenth = strlen(string);
  433.    312: 
  434.    313:             for (i=index; i<=lenth; i++){
  435.    314:                string[i] = string[i+1];
  436.    315:             }
  437.    316:             index--;
  438.    317:             continue;
  439.    318:          }
  440.    319: 
  441.    320:         /*---------------------------------------------*
  442. #
  443. #Change 9
  444. #
  445. # ... (at line 247:), 1 lines deleted from sample.v1
  446. # ... 1 (New) lines inserted into sample.v2
  447. #
  448.                  * REPLACE TAB CHAR WITH A                   Ignore case       
  449.    321:          * replace Tab char with a                   Ignore case       
  450.    322:          *---------------------------------------------*/
  451.    323:          string[index] = ' ';
  452.    324:          delta = tab_size-((index+1) % tab_size);
  453.    325: 
  454.    326:          if (delta && (delta < tab_size)){
  455.    327: 
  456. #
  457. #Change 10
  458. #
  459. # ... line 253: is a place-holder for sample.v1
  460. # ... 3 (New) lines inserted into sample.v2
  461. #
  462. +  328:            /*-----------------                       new line   (added)       
  463. +  329:             * open up the stri                       new line   (added)       
  464. +  330:             *-----------------                       new line   (added)       
  465.    331:             index++;
  466.    332:             move_from = strlen(&string[index]) + index + 1;
  467.    333:             move_to   = move_from + delta;
  468.    334:             for ( ;move_from >= index; move_from--, move_to--){
  469.    335:                if (move_to < max_lenth){
  470.    336: 
  471.    337:                  /*---------------------------------------------*
  472.    338:                   * open only within the max_lenth of string
  473.    339:                   *---------------------------------------------*/
  474. #
  475. #Change 11
  476. #
  477. # ... (at line 263:), 1 lines deleted from sample.v1
  478. # ... 1 (New) lines inserted into sample.v2
  479. #
  480.                12345           string[move_to 678]           Ignore numbers       
  481.    340:        5           string[move_to 67867840]          Ignore numbers       
  482.    341:                }
  483.    342:             }
  484.    343: 
  485.    344:            /*---------------------------------------------*
  486.    345:             * replace (delta lenth) with ' ' char within max_lenth 
  487.    346:             *---------------------------------------------*/
  488.    347:             for (delta+=index; (index<delta) && (index<max_lenth); index++){
  489.    348:                string[index] = ' ';
  490.    349:             }
  491.    350:             index--;
  492.    351:          }
  493.    352:       }
  494.    353:    }
  495.    354:    if (index >= max_lenth){
  496.    355: 
  497.    356:      /*---------------------------------------------*
  498.    357:       * put a proper terminating '\0' on fully expanded string
  499.    358:       *---------------------------------------------*/
  500.    359:    }
  501. #
  502. #Change 12
  503. #
  504. # ... (at line 283:), 1 lines deleted from sample.v1
  505. #
  506. -       }
  507.