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