Return to bigpepytest.py CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / pepy

Annotation of 43BSDReno/contrib/isode-beta/pepy/bigpepytest.py, revision 1.1

1.1     ! root        1: -- bigpepytest.py - test out most of the pepy constructs
        !             2: 
        !             3: -- $Header: /f/osi/pepy/RCS/bigpepytest.py,v 7.0 89/11/23 22:11:37 mrose Rel $
        !             4: --
        !             5: --
        !             6: -- $Log:       bigpepytest.py,v $
        !             7: -- Revision 7.0  89/11/23  22:11:37  mrose
        !             8: -- Release 6.0
        !             9: -- 
        !            10: 
        !            11: --
        !            12: --                               NOTICE
        !            13: --
        !            14: --    Acquisition, use, and distribution of this module and related
        !            15: --    materials are subject to the restrictions of a license agreement.
        !            16: --    Consult the Preface in the User's Manual for the full terms of
        !            17: --    this agreement.
        !            18: --
        !            19: --
        !            20: 
        !            21: 
        !            22: BigTest DEFINITIONS ::=
        !            23: 
        !            24: %{
        !            25: #ifndef lint
        !            26: static char *rcsid = "$Header: /f/osi/pepy/RCS/bigpepytest.py,v 7.0 89/11/23 22:11:37 mrose Rel $";
        !            27: #endif
        !            28: 
        !            29: #include <stdio.h>
        !            30: 
        !            31: 
        !            32: static int  count;
        !            33: 
        !            34: static char *myname = "bigpepytest";
        !            35: 
        !            36: 
        !            37: void   adios ();
        !            38: 
        !            39: /*  */
        !            40: 
        !            41: /* ARGSUSED */
        !            42: 
        !            43: main (argc, argv, envp)
        !            44: int    argc;
        !            45: char  **argv,
        !            46:       **envp;
        !            47: {
        !            48:     PE     pe;
        !            49: 
        !            50:     myname = argv[0];
        !            51: 
        !            52:     if (encoder_BigTest_Test1 (&pe, 1, NULL, NULLCP, NULLCP) == NOTOK)
        !            53:        adios (NULLCP, "encoder fails");
        !            54: 
        !            55:     if (printer_BigTest_Test1 (pe, 1, NULLIP, NULLVP, NULLCP) == NOTOK)
        !            56:        adios (NULLCP, "printer fails");
        !            57: 
        !            58:     if (decoder_BigTest_Test1 (pe, 1, NULLIP, NULLVP, NULLCP) == NOTOK)
        !            59:        adios (NULLCP, "decoder fails");
        !            60: 
        !            61:     exit (0);                  /* NOTREACHED */
        !            62: }
        !            63: %}
        !            64: 
        !            65: BEGIN
        !            66: 
        !            67: 
        !            68: ENCODER        encoder
        !            69: 
        !            70: Test1 %{ int fd = rnd (2); %} ::=
        !            71:        SEQUENCE {
        !            72:            boolean
        !            73:                BOOLEAN
        !            74:                [[b rnd(2)]],
        !            75: 
        !            76:            taggedBoolean
        !            77:                [0] BOOLEAN
        !            78:                [[b rnd (2)]],
        !            79: 
        !            80:            implicitTaggedBoolean
        !            81:                [PRIVATE 0] IMPLICIT BOOLEAN
        !            82:                [[b rnd(2)]],
        !            83: 
        !            84:            integer
        !            85:                INTEGER
        !            86:                [[i rnd(10000)]],
        !            87: 
        !            88:            taggedInteger
        !            89:                [APPLICATION 1] INTEGER
        !            90:                [[i rnd(10000)]],
        !            91: 
        !            92:            implicitTaggedInteger
        !            93:                [UNIVERSAL 1] IMPLICIT INTEGER
        !            94:                [[i rnd(10000)]],
        !            95: 
        !            96:            integerOneValue
        !            97:                INTEGER
        !            98:                [[i 1]] { nn(1) },
        !            99: 
        !           100:            taggedIntegerOneValue
        !           101:                [PRIVATE 2] INTEGER
        !           102:                [[i 1]] { nn(1) },
        !           103: 
        !           104:            integerManyValues
        !           105:                INTEGER
        !           106:                [[i rnd(3) + 1]]
        !           107:                { nn1(1), nn2(2), nn3(3) },
        !           108: 
        !           109:            implicitTaggedIntegerManyValues
        !           110:                [2] IMPLICIT INTEGER
        !           111:                [[i rnd(3) + 1]]
        !           112:                { nn1(1), nn2(2), nn3(3) },
        !           113: 
        !           114:            bitstring
        !           115:                %{
        !           116:                   int i;
        !           117:                   $$ = pe_alloc(PE_CLASS_UNIV, PE_FORM_PRIM, PE_PRIM_BITS);
        !           118:                   $$ = prim2bit($$);
        !           119:                   for(i = 0; i < 32; i++)
        !           120:                           if( rnd(2) )
        !           121:                                   (void) bit_on($$, i);
        !           122:                %}
        !           123:                BITSTRING,
        !           124: 
        !           125:            taggedBitstring [UNIVERSAL 3]
        !           126:                %{
        !           127:                   int i;
        !           128:                   $$ = pe_alloc(PE_CLASS_UNIV, PE_FORM_PRIM, PE_PRIM_BITS);
        !           129:                   $$ = prim2bit($$);
        !           130:                   for(i = 0; i < 32; i++)
        !           131:                           if( rnd(2) && rnd(3) )
        !           132:                                   (void) bit_on($$, i);
        !           133:                %}
        !           134:                BITSTRING,
        !           135: 
        !           136:            bitstring2
        !           137:                BIT STRING
        !           138:                [[x int2strb(0177, 8) $ 8]],
        !           139: 
        !           140:            taggedBitstring2
        !           141:                [4] BIT STRING
        !           142:                [[x int2strb(0177, 8) $ 8]],
        !           143: 
        !           144:            implicitTaggedBitstring2
        !           145:                [PRIVATE 4] IMPLICIT BIT STRING
        !           146:                [[x int2strb(0xffff, 16) $ 16]],
        !           147: 
        !           148:            bitstringValue
        !           149:                BIT STRING
        !           150:                [[x int2strb(1, 1) $ 1]]
        !           151:                { nn1(1) },
        !           152: 
        !           153:            taggedBitstringValue
        !           154:                [APPLICATION 5] BIT STRING
        !           155:                [[x int2strb(1, 1) $ 1]]
        !           156:                { nn1(1) },
        !           157: 
        !           158:            bitstringValues
        !           159:                BIT STRING
        !           160:                [[x int2strb(03, 3) $ 3]]
        !           161:                { nn1(1), nn2(2), nn3(3) },
        !           162: 
        !           163:            taggedBitstringValues
        !           164:                [PRIVATE 6] BIT STRING
        !           165:                [[x int2strb(03, 3) $ 3]]
        !           166:                { nn1(1), nn2(2), nn3(3) },
        !           167: 
        !           168:            implicitTaggedBitstringValues
        !           169:                [APPLICATION 6] IMPLICIT BIT STRING
        !           170:                [[x int2strb(03, 3) $ 3]]
        !           171:                { nn1(1), nn2(2), nn3(3) },
        !           172: 
        !           173:            octetstring
        !           174:                OCTET STRING
        !           175:                [[s "hello world"]],
        !           176: 
        !           177:            taggedOctetstring
        !           178:                [UNIVERSAL 7] OCTET STRING
        !           179:                [[s "hello world"]],
        !           180: 
        !           181:            octetstring2
        !           182:                OCTETSTRING
        !           183:                [[s "goodbye world"]],
        !           184: 
        !           185:            implicitTaggedOctetstring2
        !           186:                [PRIVATE 7] IMPLICIT OCTETSTRING
        !           187:                [[o "goodbye world" $ 8]],
        !           188: 
        !           189:            null
        !           190:                NULL,
        !           191: 
        !           192:            taggedNull
        !           193:                [8] NULL,
        !           194: 
        !           195:            implicitTaggedNull
        !           196:                [PRIVATE 8] IMPLICIT NULL,
        !           197: 
        !           198:            sequence
        !           199:                SEQUENCE,
        !           200: 
        !           201:            taggedSequence
        !           202:                [APPLICATION 9] SEQUENCE,
        !           203: 
        !           204:            implicitTaggedSequence
        !           205:                [PRIVATE 9] SEQUENCE,
        !           206: 
        !           207:            sequenceOf
        !           208:                SEQUENCE OF
        !           209:                    <<count = rnd(10); count >= 0; count-->>
        !           210:                    SequenceA,
        !           211: 
        !           212:            taggedSequenceOf
        !           213:                [PRIVATE 10] SEQUENCE OF
        !           214:                    <<count = rnd(10); count >= 0; count-->>
        !           215:                    SequenceA,
        !           216: 
        !           217:            sequenceOf2
        !           218:                SEQUENCEOF
        !           219:                    <<count = rnd(3); count >= 0; count-->>
        !           220:                    SequenceB,
        !           221: 
        !           222:            implicitTaggedSequenceOf2
        !           223:                [10] IMPLICIT SEQUENCEOF
        !           224:                    <<count = rnd(3); count >= 0; count-->>
        !           225:                    SequenceA,
        !           226: 
        !           227:            set
        !           228:                SET,
        !           229: 
        !           230:            taggedSet
        !           231:                [UNIVERSAL 11] SET,
        !           232: 
        !           233:            implicitTaggedSet
        !           234:                [PRIVATE 11] IMPLICIT SET,
        !           235: 
        !           236:            setOf
        !           237:                SET OF
        !           238:                    <<count = rnd(10); count >= 0; count -->>
        !           239:                    SetA,
        !           240: 
        !           241:            taggedSetOf
        !           242:                [12] SET OF
        !           243:                    <<count = rnd(10); count >= 0; count -->>
        !           244:                    SetA,
        !           245: 
        !           246:            setOf2
        !           247:                SETOF
        !           248:                    <<count = rnd(4); count >= 0; count -->>
        !           249:                    SetB,
        !           250: 
        !           251:            implicitTaggedSetOf2
        !           252:                [PRIVATE 12] IMPLICIT SETOF
        !           253:                    <<count = rnd(4); count >= 0; count -->>
        !           254:                    SetA,
        !           255: 
        !           256:            setValues
        !           257:                SET { SequenceA, SequenceB, SetA, SetB },
        !           258: 
        !           259:            taggedSetValues
        !           260:                [APPLICATION 13] SET { SequenceA, SequenceB, SetA, SetB },
        !           261: 
        !           262:            implicitTaggedSetValues
        !           263:                [13] IMPLICIT SET { SequenceA, SequenceB, SetA, SetB },
        !           264: 
        !           265:            choice
        !           266:                CHOICE << rnd(2) + 1 >> {
        !           267:                    [1]
        !           268:                        SequenceA,
        !           269: 
        !           270:                    [2]
        !           271:                        SequenceB,
        !           272: 
        !           273:                    [3]
        !           274:                        SetA,
        !           275: 
        !           276:                    [4]
        !           277:                        SetB
        !           278:                },
        !           279: 
        !           280:            taggedChoice
        !           281:                [PRIVATE 14] CHOICE << rnd(2) + 1 >> {
        !           282:                    [1]
        !           283:                        SequenceA,
        !           284: 
        !           285:                    [2]
        !           286:                        SequenceB,
        !           287: 
        !           288:                    [3]
        !           289:                        SetA,
        !           290: 
        !           291:                    [4]
        !           292:                        SetB
        !           293:                },
        !           294: 
        !           295:            bounded
        !           296:                objectname < ObjectA,
        !           297: 
        !           298:            taggedBounded
        !           299:                [UNIVERSAL 15] objectname < ObjectA,
        !           300: 
        !           301:            any
        !           302:                ANY
        !           303:                [[a pe_alloc (PE_CLASS_UNIV, PE_FORM_PRIM, PE_PRIM_NULL)]],
        !           304: 
        !           305:            taggedAny [PRIVATE 15]
        !           306:                ANY
        !           307:                [[a pe_alloc (PE_CLASS_UNIV, PE_FORM_PRIM, PE_PRIM_NULL)]],
        !           308: 
        !           309:            oid
        !           310:                %{
        !           311:                    OID oid;
        !           312:                    register int i;
        !           313: 
        !           314:                    oid = (OID) calloc (1, sizeof(OIDentifier));
        !           315:                    oid->oid_nelem = rnd(6)+2;
        !           316:                    oid->oid_elements = (unsigned int *)
        !           317:                                calloc((unsigned) oid->oid_nelem,
        !           318:                                            sizeof(unsigned int));
        !           319:                    for(i = 0; i < oid->oid_nelem; i++)
        !           320:                        oid->oid_elements[i] = rnd(10);
        !           321:                    $$ = oid;
        !           322:                %}
        !           323:                OBJECT IDENTIFIER,
        !           324: 
        !           325:            taggedOid [16]
        !           326:                %{
        !           327:                    OID oid;
        !           328:                    register int i;
        !           329: 
        !           330:                    oid = (OID) calloc (1, sizeof(OIDentifier));
        !           331:                    oid->oid_nelem = rnd(6)+2;
        !           332:                    oid->oid_elements = (unsigned int *)
        !           333:                                calloc((unsigned) oid->oid_nelem,
        !           334:                                            sizeof(unsigned int));
        !           335:                    for(i = 0; i < oid->oid_nelem; i++)
        !           336:                        oid->oid_elements[i] = rnd(10);
        !           337:                    $$ = oid;
        !           338:                %}
        !           339:                OBJECT IDENTIFIER,
        !           340: 
        !           341:            oid2
        !           342:                OBJECT IDENTIFIER
        !           343:                [[O str2oid ("1.2.3.4.5.6.7.8.9")]],
        !           344: 
        !           345:            implicitTaggedOid2
        !           346:                [APPLICATION 17] IMPLICIT OBJECT IDENTIFIER
        !           347:                [[O str2oid ("1.2.3.4.5.6.7.8.9")]],
        !           348: 
        !           349:            funnyDefault
        !           350:                [18] IMPLICIT INTEGER
        !           351:                [[i fd]]
        !           352:                DEFAULT 0 << fd != 0 >>
        !           353:        }
        !           354: 
        !           355: SequenceA ::=
        !           356:        SEQUENCE {
        !           357:            seqAinteger
        !           358:                INTEGER
        !           359:                [[i rnd(50)]],
        !           360: 
        !           361:            seqAbool
        !           362:                BOOLEAN
        !           363:                [[b rnd(2)]]
        !           364:        }
        !           365: 
        !           366: SequenceB ::=
        !           367:        [PRIVATE 100] SEQUENCE {
        !           368:            seqBinteger
        !           369:                INTEGER
        !           370:                [[i rnd(75)]]
        !           371:        }
        !           372: 
        !           373: SetA ::=
        !           374:        SET {
        !           375:            setAinteger
        !           376:                INTEGER
        !           377:                [[i rnd(20000)]],
        !           378: 
        !           379:            setAbool
        !           380:                BOOLEAN
        !           381:                [[b rnd(2)]]
        !           382:        }
        !           383: 
        !           384: SetB ::=
        !           385:        [PRIVATE 101] SET {
        !           386:            setBinteger
        !           387:                INTEGER
        !           388:                [[i rnd(3000)]]
        !           389:        }
        !           390: 
        !           391: ObjectA ::=
        !           392:        BOOLEAN
        !           393:        [[b rnd(2)]]
        !           394: 
        !           395: 
        !           396: SECTIONS none decoder printer
        !           397: 
        !           398: Test1 ::=
        !           399:        SEQUENCE {
        !           400:            boolean
        !           401:                BOOLEAN,
        !           402: 
        !           403:            taggedBoolean
        !           404:                [0] BOOLEAN,
        !           405: 
        !           406:            implicitTaggedBoolean
        !           407:                [PRIVATE 0] IMPLICIT BOOLEAN,
        !           408: 
        !           409:            integer
        !           410:                INTEGER,
        !           411: 
        !           412:            taggedInteger
        !           413:                [APPLICATION 1] INTEGER,
        !           414: 
        !           415:            implicitTaggedInteger
        !           416:                [UNIVERSAL 1] IMPLICIT INTEGER,
        !           417: 
        !           418:            integerOneValue
        !           419:                INTEGER { nn(1) },
        !           420: 
        !           421:            taggedIntegerOneValue
        !           422:                [PRIVATE 2] INTEGER { nn(1) },
        !           423: 
        !           424:            integerManyValues
        !           425:                INTEGER { nn1(1), nn2(2), nn3(3) },
        !           426: 
        !           427:            implicitTaggedIntegerManyValues
        !           428:                [2] IMPLICIT INTEGER { nn1(1), nn2(2), nn3(3) },
        !           429: 
        !           430:            bitstring
        !           431:                BITSTRING,
        !           432: 
        !           433:            taggedBitString
        !           434:                [UNIVERSAL 3] BITSTRING,
        !           435: 
        !           436:            bitstring2
        !           437:                BIT STRING,
        !           438: 
        !           439:            taggedBitstring2
        !           440:                [4] BIT STRING,
        !           441: 
        !           442:            implictTaggedBitstring2
        !           443:                [PRIVATE 4] IMPLICIT BIT STRING,
        !           444: 
        !           445:            bitstringValue
        !           446:                BIT STRING { nn1(1) },
        !           447: 
        !           448:            taggedBitstringValue
        !           449:                [APPLICATION 5] BIT STRING { nn1(1) },
        !           450: 
        !           451:            bitstringValues
        !           452:                BIT STRING { nn1(1), nn2(2), nn3(3) },
        !           453: 
        !           454:            taggedBitstringValues
        !           455:                [PRIVATE 6] BIT STRING { nn1(1), nn2(2), nn3(3) },
        !           456: 
        !           457:            implicitTaggedBitstringValues
        !           458:                [APPLICATION 6] IMPLICIT BIT STRING
        !           459:                { nn1(1), nn2(2), nn3(3) },
        !           460: 
        !           461:            octetstring
        !           462:                OCTET STRING,
        !           463: 
        !           464:            taggedOctetstring
        !           465:                [UNIVERSAL 7] OCTET STRING,
        !           466: 
        !           467:            octetstring2
        !           468:                OCTETSTRING,
        !           469: 
        !           470:            implicitTaggedOctetstring2
        !           471:                [PRIVATE 7] IMPLICIT OCTETSTRING,
        !           472: 
        !           473:            null
        !           474:                NULL,
        !           475: 
        !           476:            taggedNull
        !           477:                [8] NULL,
        !           478: 
        !           479:            implicitTaggedNull
        !           480:                [PRIVATE 8] IMPLICIT NULL,
        !           481: 
        !           482:            sequence
        !           483:                SEQUENCE,
        !           484: 
        !           485:            taggedSequence
        !           486:                [APPLICATION 9] SEQUENCE,
        !           487: 
        !           488:            implicitTaggedSequence
        !           489:                [PRIVATE 9] IMPLICIT SEQUENCE,
        !           490: 
        !           491:            sequenceOf
        !           492:                SEQUENCE OF
        !           493:                    SequenceA,
        !           494: 
        !           495:            taggedSequenceOf
        !           496:                [PRIVATE 10] SEQUENCE OF
        !           497:                    SequenceA,
        !           498: 
        !           499:            sequenceOf2
        !           500:                SEQUENCEOF
        !           501:                    SequenceB,
        !           502: 
        !           503:            implicitTaggedSequenceOf2
        !           504:                [10] IMPLICIT SEQUENCEOF
        !           505:                    SequenceA,
        !           506: 
        !           507:            set
        !           508:                SET,
        !           509: 
        !           510:            taggedSet
        !           511:                [UNIVERSAL 11] SET,
        !           512: 
        !           513:            implicitTaggedSet
        !           514:                [PRIVATE 11] IMPLICIT SET,
        !           515: 
        !           516:            setOf
        !           517:                SET OF
        !           518:                    SetA,
        !           519: 
        !           520:            taggedSetOf
        !           521:                [12] SET OF
        !           522:                    SetA,
        !           523: 
        !           524:            setOf2
        !           525:                SETOF
        !           526:                    SetB,
        !           527: 
        !           528:            implicitTaggedSetOf2
        !           529:                [PRIVATE 12] IMPLICIT SETOF
        !           530:                    SetA,
        !           531: 
        !           532:            setValues
        !           533:                SET { SequenceA, SequenceB, SetA, SetB },
        !           534: 
        !           535:            taggedSetValues
        !           536:                [APPLICATION 13] SET { SequenceA, SequenceB, SetA, SetB },
        !           537: 
        !           538:            implicitTaggedSetValues
        !           539:                [13] IMPLICIT SET { SequenceA, SequenceB, SetA, SetB },
        !           540: 
        !           541:            choice
        !           542:                CHOICE {
        !           543:                    [1]
        !           544:                        SequenceA,
        !           545: 
        !           546:                    [2]
        !           547:                        SequenceB,
        !           548: 
        !           549:                    [3]
        !           550:                        SetA,
        !           551: 
        !           552:                    [4]
        !           553:                        SetB
        !           554:                },
        !           555: 
        !           556:            taggedChoice
        !           557:                [PRIVATE 14] CHOICE {
        !           558:                    [1]
        !           559:                        SequenceA,
        !           560: 
        !           561:                    [2]
        !           562:                        SequenceB,
        !           563: 
        !           564:                    [3]
        !           565:                        SetA,
        !           566: 
        !           567:                    [4]
        !           568:                        SetB
        !           569:                },
        !           570: 
        !           571:            bounded
        !           572:                objectname < ObjectA,
        !           573: 
        !           574:            taggedBounded
        !           575:                [UNIVERSAL 15] objectname < ObjectA,
        !           576: 
        !           577:            any
        !           578:                ANY,
        !           579: 
        !           580:            taggedAny
        !           581:                [PRIVATE 15] ANY,
        !           582: 
        !           583:            oid
        !           584:                OBJECT IDENTIFIER,
        !           585: 
        !           586:            taggedOid
        !           587:                [16] OBJECT IDENTIFIER,
        !           588: 
        !           589:            oid2
        !           590:                OBJECT IDENTIFIER,
        !           591: 
        !           592:            implicitTaggedOid2
        !           593:                [APPLICATION 17] IMPLICIT OBJECT IDENTIFIER,
        !           594: 
        !           595:            funnyDefault
        !           596:                [18] IMPLICIT INTEGER
        !           597:                %{ if ($$ == 0) advise (NULLCP, "funny default!"); %}
        !           598:                DEFAULT 0
        !           599:        }
        !           600: 
        !           601: SequenceA ::=
        !           602:        SEQUENCE {
        !           603:            seqAinteger
        !           604:                INTEGER,
        !           605: 
        !           606:            seqAbool
        !           607:                BOOLEAN
        !           608:        }
        !           609: 
        !           610: SequenceB ::=
        !           611:        [PRIVATE 100] SEQUENCE {
        !           612:            seqBinteger
        !           613:                INTEGER
        !           614:        }
        !           615: 
        !           616: SetA ::=
        !           617:        SET {
        !           618:            setAinteger
        !           619:                INTEGER,
        !           620: 
        !           621:            setAbool
        !           622:                BOOLEAN
        !           623:        }
        !           624: 
        !           625: SetB ::=
        !           626:        [PRIVATE 101] SET {
        !           627:            setBinteger
        !           628:                INTEGER
        !           629:        }
        !           630: 
        !           631: ObjectA ::=
        !           632:        BOOLEAN
        !           633: 
        !           634: 
        !           635: END
        !           636: 
        !           637: %{
        !           638: 
        !           639: /*    MISC */
        !           640: 
        !           641: #ifdef BSD42
        !           642: #define SRAND(s)       srandom ((int) (s))
        !           643: #define RAND           random
        !           644: 
        !           645: long   random ();
        !           646: #else
        !           647: #define SRAND          srand
        !           648: #define        RAND            rand
        !           649: 
        !           650: int    rand ();
        !           651: #endif
        !           652: 
        !           653: long   time ();
        !           654: 
        !           655: 
        !           656: static int rnd(n)
        !           657: int    n;
        !           658: {
        !           659:     static int init = 0;
        !           660: 
        !           661:     if (!init) {
        !           662:        SRAND (time ((long *) 0));
        !           663:        init = 1;
        !           664:     }
        !           665:     return (RAND () % n);
        !           666: }
        !           667: 
        !           668: /*    ERRORS */
        !           669: 
        !           670: #include <varargs.h>
        !           671: 
        !           672: 
        !           673: #ifndef        lint
        !           674: void   _advise ();
        !           675: 
        !           676: 
        !           677: static void  adios (va_alist)
        !           678: va_dcl
        !           679: {
        !           680:     va_list ap;
        !           681: 
        !           682:     va_start (ap);
        !           683: 
        !           684:     _advise (ap);
        !           685: 
        !           686:     va_end (ap);
        !           687: 
        !           688:     _exit (1);
        !           689: }
        !           690: #else
        !           691: /* VARARGS */
        !           692: 
        !           693: static void  adios (what, fmt)
        !           694: char   *what,
        !           695:        *fmt;
        !           696: {
        !           697:     adios (what, fmt);
        !           698: }
        !           699: #endif
        !           700: 
        !           701: 
        !           702: #ifndef        lint
        !           703: static void  advise (va_alist)
        !           704: va_dcl
        !           705: {
        !           706:     va_list ap;
        !           707: 
        !           708:     va_start (ap);
        !           709: 
        !           710:     _advise (ap);
        !           711: 
        !           712:     va_end (ap);
        !           713: }
        !           714: 
        !           715: 
        !           716: static void  _advise (ap)
        !           717: va_list        ap;
        !           718: {
        !           719:     char    buffer[BUFSIZ];
        !           720: 
        !           721:     asprintf (buffer, ap);
        !           722: 
        !           723:     (void) fflush (stdout);
        !           724: 
        !           725:     fprintf (stderr, "%s: ", myname);
        !           726:     (void) fputs (buffer, stderr);
        !           727:     (void) fputc ('\n', stderr);
        !           728: 
        !           729:     (void) fflush (stderr);
        !           730: }
        !           731: #else
        !           732: /* VARARGS */
        !           733: 
        !           734: static void  advise (what, fmt)
        !           735: char   *what,
        !           736:        *fmt;
        !           737: {
        !           738:     advise (what, fmt);
        !           739: }
        !           740: #endif
        !           741: 
        !           742: %}

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