view release on metacpan or  search on metacpan

lib/CORBA/IDL/ParserFactory.pm  view on Meta::CPAN

        $pos = index($argumentative,$first);
        if ($pos >= 0) {
            if (defined($args[$pos+1]) and ($args[$pos+1] eq ':')) {
                shift(@ARGV);
                if ($rest eq q{}) {
                    $rest = shift(@ARGV);
                }
                $parser->YYData->{"opt_$first"} = $rest;
            }
            else {
                $parser->YYData->{"opt_$first"} = 1;
                if ($rest eq q{}) {
                    shift(@ARGV);
                }
                else {
                    $ARGV[0] = "-$rest";
                }
            }
        }
        else {
            push @{$parser->YYData->{args}}, shift(@ARGV);
        }
    }
}

sub Configure {
    my $parser = shift;
    my %attr = @_;
    while ( my ($key, $value) = each(%attr) ) {
        if (defined $value) {
            $parser->YYData->{$key} = $value;
        }
    }
    return $parser;
}

sub Run {
    my $parser = shift;
    my $preprocessor = $parser->YYData->{preprocessor};

    if ($preprocessor) {
        my @args;
        @args = @{$parser->YYData->{args}}
                if (exists $parser->YYData->{args});
        push @args, @_;

        open $parser->YYData->{fh}, "$preprocessor @args|"
                or die "can't open @_ ($!).\n";
    }
    else {
        my $file = shift;
        if (ref $file) {
            $parser->YYData->{fh} = $file;
            $parser->YYData->{srcname} = shift;
        }
        else {
            open $parser->YYData->{fh}, $file
                    or die "can't open $file ($!).\n";
            $parser->YYData->{srcname} = shift || $file;
        }
        my @st = stat($parser->YYData->{srcname});
        $parser->YYData->{srcname_size} = $st[7];
        $parser->YYData->{srcname_mtime} = $st[9];
    }

    CORBA::IDL::Lexer::InitLexico($parser);
    $parser->YYData->{doc} = q{};
    $parser->YYData->{curr_node} = undef;
    $parser->YYData->{curr_itf} = undef;
    $parser->YYData->{prop} = 0;
    $parser->YYData->{native} = 0;
    $parser->YYParse(
            yylex   => \&CORBA::IDL::Lexer::Lexer,
            yyerror => sub { return; },
#           yydebug => 0x17,
    );

#    Bit Value    Outputs
#    0x01         Token reading (useful for Lexer debugging)
#    0x02         States information
#    0x04         Driver actions (shifts, reduces, accept...)
#    0x08         Parse Stack dump
#    0x10         Error Recovery tracing

    close $parser->YYData->{fh};
    delete $parser->{RULES};
    delete $parser->{STATES};
    delete $parser->{STACK};

    if (exists $parser->YYData->{symbtab}) {
        $parser->YYData->{symbtab}->CheckForward();
        $parser->YYData->{symbtab}->CheckRepositoryID();
    }
}

sub DisplayStatus {
    my $parser = shift;
    if (exists $parser->YYData->{nb_error}) {
        my $nb = $parser->YYData->{nb_error};
        print "$nb error(s).\n"
    }
    if (        $parser->YYData->{verbose_warning}
            and exists $parser->YYData->{nb_warning} ) {
        my $nb = $parser->YYData->{nb_warning};
        print "$nb warning(s).\n"
    }
    if (        $parser->YYData->{verbose_info}
            and exists $parser->YYData->{nb_info} ) {
        my $nb = $parser->YYData->{nb_info};
        print "$nb info(s).\n"
    }
    if (        $parser->YYData->{verbose_deprecated}
            and exists $parser->YYData->{nb_deprecated} ) {
        my $nb = $parser->YYData->{nb_deprecated};
        print "$nb deprecated(s).\n"
    }
}

sub Export {
    my $parser = shift;
    if ( our $IDL_VERSION ge '3.0' ) {