DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400 Tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400 Tapes

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - download
Index: ┃ B T

⟦486828417⟧ TextFile

    Length: 52214 (0xcbf6)
    Types: TextFile
    Names: »B«

Derivation

└─⟦a7d1ea751⟧ Bits:30000550 8mm tape, Rational 1000, !users!projects 94_04_11
    └─ ⟦129cab021⟧ »DATA« 
        └─⟦this⟧ 
└─⟦2f6cfab89⟧ Bits:30000547 8mm tape, Rational 1000, !projects 94-01-04
    └─ ⟦d65440be7⟧ »DATA« 
        └─⟦this⟧ 

TextFile

package body Scanner is

    Beglin : Boolean := False;
    I, Bracelevel : Integer;

    function Get_Token return Token is
        Toktype : Token;
        Didadef, Indented_Code : Boolean;
        Cclval : Integer;
        Nmdefptr : Vstring;
        Nmdef, Tmpbuf : Vstring;

        procedure Action_Echo is
        begin
            Text_Io.Put (Temp_Action_File, Yytext (1 .. Yylength));
        end Action_Echo;

        procedure Mark_End_Of_Prolog is
        begin
            Text_Io.Put (Temp_Action_File, "%%%% end of prolog");
            Text_Io.New_Line (Temp_Action_File);
        end Mark_End_Of_Prolog;

        procedure Put_Back_String (Str : Vstring; Start : Integer) is
        begin
            for I in reverse Start + 1 .. Tstring.Len (Str) loop
                Unput (Char (Str, I));
            end loop;
        end Put_Back_String;

        function Check_Yylex_Here return Boolean is
        begin
            return ((Yytext'Length >= 2) and then
                    ((Yytext (1) = '#') and (Yytext (2) = '#')));
        end Check_Yylex_Here;

        function Yylex return Token is
            subtype Short is Integer range -32768 .. 32767;
            Yy_Act : Integer;
            Yy_C : Short;

-- returned upon end-of-file
            Yy_End_Tok : constant Integer := 0;
            Yy_End_Of_Buffer : constant := 82;
            subtype Yy_State_Type is Integer;
            Yy_Current_State : Yy_State_Type;
            Initial : constant := 0;
            Sect2 : constant := 1;
            Sect2prolog : constant := 2;
            Sect3 : constant := 3;
            Pickupdef : constant := 4;
            Sc : constant := 5;
            Caretisbol : constant := 6;
            Num : constant := 7;
            Quote : constant := 8;
            Firstccl : constant := 9;
            Ccl : constant := 10;
            Action : constant := 11;
            Recover : constant := 12;
            Braceerror : constant := 13;
            Action_String : constant := 14;
            Yy_Accept : constant array (0 .. 206) of Short :=
               (0, 0, 0, 0, 0, 0, 0, 80, 80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 82, 13, 6, 12, 10, 1, 11, 13,
                13, 13, 9, 39, 31, 32, 25, 39, 38, 23, 39, 39, 39, 31, 21, 39,
                39, 24, 81, 19, 80, 80, 15, 14, 16, 45, 81, 41, 42, 44, 46, 60,
                61, 58, 57, 59, 47, 49, 48, 47, 53, 52, 53, 53, 55, 55, 55,
                56, 66, 71, 70, 72, 66, 72, 67, 64, 65, 81, 17, 63, 62, 73,

                75, 76, 77, 6, 12, 10, 1, 11, 0, 0, 2, 0, 7, 4, 5, 0, 9, 31,
                32, 0, 28, 0, 0, 0, 78, 78, 27, 26, 27, 0, 31, 21, 0, 0,
                35, 0, 0, 19, 18, 80, 80, 15, 14, 43, 44, 57, 79, 79, 50,
                51, 54, 66, 0, 69, 0, 66, 67, 0, 17, 73, 74, 0, 7, 0, 0, 3,
                0, 29, 0, 36, 0, 78, 27, 27, 37, 0, 0, 0, 35, 0, 30, 79,
                66, 68, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, 22,

                0, 22, 4, 0, 34, 0);

            Yy_Ec : constant array (Character'First .. Character'Last) of
                                Short :=
               (0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 4, 1, 1, 1, 1, 1, 1, 1,
                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 6, 7, 8, 9, 1, 10,
                11, 11, 11, 11, 12, 13, 11, 14, 15, 15, 15, 15, 15, 15, 15,
                15, 15, 15, 1, 1, 16, 1, 17, 11, 1, 23, 22, 22, 22, 24, 25,
                22, 22, 22, 22, 22, 22, 22, 22, 26, 22, 22, 27, 28, 29, 22,
                22, 22, 30, 22, 22, 18, 19, 20, 21, 22, 1, 23, 22, 22, 22,

                24, 25, 22, 22, 22, 22, 22, 22, 22, 22, 26, 22, 22,
                27, 28, 29, 22, 22, 22, 30, 22, 22, 31, 32, 33, 1, 1);

            Yy_Meta : constant array (0 .. 33) of Short :=
               (0, 1, 2, 3, 2, 2, 4, 1, 1, 1, 5, 1, 1, 6, 5, 7, 1, 1, 1,
                8, 9, 1, 10, 10, 10, 10, 10, 10, 10, 10, 10, 5, 11, 12);

            Yy_Base : constant array (0 .. 254) of Short :=
               (0, 0, 29, 58, 89, 503, 499, 498, 305, 4, 8, 119, 147, 286,
                285, 32, 34, 65, 67, 93, 96, 110, 113, 177, 0, 302, 301,
                12, 15, 82, 121, 303, 880, 76, 880, 0, 37, 880, 299, 11,
                288, 0, 880, 11, 880, 880, 14, 880, 284, 280, 283, 196, 225,
                880, 288, 283, 880, 292, 0, 291, 880, 0, 133, 880, 880,
                880, 880, 272, 0, 880, 880, 880, 880, 277, 880, 880, 880,
                880, 276, 880, 880, 274, 275, 880, 0, 272, 880, 0, 880,
                880, 109, 273, 880, 0, 880, 880, 282, 880, 880, 880, 0,

                880, 880, 0, 149, 880, 0, 152, 880, 271, 280, 880, 272, 0,
                247, 880, 263, 0, 72, 880, 262, 880, 240, 63, 119, 880,
                248, 0, 880, 245, 249, 277, 880, 248, 153, 0, 256, 253, 0,
                880, 252, 880, 0, 156, 880, 0, 239, 880, 238, 880, 880,
                880, 0, 221, 880, 0, 309, 0, 249, 880, 0, 880, 248, 0, 227,
                246, 880, 245, 880, 221, 880, 148, 231, 0, 0, 880, 232,
                229, 230, 0, 241, 880, 226, 0, 880, 236, 234, 880, 209,
                210, 197, 231, 212, 159, 128, 108, 194, 115, 880, 108, 880,

                84, 880, 880, 4, 880, 880, 342, 354, 366, 378, 390,
                402, 414, 426, 438, 450, 462, 474, 486, 493, 502, 508,
                520, 527, 536, 547, 559, 571, 583, 595, 607, 619, 631,
                638, 648, 660, 672, 684, 695, 702, 712, 724, 736, 748,
                760, 772, 784, 795, 807, 819, 831, 843, 855, 867);

            Yy_Def : constant array (0 .. 254) of Short :=
               (0, 207, 207, 208, 208, 209, 209, 210, 210, 211, 211, 212, 212,
                213, 213, 214, 214, 215, 215, 216, 216, 217, 217, 206, 23, 218,
                218, 213, 213, 219, 219, 206, 206, 206, 206, 220, 221, 206, 222,
                223, 206, 224, 206, 225, 206, 206, 206, 206, 206, 226, 227, 228,
                229, 206, 206, 206, 206, 230, 231, 232, 206, 233, 206, 206, 206,
                206, 206, 206, 234, 206, 206, 206, 206, 206, 206, 206, 206,
                206, 227, 206, 206, 235, 236, 206, 237, 227, 206, 238, 206,
                206, 239, 238, 206, 240, 206, 206, 241, 206, 206, 206, 242,

                206, 206, 243, 206, 206, 220, 221, 206, 206, 222, 206, 206, 244,
                206, 206, 245, 224, 225, 206, 246, 206, 206, 226, 226, 206, 206,
                247, 206, 247, 206, 229, 206, 206, 246, 248, 249, 230, 231, 206,
                232, 206, 233, 206, 206, 234, 206, 206, 206, 206, 206, 206, 238,
                239, 206, 239, 206, 240, 241, 206, 242, 206, 250, 244, 206,
                245, 206, 246, 206, 206, 206, 226, 206, 247, 129, 206, 206,
                249, 246, 248, 249, 206, 206, 156, 206, 251, 250, 206, 206,
                206, 226, 252, 253, 254, 206, 206, 226, 252, 206, 253, 206,

                254, 206, 206, 206, 206, 0, 206, 206, 206, 206, 206,
                206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206,
                206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206,
                206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206,
                206, 206, 206, 206, 206, 206, 206, 206, 206, 206);

            Yy_Nxt : constant array (0 .. 913) of Short :=
               (0, 206, 33, 34, 33, 33, 62, 63, 62, 62, 62, 63, 62, 62, 119,
                98, 121, 121, 98, 121, 113, 205, 35, 35, 35, 35, 35, 35, 35,
                35, 35, 36, 37, 36, 36, 71, 38, 71, 39, 114, 108, 115, 40,
                120, 72, 99, 72, 73, 99, 73, 109, 41, 41, 41, 41, 41, 41, 41,
                41, 41, 43, 44, 43, 43, 45, 74, 46, 74, 76, 47, 76, 77, 47,
                77, 48, 119, 49, 50, 104, 105, 104, 104, 124, 170, 78, 101,
                78, 202, 102, 51, 47, 52, 53, 52, 52, 45, 65, 46, 54, 65, 47,

                103, 55, 47, 120, 48, 80, 49, 50, 80, 56, 200, 81, 65, 82, 81,
                65, 82, 198, 154, 51, 47, 65, 84, 101, 204, 84, 102, 155, 85,
                86, 66, 85, 86, 171, 143, 67, 143, 143, 123, 103, 68, 68, 68,
                68, 68, 68, 68, 68, 68, 65, 104, 105, 104, 104, 108, 168, 203,
                143, 66, 143, 143, 202, 190, 67, 109, 178, 124, 170, 68, 68,
                68, 68, 68, 68, 68, 68, 68, 87, 87, 88, 87, 87, 89, 87, 87,
                87, 90, 87, 87, 91, 92, 87, 87, 87, 87, 87, 87, 87, 93, 93,

                93, 93, 93, 93, 93, 93, 93, 94, 87, 95, 128, 196, 124, 170, 200,
                124, 170, 129, 129, 129, 129, 129, 129, 129, 129, 129, 131, 132,
                131, 131, 154, 181, 168, 198, 195, 194, 187, 133, 184, 155,
                147, 192, 193, 181, 191, 125, 189, 168, 166, 188, 187, 159,
                182, 146, 141, 138, 134, 174, 181, 174, 177, 176, 172, 169,
                168, 166, 174, 174, 174, 174, 174, 174, 174, 174, 174, 164,
                162, 175, 131, 132, 131, 131, 111, 116, 159, 156, 126, 150,
                148, 133, 126, 146, 144, 141, 138, 136, 135, 126, 124, 122,

                116, 111, 206, 97, 97, 69, 69, 60, 134, 183, 183, 184, 183, 183,
                185, 183, 183, 183, 185, 183, 183, 183, 185, 183, 183, 183, 183,
                183, 183, 183, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
                183, 185, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42,
                42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 57, 57, 57, 57,
                57, 57, 57, 57, 57, 57, 57, 57, 59, 59, 59, 59, 59, 59, 59,
                59, 59, 59, 59, 59, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,

                61, 61, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 65,
                65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 70, 70, 70, 70,
                70, 70, 70, 70, 70, 70, 70, 70, 75, 75, 75, 75, 75, 75, 75,
                75, 75, 75, 75, 75, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79,
                79, 79, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83,
                96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 100, 100,
                100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 106, 106,

                60, 58, 106, 107, 107, 58, 206, 107, 110, 110, 110, 110, 110,
                110, 110, 110, 110, 110, 110, 110, 112, 112, 112, 112, 112, 112,
                112, 112, 112, 112, 112, 112, 117, 117, 206, 206, 117, 118, 118,
                206, 206, 206, 206, 206, 206, 206, 118, 123, 123, 206, 123, 123,
                123, 123, 123, 206, 123, 123, 123, 125, 125, 206, 125, 125,
                125, 125, 125, 125, 125, 125, 125, 127, 127, 206, 127, 127,
                127, 127, 127, 127, 127, 127, 127, 130, 130, 130, 130, 130,
                130, 130, 130, 130, 130, 130, 130, 137, 137, 137, 137, 137,

                137, 137, 137, 137, 137, 137, 137, 139, 206, 206, 139, 139, 139,
                139, 139, 139, 139, 139, 139, 140, 140, 140, 140, 140, 140, 140,
                140, 140, 140, 140, 140, 142, 142, 206, 142, 142, 142, 142, 142,
                142, 142, 142, 142, 145, 145, 206, 206, 145, 147, 147, 206, 147,
                147, 147, 147, 147, 147, 147, 147, 147, 149, 149, 206, 149,
                149, 149, 149, 149, 149, 149, 149, 149, 151, 151, 206, 151,
                151, 151, 151, 151, 206, 151, 151, 151, 152, 152, 206, 206,
                206, 152, 152, 152, 152, 206, 152, 153, 153, 206, 153, 153,

                153, 153, 153, 153, 153, 153, 153, 157, 157, 206, 206, 157, 158,
                158, 158, 158, 158, 158, 158, 158, 158, 158, 158, 158, 160, 160,
                206, 206, 160, 160, 160, 206, 160, 160, 160, 160, 161, 161, 206,
                161, 161, 161, 161, 161, 161, 161, 161, 161, 163, 163, 206, 163,
                163, 163, 163, 163, 163, 163, 163, 163, 165, 165, 165, 165,
                165, 165, 165, 165, 165, 165, 165, 165, 167, 167, 167, 167,
                167, 167, 167, 167, 167, 167, 167, 167, 173, 173, 206, 173,
                173, 173, 173, 173, 173, 173, 173, 179, 179, 206, 179, 179,

                179, 179, 179, 179, 179, 179, 179, 180, 180, 180, 180, 180, 180,
                180, 180, 180, 180, 180, 180, 186, 186, 186, 186, 186, 186, 186,
                186, 186, 186, 186, 186, 185, 185, 185, 185, 185, 185, 185, 185,
                185, 185, 185, 185, 197, 197, 197, 197, 197, 197, 197, 197,
                197, 197, 197, 197, 199, 199, 199, 199, 199, 199, 199, 199,
                199, 199, 199, 199, 201, 201, 201, 201, 201, 201, 201, 201,
                201, 201, 201, 201, 31, 206, 206, 206, 206, 206, 206, 206, 206,
                206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206,

                206, 206, 206, 206, 206, 206, 206,
                206, 206, 206, 206, 206, 206);

            Yy_Chk : constant array (0 .. 913) of Short :=
               (0, 0, 1, 1, 1, 1, 9, 9, 9, 9, 10, 10, 10, 10, 43, 27, 46,
                46, 28, 46, 39, 204, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2,
                15, 2, 16, 2, 39, 36, 39, 2, 43, 15, 27, 16, 15, 28, 16, 36,
                2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 15, 3, 16, 17,
                3, 18, 17, 3, 18, 3, 118, 3, 3, 33, 33, 33, 33, 123, 123,
                17, 29, 18, 201, 29, 3, 3, 4, 4, 4, 4, 4, 19, 4, 4, 20, 4,

                29, 4, 4, 118, 4, 19, 4, 4, 20, 4, 199, 19, 21, 19, 20, 22,
                20, 197, 90, 4, 4, 11, 21, 30, 195, 22, 30, 90, 21, 21, 11,
                22, 22, 124, 62, 11, 62, 62, 124, 30, 11, 11, 11, 11, 11,
                11, 11, 11, 11, 12, 104, 104, 104, 104, 107, 134, 194, 143,
                12, 143, 143, 193, 171, 12, 107, 134, 171, 171, 12, 12, 12,
                12, 12, 12, 12, 12, 12, 23, 23, 23, 23, 23, 23, 23, 23, 23,
                23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,

                23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 51, 190, 196, 196,
                192, 190, 190, 51, 51, 51, 51, 51, 51, 51, 51, 51, 52, 52,
                52, 52, 153, 177, 178, 191, 189, 188, 186, 52, 185, 153,
                182, 177, 178, 180, 176, 172, 169, 167, 165, 164, 162,
                158, 148, 146, 140, 137, 52, 129, 136, 129, 133, 130, 126,
                122, 120, 116, 129, 129, 129, 129, 129, 129, 129, 129,
                129, 114, 112, 129, 131, 131, 131, 131, 110, 109, 96, 91,
                85, 82, 81, 131, 78, 73, 67, 59, 57, 55, 54, 50, 49, 48,

                40, 38, 31, 26, 25, 14, 13, 8, 131, 156, 156, 156, 156, 156,
                156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
                156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
                156, 156, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
                207, 207, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
                208, 208, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
                209, 209, 210, 210, 210, 210, 210, 210, 210, 210, 210, 210,
                210, 210, 211, 211, 211, 211, 211, 211, 211, 211, 211, 211,

                211, 211, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212,
                212, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213,
                214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 215,
                215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 215, 216, 216,
                216, 216, 216, 216, 216, 216, 216, 216, 216, 216, 217, 217,
                217, 217, 217, 217, 217, 217, 217, 217, 217, 217, 218, 218,
                218, 218, 218, 218, 218, 218, 218, 218, 218, 218, 219, 219,
                219, 219, 219, 219, 219, 219, 219, 219, 219, 219, 220, 220,

                7, 6, 220, 221, 221, 5, 0, 221, 222, 222, 222, 222, 222,
                222, 222, 222, 222, 222, 222, 222, 223, 223, 223, 223, 223,
                223, 223, 223, 223, 223, 223, 223, 224, 224, 0, 0, 224,
                225, 225, 0, 0, 0, 0, 0, 0, 0, 225, 226, 226, 0, 226, 226,
                226, 226, 226, 0, 226, 226, 226, 227, 227, 0, 227, 227,
                227, 227, 227, 227, 227, 227, 227, 228, 228, 0, 228, 228,
                228, 228, 228, 228, 228, 228, 228, 229, 229, 229, 229, 229,
                229, 229, 229, 229, 229, 229, 229, 230, 230, 230, 230, 230,

                230, 230, 230, 230, 230, 230, 230, 231, 0, 0, 231, 231, 231,
                231, 231, 231, 231, 231, 231, 232, 232, 232, 232, 232, 232,
                232, 232, 232, 232, 232, 232, 233, 233, 0, 233, 233, 233,
                233, 233, 233, 233, 233, 233, 234, 234, 0, 0, 234, 235, 235,
                0, 235, 235, 235, 235, 235, 235, 235, 235, 235, 236, 236,
                0, 236, 236, 236, 236, 236, 236, 236, 236, 236, 237, 237,
                0, 237, 237, 237, 237, 237, 0, 237, 237, 237, 238, 238, 0,
                0, 0, 238, 238, 238, 238, 0, 238, 239, 239, 0, 239, 239,

                239, 239, 239, 239, 239, 239, 239, 240, 240, 0, 0, 240, 241,
                241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 242,
                242, 0, 0, 242, 242, 242, 0, 242, 242, 242, 242, 243, 243,
                0, 243, 243, 243, 243, 243, 243, 243, 243, 243, 244, 244, 0,
                244, 244, 244, 244, 244, 244, 244, 244, 244, 245, 245, 245,
                245, 245, 245, 245, 245, 245, 245, 245, 245, 246, 246, 246,
                246, 246, 246, 246, 246, 246, 246, 246, 246, 247, 247, 0, 247,
                247, 247, 247, 247, 247, 247, 247, 248, 248, 0, 248, 248,

                248, 248, 248, 248, 248, 248, 248, 249, 249, 249, 249, 249, 249,
                249, 249, 249, 249, 249, 249, 250, 250, 250, 250, 250, 250, 250,
                250, 250, 250, 250, 250, 251, 251, 251, 251, 251, 251, 251, 251,
                251, 251, 251, 251, 252, 252, 252, 252, 252, 252, 252, 252, 252,
                252, 252, 252, 253, 253, 253, 253, 253, 253, 253, 253, 253,
                253, 253, 253, 254, 254, 254, 254, 254, 254, 254, 254, 254,
                254, 254, 254, 206, 206, 206, 206, 206, 206, 206, 206, 206,
                206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206,

                206, 206, 206, 206, 206, 206, 206,
                206, 206, 206, 206, 206, 206);


-- copy whatever the last rule matched to the standard output

            procedure Echo is
            begin
                Text_Io.Put (Yytext);
            end Echo;

-- enter a start condition.
-- Using procedure requires a () after the ENTER, but makes everything
-- much neater.

            procedure Enter (State : Integer) is
            begin
                Yy_Start := 1 + 2 * State;
            end Enter;

-- action number for EOF rule of a given start state
            function Yy_State_Eof (State : Integer) return Integer is
            begin
                return Yy_End_Of_Buffer + State + 1;
            end Yy_State_Eof;

-- return all but the first 'n' matched characters back to the input stream
            procedure Yyless (N : Integer) is
            begin
                Yy_Ch_Buf (Yy_Cp) :=
                   Yy_Hold_Char; -- undo effects of setting up yytext
                Yy_Cp := Yy_Bp + N;
                Yy_C_Buf_P := Yy_Cp;
                Yy_Do_Before_Action; -- set up yytext again
            end Yyless;

-- redefine this if you have something you want each time.
            procedure Yy_User_Action is
            begin
                null;
            end Yy_User_Action;

-- yy_get_previous_state - get the state just before the EOB char was reached

            function Yy_Get_Previous_State return Yy_State_Type is
                Yy_Current_State : Yy_State_Type;
                Yy_C : Short;
                Yy_Bp : Integer := Yytext_Ptr;
            begin
                Yy_Current_State := Yy_Start;
                if (Yy_Ch_Buf (Yy_Bp - 1) = Ascii.Lf) then
                    Yy_Current_State := Yy_Current_State + 1;
                end if;

                for Yy_Cp in Yytext_Ptr .. Yy_C_Buf_P - 1 loop
                    Yy_C := Yy_Ec (Yy_Ch_Buf (Yy_Cp));
                    if (Yy_Accept (Yy_Current_State) /= 0) then
                        Yy_Last_Accepting_State := Yy_Current_State;
                        Yy_Last_Accepting_Cpos := Yy_Cp;
                    end if;
                    while (Yy_Chk (Yy_Base (Yy_Current_State) + Yy_C) /=
                           Yy_Current_State) loop
                        Yy_Current_State := Yy_Def (Yy_Current_State);
                        if (Yy_Current_State >= 207) then
                            Yy_C := Yy_Meta (Yy_C);
                        end if;
                    end loop;
                    Yy_Current_State := Yy_Nxt
                                           (Yy_Base (Yy_Current_State) + Yy_C);
                end loop;

                return Yy_Current_State;
            end Yy_Get_Previous_State;

            procedure Yyrestart (Input_File : File_Type) is
            begin
                Set_Input (Input_File);
                Yy_Init := True;
            end Yyrestart;

        begin -- of YYLex
            <<New_File>>
                -- this is where we enter upon encountering an end-of-file and
                -- yywrap() indicating that we should continue processing

                if (Yy_Init) then
                    if (Yy_Start = 0) then
                        Yy_Start := 1;      -- first start state
                    end if;

                    -- we put in the '\n' and start reading from [1] so that an
                    -- initial match-at-newline will be true.

                    Yy_Ch_Buf (0) := Ascii.Lf;
                    Yy_N_Chars := 1;

                    -- we always need two end-of-buffer characters.  The first causes
                    -- a transition to the end-of-buffer state.  The second causes
                    -- a jam in that state.

                    Yy_Ch_Buf (Yy_N_Chars) := Yy_End_Of_Buffer_Char;
                    Yy_Ch_Buf (Yy_N_Chars + 1) := Yy_End_Of_Buffer_Char;

                    Yy_Eof_Has_Been_Seen := False;

                    Yytext_Ptr := 1;
                    Yy_C_Buf_P := Yytext_Ptr;
                    Yy_Hold_Char := Yy_Ch_Buf (Yy_C_Buf_P);
                    Yy_Init := False;
                end if; -- yy_init

            loop                -- loops until end-of-file is reached
                Yy_Cp := Yy_C_Buf_P;

                -- support of yytext
                Yy_Ch_Buf (Yy_Cp) := Yy_Hold_Char;

                -- yy_bp points to the position in yy_ch_buf of the start of the
                -- current run.
                Yy_Bp := Yy_Cp;
                Yy_Current_State := Yy_Start;
                if (Yy_Ch_Buf (Yy_Bp - 1) = Ascii.Lf) then
                    Yy_Current_State := Yy_Current_State + 1;
                end if;
                loop
                    Yy_C := Yy_Ec (Yy_Ch_Buf (Yy_Cp));
                    if (Yy_Accept (Yy_Current_State) /= 0) then
                        Yy_Last_Accepting_State := Yy_Current_State;
                        Yy_Last_Accepting_Cpos := Yy_Cp;
                    end if;
                    while (Yy_Chk (Yy_Base (Yy_Current_State) + Yy_C) /=
                           Yy_Current_State) loop
                        Yy_Current_State := Yy_Def (Yy_Current_State);
                        if (Yy_Current_State >= 207) then
                            Yy_C := Yy_Meta (Yy_C);
                        end if;
                    end loop;
                    Yy_Current_State := Yy_Nxt
                                           (Yy_Base (Yy_Current_State) + Yy_C);
                    Yy_Cp := Yy_Cp + 1;
                    if (Yy_Current_State = 206) then
                        exit;
                    end if;
                end loop;
                Yy_Cp := Yy_Last_Accepting_Cpos;
                Yy_Current_State := Yy_Last_Accepting_State;

                <<Next_Action>> Yy_Act := Yy_Accept (Yy_Current_State);
                Yy_Do_Before_Action;
                Yy_User_Action;

                if Aflex_Debug then  -- output acceptance info. for (-d) debug mode
                    Text_Io.Put (Standard_Error, "--accepting rule #");
                    Text_Io.Put (Standard_Error, Integer'Image (Yy_Act));
                    Text_Io.Put_Line (Standard_Error, "(""" & Yytext & """)");
                end if;

                <<Do_Action>>   -- this label is used only to access EOF actions
                    case Yy_Act is
                        when 0 => -- must backtrack
                            -- undo the effects of YY_DO_BEFORE_ACTION
                            Yy_Ch_Buf (Yy_Cp) := Yy_Hold_Char;
                            Yy_Cp := Yy_Last_Accepting_Cpos;
                            Yy_Current_State := Yy_Last_Accepting_State;
                            goto Next_Action;



                        when 1 =>
--# line 46 "ascan.l"
                            Indented_Code := True;

                        when 2 =>
--# line 47 "ascan.l"
                            Linenum := Linenum + 1;
                            Echo;
                            -- treat as a comment;


                        when 3 =>
--# line 50 "ascan.l"
                            Linenum := Linenum + 1;
                            Echo;

                        when 4 =>
--# line 51 "ascan.l"
                            return (Scdecl);

                        when 5 =>
--# line 52 "ascan.l"
                            return (Xscdecl);

                        when 6 =>
--# line 54 "ascan.l"
                            return (Whitespace);

                        when 7 =>
--# line 56 "ascan.l"

                            Sectnum := 2;
                            Misc.Line_Directive_Out;
                            Enter (Sect2prolog);
                            return (Sectend);


                        when 8 =>
--# line 63 "ascan.l"

                            Text_Io.Put (Standard_Error,
                                         "old-style lex command at line ");
                            Int_Io.Put (Standard_Error, Linenum);
                            Text_Io.Put (Standard_Error, "ignored:");
                            Text_Io.New_Line (Standard_Error);
                            Text_Io.Put (Standard_Error, Ascii.Ht);
                            Text_Io.Put (Standard_Error,
                                         Yytext (1 .. Yylength));
                            Linenum := Linenum + 1;


                        when 9 =>
--# line 73 "ascan.l"

                            Nmstr := Vstr (Yytext (1 .. Yylength));
                            Didadef := False;
                            Enter (Pickupdef);


                        when 10 =>
--# line 79 "ascan.l"
                            Nmstr := Vstr (Yytext (1 .. Yylength));
                            return Name;


                        when 11 =>
--# line 82 "ascan.l"
                            Linenum := Linenum + 1;
                            -- allows blank lines in section 1;


                        when 12 =>
--# line 85 "ascan.l"
                            Linenum := Linenum + 1;
                            return Newline;

                        when 13 =>
--# line 86 "ascan.l"
                            Misc.Synerr ("illegal character");
                            Enter (Recover);

                        when 14 =>
--# line 88 "ascan.l"
                            null;
                            -- separates name and definition;


                        when 15 =>
--# line 92 "ascan.l"

                            Nmdef := Vstr (Yytext (1 .. Yylength));

                            I := Tstring.Len (Nmdef);
                            while (I >= Tstring.First) loop
                                if ((Char (Nmdef, I) /= ' ') and
                                    (Char (Nmdef, I) /= Ascii.Ht)) then
                                    exit;
                                end if;
                                I := I - 1;
                            end loop;

                            Sym.Ndinstal (Nmstr, Tstring.Slice
                                                    (Nmdef, Tstring.First, I));
                            Didadef := True;


                        when 16 =>
--# line 109 "ascan.l"

                            if (not Didadef) then
                                Misc.Synerr ("incomplete name definition");
                            end if;
                            Enter (0);
                            Linenum := Linenum + 1;


                        when 17 =>
--# line 117 "ascan.l"
                            Linenum := Linenum + 1;
                            Enter (0);
                            Nmstr := Vstr (Yytext (1 .. Yylength));
                            return Name;


                        when 18 =>
                            Yy_Ch_Buf (Yy_Cp) :=
                               Yy_Hold_Char; -- undo effects of setting up yytext
                            Yy_Cp := Yy_Cp - 1;
                            Yy_C_Buf_P := Yy_Cp;
                            Yy_Do_Before_Action; -- set up yytext again
--# line 123 "ascan.l"

                            Linenum := Linenum + 1;
                            Action_Echo;
                            Mark_End_Of_Prolog;
                            Enter (Sect2);


                        when 19 =>
--# line 130 "ascan.l"
                            Linenum := Linenum + 1;
                            Action_Echo;

                        when Yy_End_Of_Buffer + Sect2prolog + 1 =>
--# line 132 "ascan.l"
                            Mark_End_Of_Prolog;
                            return End_Of_Input;


                        when 21 =>
--# line 136 "ascan.l"
                            Linenum := Linenum + 1;
                            -- allow blank lines in sect2;

                            -- this rule matches indented lines which
                            -- are not comments.
                        when 22 =>
--# line 141 "ascan.l"

                            Misc.Synerr
                               ("indented code found outside of action");
                            Linenum := Linenum + 1;


                        when 23 =>
--# line 146 "ascan.l"
                            Enter (Sc);
                            return ('<');

                        when 24 =>
--# line 147 "ascan.l"
                            return ('^');

                        when 25 =>
--# line 148 "ascan.l"
                            Enter (Quote);
                            return ('"');

                        when 26 =>
                            Yy_Ch_Buf (Yy_Cp) :=
                               Yy_Hold_Char; -- undo effects of setting up yytext
                            Yy_Cp := Yy_Bp + 1;
                            Yy_C_Buf_P := Yy_Cp;
                            Yy_Do_Before_Action; -- set up yytext again
--# line 149 "ascan.l"
                            Enter (Num);
                            return ('{');

                        when 27 =>
--# line 150 "ascan.l"
                            Enter (Braceerror);

                        when 28 =>
                            Yy_Ch_Buf (Yy_Cp) :=
                               Yy_Hold_Char; -- undo effects of setting up yytext
                            Yy_Cp := Yy_Bp + 1;
                            Yy_C_Buf_P := Yy_Cp;
                            Yy_Do_Before_Action; -- set up yytext again
--# line 151 "ascan.l"
                            return ('$');

                        when 29 =>
--# line 153 "ascan.l"
                            Continued_Action := True;
                            Linenum := Linenum + 1;
                            return Newline;


                        when 30 =>
--# line 158 "ascan.l"
                            Linenum := Linenum + 1;
                            Action_Echo;

                        when 31 =>
--# line 160 "ascan.l"

                            -- this rule is separate from the one below because
                            -- otherwise we get variable trailing context, so
                            -- we can't build the scanner using -f,F

                            Bracelevel := 0;
                            Continued_Action := False;
                            Enter (Action);
                            return Newline;


                        when 32 =>
                            Yy_Ch_Buf (Yy_Cp) :=
                               Yy_Hold_Char; -- undo effects of setting up yytext
                            Yy_Cp := Yy_Cp - 1;
                            Yy_C_Buf_P := Yy_Cp;
                            Yy_Do_Before_Action; -- set up yytext again
--# line 171 "ascan.l"

                            Bracelevel := 0;
                            Continued_Action := False;
                            Enter (Action);
                            return Newline;


                        when 33 =>
--# line 178 "ascan.l"
                            Linenum := Linenum + 1;
                            return Newline;

                        when 34 =>
--# line 180 "ascan.l"
                            return (Eof_Op);

                        when 35 =>
--# line 182 "ascan.l"

                            Sectnum := 3;
                            Enter (Sect3);
                            return (End_Of_Input);
                            -- to stop the parser


                        when 36 =>
--# line 189 "ascan.l"


                            Nmstr := Vstr (Yytext (1 .. Yylength));

                            -- check to see if we've already encountered this ccl
                            Cclval := Sym.Ccllookup (Nmstr);
                            if (Cclval /= 0) then
                                Yylval := Cclval;
                                Cclreuse := Cclreuse + 1;
                                return (Prevccl);
                            else
                                -- we fudge a bit.  We know that this ccl will
                                -- soon be numbered as lastccl + 1 by cclinit
                                Sym.Cclinstal (Nmstr, Lastccl + 1);

                                -- push back everything but the leading bracket
                                -- so the ccl can be rescanned

                                Put_Back_String (Nmstr, 1);

                                Enter (Firstccl);
                                return ('[');
                            end if;


                        when 37 =>
--# line 214 "ascan.l"

                            Nmstr := Vstr (Yytext (1 .. Yylength));
                            -- chop leading and trailing brace
                            Tmpbuf := Slice (Vstr (Yytext (1 .. Yylength)),
                                             2, Yylength - 1);

                            Nmdefptr := Sym.Ndlookup (Tmpbuf);
                            if (Nmdefptr = Nul) then
                                Misc.Synerr ("undefined {name}");
                            else
                                -- push back name surrounded by ()'s
                                Unput (')');
                                Put_Back_String (Nmdefptr, 0);
                                Unput ('(');
                            end if;


                        when 38 =>
--# line 231 "ascan.l"
                            Tmpbuf := Vstr (Yytext (1 .. Yylength));
                            case Tstring.Char (Tmpbuf, 1) is
                                when '/' =>
                                    return '/';
                                when '|' =>
                                    return '|';
                                when '*' =>
                                    return '*';
                                when '+' =>
                                    return '+';
                                when '?' =>
                                    return '?';
                                when '.' =>
                                    return '.';
                                when '(' =>
                                    return '(';
                                when ')' =>
                                    return ')';
                                when others =>
                                    Misc.Aflexerror ("error in aflex case");
                            end case;


                        when 39 =>
--# line 245 "ascan.l"
                            Tmpbuf := Vstr (Yytext (1 .. Yylength));
                            Yylval := Character'Pos (Char (Tmpbuf, 1));
                            return Char;


                        when 40 =>
--# line 249 "ascan.l"
                            Linenum := Linenum + 1;
                            return Newline;

                        when 41 =>
--# line 252 "ascan.l"
                            return (',');

                        when 42 =>
--# line 253 "ascan.l"
                            Enter (Sect2);
                            return ('>');

                        when 43 =>
                            Yy_Ch_Buf (Yy_Cp) :=
                               Yy_Hold_Char; -- undo effects of setting up yytext
                            Yy_Cp := Yy_Bp + 1;
                            Yy_C_Buf_P := Yy_Cp;
                            Yy_Do_Before_Action; -- set up yytext again
--# line 254 "ascan.l"
                            Enter (Caretisbol);
                            return ('>');

                        when 44 =>
--# line 255 "ascan.l"
                            Nmstr := Vstr (Yytext (1 .. Yylength));
                            return Name;


                        when 45 =>
--# line 258 "ascan.l"
                            Misc.Synerr ("bad start condition name");

                        when 46 =>
--# line 260 "ascan.l"
                            Enter (Sect2);
                            return ('^');

                        when 47 =>
--# line 263 "ascan.l"
                            Tmpbuf := Vstr (Yytext (1 .. Yylength));
                            Yylval := Character'Pos (Char (Tmpbuf, 1));
                            return Char;


                        when 48 =>
--# line 267 "ascan.l"
                            Enter (Sect2);
                            return ('"');

                        when 49 =>
--# line 269 "ascan.l"

                            Misc.Synerr ("missing quote");
                            Enter (Sect2);
                            Linenum := Linenum + 1;
                            return ('"');


                        when 50 =>
                            Yy_Ch_Buf (Yy_Cp) :=
                               Yy_Hold_Char; -- undo effects of setting up yytext
                            Yy_Cp := Yy_Bp + 1;
                            Yy_C_Buf_P := Yy_Cp;
                            Yy_Do_Before_Action; -- set up yytext again
--# line 277 "ascan.l"
                            Enter (Ccl);
                            return ('^');

                        when 51 =>
                            Yy_Ch_Buf (Yy_Cp) :=
                               Yy_Hold_Char; -- undo effects of setting up yytext
                            Yy_Cp := Yy_Bp + 1;
                            Yy_C_Buf_P := Yy_Cp;
                            Yy_Do_Before_Action; -- set up yytext again
--# line 278 "ascan.l"
                            return ('^');

                        when 52 =>
--# line 279 "ascan.l"
                            Enter (Ccl);
                            Yylval := Character'Pos ('-');
                            return (Char);

                        when 53 =>
--# line 280 "ascan.l"
                            Enter (Ccl);
                            Tmpbuf := Vstr (Yytext (1 .. Yylength));
                            Yylval := Character'Pos (Char (Tmpbuf, 1));
                            return Char;


                        when 54 =>
                            Yy_Ch_Buf (Yy_Cp) :=
                               Yy_Hold_Char; -- undo effects of setting up yytext
                            Yy_Cp := Yy_Bp + 1;
                            Yy_C_Buf_P := Yy_Cp;
                            Yy_Do_Before_Action; -- set up yytext again
--# line 286 "ascan.l"
                            return ('-');

                        when 55 =>
--# line 287 "ascan.l"
                            Tmpbuf := Vstr (Yytext (1 .. Yylength));
                            Yylval := Character'Pos (Char (Tmpbuf, 1));
                            return Char;


                        when 56 =>
--# line 291 "ascan.l"
                            Enter (Sect2);
                            return (']');

                        when 57 =>
--# line 294 "ascan.l"

                            Yylval := Misc.Myctoi (Vstr
                                                      (Yytext (1 .. Yylength)));
                            return (Number);


                        when 58 =>
--# line 299 "ascan.l"
                            return (',');

                        when 59 =>
--# line 300 "ascan.l"
                            Enter (Sect2);
                            return ('}');

                        when 60 =>
--# line 302 "ascan.l"

                            Misc.Synerr ("bad character inside {}'s");
                            Enter (Sect2);
                            return ('}');


                        when 61 =>
--# line 308 "ascan.l"

                            Misc.Synerr ("missing }");
                            Enter (Sect2);
                            Linenum := Linenum + 1;
                            return ('}');


                        when 62 =>
--# line 316 "ascan.l"
                            Misc.Synerr ("bad name in {}'s");
                            Enter (Sect2);

                        when 63 =>
--# line 317 "ascan.l"
                            Misc.Synerr ("missing }");
                            Linenum := Linenum + 1;
                            Enter (Sect2);


                        when 64 =>
--# line 322 "ascan.l"
                            Bracelevel := Bracelevel + 1;

                        when 65 =>
--# line 323 "ascan.l"
                            Bracelevel := Bracelevel - 1;

                        when 66 =>
--# line 324 "ascan.l"
                            Action_Echo;

                        when 67 =>
--# line 325 "ascan.l"
                            Action_Echo;

                        when 68 =>
--# line 326 "ascan.l"
                            Linenum := Linenum + 1;
                            Action_Echo;

                        when 69 =>
--# line 327 "ascan.l"
                            Action_Echo;
                            -- character constant;


                        when 70 =>
--# line 331 "ascan.l"
                            Action_Echo;
                            Enter (Action_String);

                        when 71 =>
--# line 333 "ascan.l"

                            Linenum := Linenum + 1;
                            Action_Echo;
                            if (Bracelevel = 0) then
                                Text_Io.New_Line (Temp_Action_File);
                                Enter (Sect2);
                            end if;


                        when 72 =>
--# line 341 "ascan.l"
                            Action_Echo;

                        when 73 =>
--# line 343 "ascan.l"
                            Action_Echo;

                        when 74 =>
--# line 344 "ascan.l"
                            Action_Echo;

                        when 75 =>
--# line 345 "ascan.l"
                            Linenum := Linenum + 1;
                            Action_Echo;

                        when 76 =>
--# line 346 "ascan.l"
                            Action_Echo;
                            Enter (Action);

                        when 77 =>
--# line 347 "ascan.l"
                            Action_Echo;

                        when 78 =>
--# line 350 "ascan.l"

                            Yylval := Character'Pos
                                         (Misc.Myesc
                                             (Vstr (Yytext (1 .. Yylength))));
                            return (Char);


                        when 79 =>
--# line 355 "ascan.l"

                            Yylval := Character'Pos
                                         (Misc.Myesc
                                             (Vstr (Yytext (1 .. Yylength))));
                            Enter (Ccl);
                            return (Char);


                        when 80 =>
--# line 362 "ascan.l"
                            if (Check_Yylex_Here) then
                                return End_Of_Input;
                            else
                                Echo;
                            end if;


                        when 81 =>
--# line 368 "ascan.l"
                            raise Aflex_Scanner_Jammed;
                        when Yy_End_Of_Buffer + Initial + 1 |
                             Yy_End_Of_Buffer + Sect2 + 1 |
                             Yy_End_Of_Buffer + Sect3 + 1 |
                             Yy_End_Of_Buffer + Pickupdef + 1 |
                             Yy_End_Of_Buffer + Sc + 1 |
                             Yy_End_Of_Buffer + Caretisbol + 1 |
                             Yy_End_Of_Buffer + Num + 1 |
                             Yy_End_Of_Buffer + Quote + 1 |
                             Yy_End_Of_Buffer + Firstccl + 1 |
                             Yy_End_Of_Buffer + Ccl + 1 |
                             Yy_End_Of_Buffer + Action + 1 |
                             Yy_End_Of_Buffer + Recover + 1 |
                             Yy_End_Of_Buffer + Braceerror + 1 |
                             Yy_End_Of_Buffer + Action_String + 1 =>
                            return End_Of_Input;
                        when Yy_End_Of_Buffer =>
                            -- undo the effects of YY_DO_BEFORE_ACTION
                            Yy_Ch_Buf (Yy_Cp) := Yy_Hold_Char;

                            Yytext_Ptr := Yy_Bp;

                            case Yy_Get_Next_Buffer is
                                when Eob_Act_End_Of_File =>
                                    begin
                                        if (Yywrap) then
                                            -- note: because we've taken care in
                                            -- yy_get_next_buffer() to have set up yytext,
                                            -- we can now set up yy_c_buf_p so that if some
                                            -- total hoser (like aflex itself) wants
                                            -- to call the scanner after we return the
                                            -- End_Of_Input, it'll still work - another
                                            -- End_Of_Input will get returned.

                                            Yy_C_Buf_P := Yytext_Ptr;

                                            Yy_Act := Yy_State_Eof
                                                         ((Yy_Start - 1) / 2);

                                            goto Do_Action;
                                        else
                                            --  start processing a new file
                                            Yy_Init := True;
                                            goto New_File;
                                        end if;
                                    end;
                                when Eob_Act_Restart_Scan =>
                                    Yy_C_Buf_P := Yytext_Ptr;
                                    Yy_Hold_Char := Yy_Ch_Buf (Yy_C_Buf_P);
                                when Eob_Act_Last_Match =>
                                    Yy_C_Buf_P := Yy_N_Chars;
                                    Yy_Current_State := Yy_Get_Previous_State;

                                    Yy_Cp := Yy_C_Buf_P;
                                    Yy_Bp := Yytext_Ptr;
                                    goto Next_Action;
                                when others =>
                                    null;
                            end case; -- case yy_get_next_buffer()
                        when others =>
                            Text_Io.Put ("action # ");
                            Text_Io.Put (Integer'Image (Yy_Act));
                            Text_Io.New_Line;
                            raise Aflex_Internal_Error;
                    end case; -- case (yy_act)
            end loop; -- end of loop waiting for end of file
        end Yylex;
--# line 368 "ascan.l"
    begin
        if (Call_Yylex) then
            Toktype := Yylex;
            Call_Yylex := False;
            return Toktype;
        end if;

        if (Eofseen) then
            Toktype := End_Of_Input;
        else
            Toktype := Yylex;
        end if;
-- this tracing code allows easy tracing of aflex runs
        if (Trace) then
            Text_Io.New_Line (Standard_Error);
            Text_Io.Put (Standard_Error, "toktype = :");
            Text_Io.Put (Standard_Error, Token'Image (Toktype));
            Text_Io.Put_Line (Standard_Error, ":");
        end if;

        if (Toktype = End_Of_Input) then
            Eofseen := True;

            if (Sectnum = 1) then
                Misc.Synerr ("unexpected EOF");
                Sectnum := 2;
                Toktype := Sectend;
            else
                if (Sectnum = 2) then
                    Sectnum := 3;
                    Toktype := Sectend;
                end if;
            end if;
        end if;

        if (Trace) then
            if (Beglin) then
                Int_Io.Put (Standard_Error, Num_Rules + 1);
                Text_Io.Put (Standard_Error, Ascii.Ht);
                Beglin := False;
            end if;

            case Toktype is
                when '<' | '>' | '^' | '$' | '"' | '[' | ']' | '{' | '}' | '|' |
                     '(' | ')' | '-' | '/' | '?' | '.' | '*' | '+' | ',' =>
                    Text_Io.Put (Standard_Error, Token'Image (Toktype));

                when Newline =>
                    Text_Io.New_Line (Standard_Error);
                    if (Sectnum = 2) then
                        Beglin := True;
                    end if;

                when Scdecl =>
                    Text_Io.Put (Standard_Error, "%s");

                when Xscdecl =>
                    Text_Io.Put (Standard_Error, "%x");

                when Whitespace =>
                    Text_Io.Put (Standard_Error, " ");

                when Sectend =>
                    Text_Io.Put_Line (Standard_Error, "%%");

                    -- we set beglin to be true so we'll start
                    -- writing out numbers as we echo rules.  aflexscan() has
                    -- already assigned sectnum

                    if (Sectnum = 2) then
                        Beglin := True;
                    end if;

                when Name =>
                    Text_Io.Put (Standard_Error, ''');
                    Text_Io.Put (Standard_Error, Yytext);
                    Text_Io.Put (Standard_Error, ''');

                when Char =>
                    if ((Yylval < Character'Pos (' ')) or
                        (Yylval = Character'Pos (Ascii.Del))) then
                        Text_Io.Put (Standard_Error, '\');
                        Int_Io.Put (Standard_Error, Yylval);
                        Text_Io.Put (Standard_Error, '\');
                    else
                        Text_Io.Put (Standard_Error, Token'Image (Toktype));
                    end if;

                when Number =>
                    Int_Io.Put (Standard_Error, Yylval);

                when Prevccl =>
                    Text_Io.Put (Standard_Error, '[');
                    Int_Io.Put (Standard_Error, Yylval);
                    Text_Io.Put (Standard_Error, ']');

                when End_Of_Input =>
                    Text_Io.Put (Standard_Error, "End Marker");

                when others =>
                    Text_Io.Put (Standard_Error, "Something weird:");
                    Text_Io.Put_Line (Standard_Error, Token'Image (Toktype));
            end case;
        end if;

        return Toktype;

    end Get_Token;
end Scanner;