![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to printgprof.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / gprof|
Return to printgprof.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / gprof |
1.1 ! root 1: /* ! 2: * Copyright (c) 1983 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: */ ! 6: ! 7: #ifndef lint ! 8: static char sccsid[] = "@(#)printgprof.c 5.1 (Berkeley) 6/4/85"; ! 9: #endif not lint ! 10: ! 11: #include "gprof.h" ! 12: ! 13: printprof() ! 14: { ! 15: register nltype *np; ! 16: nltype **sortednlp; ! 17: int index; ! 18: ! 19: actime = 0.0; ! 20: printf( "\f\n" ); ! 21: flatprofheader(); ! 22: /* ! 23: * Sort the symbol table in by time ! 24: */ ! 25: sortednlp = (nltype **) calloc( nname , sizeof(nltype *) ); ! 26: if ( sortednlp == (nltype **) 0 ) { ! 27: fprintf( stderr , "[printprof] ran out of memory for time sorting\n" ); ! 28: } ! 29: for ( index = 0 ; index < nname ; index += 1 ) { ! 30: sortednlp[ index ] = &nl[ index ]; ! 31: } ! 32: qsort( sortednlp , nname , sizeof(nltype *) , timecmp ); ! 33: for ( index = 0 ; index < nname ; index += 1 ) { ! 34: np = sortednlp[ index ]; ! 35: flatprofline( np ); ! 36: } ! 37: actime = 0.0; ! 38: cfree( sortednlp ); ! 39: } ! 40: ! 41: timecmp( npp1 , npp2 ) ! 42: nltype **npp1, **npp2; ! 43: { ! 44: double timediff; ! 45: long calldiff; ! 46: ! 47: timediff = (*npp2) -> time - (*npp1) -> time; ! 48: if ( timediff > 0.0 ) ! 49: return 1 ; ! 50: if ( timediff < 0.0 ) ! 51: return -1; ! 52: calldiff = (*npp2) -> ncall - (*npp1) -> ncall; ! 53: if ( calldiff > 0 ) ! 54: return 1; ! 55: if ( calldiff < 0 ) ! 56: return -1; ! 57: return( strcmp( (*npp1) -> name , (*npp2) -> name ) ); ! 58: } ! 59: ! 60: /* ! 61: * header for flatprofline ! 62: */ ! 63: flatprofheader() ! 64: { ! 65: ! 66: if ( bflag ) { ! 67: printblurb( FLAT_BLURB ); ! 68: } ! 69: printf( "\ngranularity: each sample hit covers %d byte(s)" , ! 70: (long) scale * sizeof(UNIT) ); ! 71: if ( totime > 0.0 ) { ! 72: printf( " for %.2f%% of %.2f seconds\n\n" , ! 73: 100.0/totime , totime / hz ); ! 74: } else { ! 75: printf( " no time accumulated\n\n" ); ! 76: /* ! 77: * this doesn't hurt sinc eall the numerators will be zero. ! 78: */ ! 79: totime = 1.0; ! 80: } ! 81: printf( "%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s %-8.8s\n" , ! 82: "% " , "cumulative" , "self " , "" , "self " , "total " , "" ); ! 83: printf( "%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s %-8.8s\n" , ! 84: "time" , "seconds " , "seconds" , "calls" , ! 85: "ms/call" , "ms/call" , "name" ); ! 86: } ! 87: ! 88: flatprofline( np ) ! 89: register nltype *np; ! 90: { ! 91: ! 92: if ( zflag == 0 && np -> ncall == 0 && np -> time == 0 ) { ! 93: return; ! 94: } ! 95: actime += np -> time; ! 96: printf( "%5.1f %10.2f %8.2f" , ! 97: 100 * np -> time / totime , actime / hz , np -> time / hz ); ! 98: if ( np -> ncall != 0 ) { ! 99: printf( " %8d %8.2f %8.2f " , np -> ncall , ! 100: 1000 * np -> time / hz / np -> ncall , ! 101: 1000 * ( np -> time + np -> childtime ) / hz / np -> ncall ); ! 102: } else { ! 103: printf( " %8.8s %8.8s %8.8s " , "" , "" , "" ); ! 104: } ! 105: printname( np ); ! 106: printf( "\n" ); ! 107: } ! 108: ! 109: gprofheader() ! 110: { ! 111: ! 112: if ( bflag ) { ! 113: printblurb( CALLG_BLURB ); ! 114: } ! 115: printf( "\ngranularity: each sample hit covers %d byte(s)" , ! 116: (long) scale * sizeof(UNIT) ); ! 117: if ( printtime > 0.0 ) { ! 118: printf( " for %.2f%% of %.2f seconds\n\n" , ! 119: 100.0/printtime , printtime / hz ); ! 120: } else { ! 121: printf( " no time propagated\n\n" ); ! 122: /* ! 123: * this doesn't hurt, since all the numerators will be 0.0 ! 124: */ ! 125: printtime = 1.0; ! 126: } ! 127: printf( "%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s %-8.8s\n" , ! 128: "" , "" , "" , "" , "called" , "total" , "parents" , "" ); ! 129: printf( "%-6.6s %5.5s %7.7s %11.11s %7.7s+%-7.7s %-8.8s\t%5.5s\n" , ! 130: "index" , "%time" , "self" , "descendents" , ! 131: "called" , "self" , "name" , "index" ); ! 132: printf( "%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s %-8.8s\n" , ! 133: "" , "" , "" , "" , "called" , "total" , "children" , "" ); ! 134: printf( "\n" ); ! 135: } ! 136: ! 137: gprofline( np ) ! 138: register nltype *np; ! 139: { ! 140: char kirkbuffer[ BUFSIZ ]; ! 141: ! 142: sprintf( kirkbuffer , "[%d]" , np -> index ); ! 143: printf( "%-6.6s %5.1f %7.2f %11.2f" , ! 144: kirkbuffer , ! 145: 100 * ( np -> propself + np -> propchild ) / printtime , ! 146: np -> propself / hz , ! 147: np -> propchild / hz ); ! 148: if ( ( np -> ncall + np -> selfcalls ) != 0 ) { ! 149: printf( " %7d" , np -> ncall ); ! 150: if ( np -> selfcalls != 0 ) { ! 151: printf( "+%-7d " , np -> selfcalls ); ! 152: } else { ! 153: printf( " %7.7s " , "" ); ! 154: } ! 155: } else { ! 156: printf( " %7.7s %7.7s " , "" , "" ); ! 157: } ! 158: printname( np ); ! 159: printf( "\n" ); ! 160: } ! 161: ! 162: printgprof(timesortnlp) ! 163: nltype **timesortnlp; ! 164: { ! 165: int index; ! 166: nltype *parentp; ! 167: ! 168: /* ! 169: * Print out the structured profiling list ! 170: */ ! 171: gprofheader(); ! 172: for ( index = 0 ; index < nname + ncycle ; index ++ ) { ! 173: parentp = timesortnlp[ index ]; ! 174: if ( zflag == 0 && ! 175: parentp -> ncall == 0 && ! 176: parentp -> selfcalls == 0 && ! 177: parentp -> propself == 0 && ! 178: parentp -> propchild == 0 ) { ! 179: continue; ! 180: } ! 181: if ( ! parentp -> printflag ) { ! 182: continue; ! 183: } ! 184: if ( parentp -> name == 0 && parentp -> cycleno != 0 ) { ! 185: /* ! 186: * cycle header ! 187: */ ! 188: printcycle( parentp ); ! 189: printmembers( parentp ); ! 190: } else { ! 191: printparents( parentp ); ! 192: gprofline( parentp ); ! 193: printchildren( parentp ); ! 194: } ! 195: printf( "\n" ); ! 196: printf( "-----------------------------------------------\n" ); ! 197: printf( "\n" ); ! 198: } ! 199: cfree( timesortnlp ); ! 200: } ! 201: ! 202: /* ! 203: * sort by decreasing propagated time ! 204: * if times are equal, but one is a cycle header, ! 205: * say that's first (e.g. less, i.e. -1). ! 206: * if one's name doesn't have an underscore and the other does, ! 207: * say the one is first. ! 208: * all else being equal, sort by names. ! 209: */ ! 210: int ! 211: totalcmp( npp1 , npp2 ) ! 212: nltype **npp1; ! 213: nltype **npp2; ! 214: { ! 215: register nltype *np1 = *npp1; ! 216: register nltype *np2 = *npp2; ! 217: double diff; ! 218: ! 219: diff = ( np1 -> propself + np1 -> propchild ) ! 220: - ( np2 -> propself + np2 -> propchild ); ! 221: if ( diff < 0.0 ) ! 222: return 1; ! 223: if ( diff > 0.0 ) ! 224: return -1; ! 225: if ( np1 -> name == 0 && np1 -> cycleno != 0 ) ! 226: return -1; ! 227: if ( np2 -> name == 0 && np2 -> cycleno != 0 ) ! 228: return 1; ! 229: if ( np1 -> name == 0 ) ! 230: return -1; ! 231: if ( np2 -> name == 0 ) ! 232: return 1; ! 233: if ( *(np1 -> name) != '_' && *(np2 -> name) == '_' ) ! 234: return -1; ! 235: if ( *(np1 -> name) == '_' && *(np2 -> name) != '_' ) ! 236: return 1; ! 237: if ( np1 -> ncall > np2 -> ncall ) ! 238: return -1; ! 239: if ( np1 -> ncall < np2 -> ncall ) ! 240: return 1; ! 241: return strcmp( np1 -> name , np2 -> name ); ! 242: } ! 243: ! 244: printparents( childp ) ! 245: nltype *childp; ! 246: { ! 247: nltype *parentp; ! 248: arctype *arcp; ! 249: nltype *cycleheadp; ! 250: ! 251: if ( childp -> cyclehead != 0 ) { ! 252: cycleheadp = childp -> cyclehead; ! 253: } else { ! 254: cycleheadp = childp; ! 255: } ! 256: if ( childp -> parents == 0 ) { ! 257: printf( "%6.6s %5.5s %7.7s %11.11s %7.7s %7.7s <spontaneous>\n" , ! 258: "" , "" , "" , "" , "" , "" ); ! 259: return; ! 260: } ! 261: sortparents( childp ); ! 262: for ( arcp = childp -> parents ; arcp ; arcp = arcp -> arc_parentlist ) { ! 263: parentp = arcp -> arc_parentp; ! 264: if ( childp == parentp || ! 265: ( childp->cycleno != 0 && parentp->cycleno == childp->cycleno ) ) { ! 266: /* ! 267: * selfcall or call among siblings ! 268: */ ! 269: printf( "%6.6s %5.5s %7.7s %11.11s %7d %7.7s " , ! 270: "" , "" , "" , "" , ! 271: arcp -> arc_count , "" ); ! 272: printname( parentp ); ! 273: printf( "\n" ); ! 274: } else { ! 275: /* ! 276: * regular parent of child ! 277: */ ! 278: printf( "%6.6s %5.5s %7.2f %11.2f %7d/%-7d " , ! 279: "" , "" , ! 280: arcp -> arc_time / hz , arcp -> arc_childtime / hz , ! 281: arcp -> arc_count , cycleheadp -> ncall ); ! 282: printname( parentp ); ! 283: printf( "\n" ); ! 284: } ! 285: } ! 286: } ! 287: ! 288: printchildren( parentp ) ! 289: nltype *parentp; ! 290: { ! 291: nltype *childp; ! 292: arctype *arcp; ! 293: ! 294: sortchildren( parentp ); ! 295: arcp = parentp -> children; ! 296: for ( arcp = parentp -> children ; arcp ; arcp = arcp -> arc_childlist ) { ! 297: childp = arcp -> arc_childp; ! 298: if ( childp == parentp || ! 299: ( childp->cycleno != 0 && childp->cycleno == parentp->cycleno ) ) { ! 300: /* ! 301: * self call or call to sibling ! 302: */ ! 303: printf( "%6.6s %5.5s %7.7s %11.11s %7d %7.7s " , ! 304: "" , "" , "" , "" , arcp -> arc_count , "" ); ! 305: printname( childp ); ! 306: printf( "\n" ); ! 307: } else { ! 308: /* ! 309: * regular child of parent ! 310: */ ! 311: printf( "%6.6s %5.5s %7.2f %11.2f %7d/%-7d " , ! 312: "" , "" , ! 313: arcp -> arc_time / hz , arcp -> arc_childtime / hz , ! 314: arcp -> arc_count , childp -> cyclehead -> ncall ); ! 315: printname( childp ); ! 316: printf( "\n" ); ! 317: } ! 318: } ! 319: } ! 320: ! 321: printname( selfp ) ! 322: nltype *selfp; ! 323: { ! 324: ! 325: if ( selfp -> name != 0 ) { ! 326: printf( "%s" , selfp -> name ); ! 327: # ifdef DEBUG ! 328: if ( debug & DFNDEBUG ) { ! 329: printf( "{%d} " , selfp -> toporder ); ! 330: } ! 331: if ( debug & PROPDEBUG ) { ! 332: printf( "%5.2f%% " , selfp -> propfraction ); ! 333: } ! 334: # endif DEBUG ! 335: } ! 336: if ( selfp -> cycleno != 0 ) { ! 337: printf( " <cycle %d>" , selfp -> cycleno ); ! 338: } ! 339: if ( selfp -> index != 0 ) { ! 340: if ( selfp -> printflag ) { ! 341: printf( " [%d]" , selfp -> index ); ! 342: } else { ! 343: printf( " (%d)" , selfp -> index ); ! 344: } ! 345: } ! 346: } ! 347: ! 348: sortchildren( parentp ) ! 349: nltype *parentp; ! 350: { ! 351: arctype *arcp; ! 352: arctype *detachedp; ! 353: arctype sorted; ! 354: arctype *prevp; ! 355: ! 356: /* ! 357: * unlink children from parent, ! 358: * then insertion sort back on to sorted's children. ! 359: * *arcp the arc you have detached and are inserting. ! 360: * *detachedp the rest of the arcs to be sorted. ! 361: * sorted arc list onto which you insertion sort. ! 362: * *prevp arc before the arc you are comparing. ! 363: */ ! 364: sorted.arc_childlist = 0; ! 365: for ( (arcp = parentp -> children)&&(detachedp = arcp -> arc_childlist); ! 366: arcp ; ! 367: (arcp = detachedp)&&(detachedp = detachedp -> arc_childlist)) { ! 368: /* ! 369: * consider *arcp as disconnected ! 370: * insert it into sorted ! 371: */ ! 372: for ( prevp = &sorted ; ! 373: prevp -> arc_childlist ; ! 374: prevp = prevp -> arc_childlist ) { ! 375: if ( arccmp( arcp , prevp -> arc_childlist ) != LESSTHAN ) { ! 376: break; ! 377: } ! 378: } ! 379: arcp -> arc_childlist = prevp -> arc_childlist; ! 380: prevp -> arc_childlist = arcp; ! 381: } ! 382: /* ! 383: * reattach sorted children to parent ! 384: */ ! 385: parentp -> children = sorted.arc_childlist; ! 386: } ! 387: ! 388: sortparents( childp ) ! 389: nltype *childp; ! 390: { ! 391: arctype *arcp; ! 392: arctype *detachedp; ! 393: arctype sorted; ! 394: arctype *prevp; ! 395: ! 396: /* ! 397: * unlink parents from child, ! 398: * then insertion sort back on to sorted's parents. ! 399: * *arcp the arc you have detached and are inserting. ! 400: * *detachedp the rest of the arcs to be sorted. ! 401: * sorted arc list onto which you insertion sort. ! 402: * *prevp arc before the arc you are comparing. ! 403: */ ! 404: sorted.arc_parentlist = 0; ! 405: for ( (arcp = childp -> parents)&&(detachedp = arcp -> arc_parentlist); ! 406: arcp ; ! 407: (arcp = detachedp)&&(detachedp = detachedp -> arc_parentlist)) { ! 408: /* ! 409: * consider *arcp as disconnected ! 410: * insert it into sorted ! 411: */ ! 412: for ( prevp = &sorted ; ! 413: prevp -> arc_parentlist ; ! 414: prevp = prevp -> arc_parentlist ) { ! 415: if ( arccmp( arcp , prevp -> arc_parentlist ) != GREATERTHAN ) { ! 416: break; ! 417: } ! 418: } ! 419: arcp -> arc_parentlist = prevp -> arc_parentlist; ! 420: prevp -> arc_parentlist = arcp; ! 421: } ! 422: /* ! 423: * reattach sorted arcs to child ! 424: */ ! 425: childp -> parents = sorted.arc_parentlist; ! 426: } ! 427: ! 428: /* ! 429: * print a cycle header ! 430: */ ! 431: printcycle( cyclep ) ! 432: nltype *cyclep; ! 433: { ! 434: char kirkbuffer[ BUFSIZ ]; ! 435: ! 436: sprintf( kirkbuffer , "[%d]" , cyclep -> index ); ! 437: printf( "%-6.6s %5.1f %7.2f %11.2f %7d" , ! 438: kirkbuffer , ! 439: 100 * ( cyclep -> propself + cyclep -> propchild ) / printtime , ! 440: cyclep -> propself / hz , ! 441: cyclep -> propchild / hz , ! 442: cyclep -> ncall ); ! 443: if ( cyclep -> selfcalls != 0 ) { ! 444: printf( "+%-7d" , cyclep -> selfcalls ); ! 445: } else { ! 446: printf( " %7.7s" , "" ); ! 447: } ! 448: printf( " <cycle %d as a whole>\t[%d]\n" , ! 449: cyclep -> cycleno , cyclep -> index ); ! 450: } ! 451: ! 452: /* ! 453: * print the members of a cycle ! 454: */ ! 455: printmembers( cyclep ) ! 456: nltype *cyclep; ! 457: { ! 458: nltype *memberp; ! 459: ! 460: sortmembers( cyclep ); ! 461: for ( memberp = cyclep -> cnext ; memberp ; memberp = memberp -> cnext ) { ! 462: printf( "%6.6s %5.5s %7.2f %11.2f %7d" , ! 463: "" , "" , memberp -> propself / hz , memberp -> propchild / hz , ! 464: memberp -> ncall ); ! 465: if ( memberp -> selfcalls != 0 ) { ! 466: printf( "+%-7d" , memberp -> selfcalls ); ! 467: } else { ! 468: printf( " %7.7s" , "" ); ! 469: } ! 470: printf( " " ); ! 471: printname( memberp ); ! 472: printf( "\n" ); ! 473: } ! 474: } ! 475: ! 476: /* ! 477: * sort members of a cycle ! 478: */ ! 479: sortmembers( cyclep ) ! 480: nltype *cyclep; ! 481: { ! 482: nltype *todo; ! 483: nltype *doing; ! 484: nltype *prev; ! 485: ! 486: /* ! 487: * detach cycle members from cyclehead, ! 488: * and insertion sort them back on. ! 489: */ ! 490: todo = cyclep -> cnext; ! 491: cyclep -> cnext = 0; ! 492: for ( (doing = todo)&&(todo = doing -> cnext); ! 493: doing ; ! 494: (doing = todo )&&(todo = doing -> cnext )){ ! 495: for ( prev = cyclep ; prev -> cnext ; prev = prev -> cnext ) { ! 496: if ( membercmp( doing , prev -> cnext ) == GREATERTHAN ) { ! 497: break; ! 498: } ! 499: } ! 500: doing -> cnext = prev -> cnext; ! 501: prev -> cnext = doing; ! 502: } ! 503: } ! 504: ! 505: /* ! 506: * major sort is on propself + propchild, ! 507: * next is sort on ncalls + selfcalls. ! 508: */ ! 509: int ! 510: membercmp( this , that ) ! 511: nltype *this; ! 512: nltype *that; ! 513: { ! 514: double thistime = this -> propself + this -> propchild; ! 515: double thattime = that -> propself + that -> propchild; ! 516: long thiscalls = this -> ncall + this -> selfcalls; ! 517: long thatcalls = that -> ncall + that -> selfcalls; ! 518: ! 519: if ( thistime > thattime ) { ! 520: return GREATERTHAN; ! 521: } ! 522: if ( thistime < thattime ) { ! 523: return LESSTHAN; ! 524: } ! 525: if ( thiscalls > thatcalls ) { ! 526: return GREATERTHAN; ! 527: } ! 528: if ( thiscalls < thatcalls ) { ! 529: return LESSTHAN; ! 530: } ! 531: return EQUALTO; ! 532: } ! 533: /* ! 534: * compare two arcs to/from the same child/parent. ! 535: * - if one arc is a self arc, it's least. ! 536: * - if one arc is within a cycle, it's less than. ! 537: * - if both arcs are within a cycle, compare arc counts. ! 538: * - if neither arc is within a cycle, compare with ! 539: * arc_time + arc_childtime as major key ! 540: * arc count as minor key ! 541: */ ! 542: int ! 543: arccmp( thisp , thatp ) ! 544: arctype *thisp; ! 545: arctype *thatp; ! 546: { ! 547: nltype *thisparentp = thisp -> arc_parentp; ! 548: nltype *thischildp = thisp -> arc_childp; ! 549: nltype *thatparentp = thatp -> arc_parentp; ! 550: nltype *thatchildp = thatp -> arc_childp; ! 551: double thistime; ! 552: double thattime; ! 553: ! 554: # ifdef DEBUG ! 555: if ( debug & TIMEDEBUG ) { ! 556: printf( "[arccmp] " ); ! 557: printname( thisparentp ); ! 558: printf( " calls " ); ! 559: printname ( thischildp ); ! 560: printf( " %f + %f %d/%d\n" , ! 561: thisp -> arc_time , thisp -> arc_childtime , ! 562: thisp -> arc_count , thischildp -> ncall ); ! 563: printf( "[arccmp] " ); ! 564: printname( thatparentp ); ! 565: printf( " calls " ); ! 566: printname( thatchildp ); ! 567: printf( " %f + %f %d/%d\n" , ! 568: thatp -> arc_time , thatp -> arc_childtime , ! 569: thatp -> arc_count , thatchildp -> ncall ); ! 570: printf( "\n" ); ! 571: } ! 572: # endif DEBUG ! 573: if ( thisparentp == thischildp ) { ! 574: /* this is a self call */ ! 575: return LESSTHAN; ! 576: } ! 577: if ( thatparentp == thatchildp ) { ! 578: /* that is a self call */ ! 579: return GREATERTHAN; ! 580: } ! 581: if ( thisparentp -> cycleno != 0 && thischildp -> cycleno != 0 && ! 582: thisparentp -> cycleno == thischildp -> cycleno ) { ! 583: /* this is a call within a cycle */ ! 584: if ( thatparentp -> cycleno != 0 && thatchildp -> cycleno != 0 && ! 585: thatparentp -> cycleno == thatchildp -> cycleno ) { ! 586: /* that is a call within the cycle, too */ ! 587: if ( thisp -> arc_count < thatp -> arc_count ) { ! 588: return LESSTHAN; ! 589: } ! 590: if ( thisp -> arc_count > thatp -> arc_count ) { ! 591: return GREATERTHAN; ! 592: } ! 593: return EQUALTO; ! 594: } else { ! 595: /* that isn't a call within the cycle */ ! 596: return LESSTHAN; ! 597: } ! 598: } else { ! 599: /* this isn't a call within a cycle */ ! 600: if ( thatparentp -> cycleno != 0 && thatchildp -> cycleno != 0 && ! 601: thatparentp -> cycleno == thatchildp -> cycleno ) { ! 602: /* that is a call within a cycle */ ! 603: return GREATERTHAN; ! 604: } else { ! 605: /* neither is a call within a cycle */ ! 606: thistime = thisp -> arc_time + thisp -> arc_childtime; ! 607: thattime = thatp -> arc_time + thatp -> arc_childtime; ! 608: if ( thistime < thattime ) ! 609: return LESSTHAN; ! 610: if ( thistime > thattime ) ! 611: return GREATERTHAN; ! 612: if ( thisp -> arc_count < thatp -> arc_count ) ! 613: return LESSTHAN; ! 614: if ( thisp -> arc_count > thatp -> arc_count ) ! 615: return GREATERTHAN; ! 616: return EQUALTO; ! 617: } ! 618: } ! 619: } ! 620: ! 621: printblurb( blurbname ) ! 622: char *blurbname; ! 623: { ! 624: FILE *blurbfile; ! 625: int input; ! 626: ! 627: blurbfile = fopen( blurbname , "r" ); ! 628: if ( blurbfile == NULL ) { ! 629: perror( blurbname ); ! 630: return; ! 631: } ! 632: while ( ( input = getc( blurbfile ) ) != EOF ) { ! 633: putchar( input ); ! 634: } ! 635: fclose( blurbfile ); ! 636: } ! 637: ! 638: int ! 639: namecmp( npp1 , npp2 ) ! 640: nltype **npp1, **npp2; ! 641: { ! 642: return( strcmp( (*npp1) -> name , (*npp2) -> name ) ); ! 643: } ! 644: ! 645: printindex() ! 646: { ! 647: nltype **namesortnlp; ! 648: register nltype *nlp; ! 649: int index, nnames, todo, i, j; ! 650: char peterbuffer[ BUFSIZ ]; ! 651: ! 652: /* ! 653: * Now, sort regular function name alphbetically ! 654: * to create an index. ! 655: */ ! 656: namesortnlp = (nltype **) calloc( nname + ncycle , sizeof(nltype *) ); ! 657: if ( namesortnlp == (nltype **) 0 ) { ! 658: fprintf( stderr , "%s: ran out of memory for sorting\n" , whoami ); ! 659: } ! 660: for ( index = 0 , nnames = 0 ; index < nname ; index++ ) { ! 661: if ( zflag == 0 && nl[index].ncall == 0 && nl[index].time == 0 ) ! 662: continue; ! 663: namesortnlp[nnames++] = &nl[index]; ! 664: } ! 665: qsort( namesortnlp , nnames , sizeof(nltype *) , namecmp ); ! 666: for ( index = 1 , todo = nnames ; index <= ncycle ; index++ ) { ! 667: namesortnlp[todo++] = &cyclenl[index]; ! 668: } ! 669: printf( "\f\nIndex by function name\n\n" ); ! 670: index = ( todo + 2 ) / 3; ! 671: for ( i = 0; i < index ; i++ ) { ! 672: for ( j = i; j < todo ; j += index ) { ! 673: nlp = namesortnlp[ j ]; ! 674: if ( nlp -> printflag ) { ! 675: sprintf( peterbuffer , "[%d]" , nlp -> index ); ! 676: } else { ! 677: sprintf( peterbuffer , "(%d)" , nlp -> index ); ! 678: } ! 679: if ( j < nnames ) { ! 680: printf( "%6.6s %-19.19s" , peterbuffer , nlp -> name ); ! 681: } else { ! 682: printf( "%6.6s " , peterbuffer ); ! 683: sprintf( peterbuffer , "<cycle %d>" , nlp -> cycleno ); ! 684: printf( "%-19.19s" , peterbuffer ); ! 685: } ! 686: } ! 687: printf( "\n" ); ! 688: } ! 689: cfree( namesortnlp ); ! 690: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.