09_parameters.t

SinFP是一种新的识别对方计算机操作系统类型的工具

    $vector[2] = Bit::Vector->new($bits);
    $vector[3] = Bit::Vector->new($bits);
    $vector[4] = Bit::Vector->new($bits);
    $vector[5] = Bit::Vector->new($bits);
    $vector[6] = Bit::Vector->new($bits);
    if ($bits > 0)
    {
        $vector[0]->Bit_On(0);
        $vector[1]->Bit_On(0);
        $vector[2]->Bit_On(0);
        $vector[3]->Bit_On(0);
        $vector[4]->Bit_On(0);
        $vector[5]->Bit_On(0);
        $vector[6]->Bit_On(0);
    }
}

sub correct_values
{
    my($flag) = @_;
    my($i,$type);

#   0  =  object reference
#   1  =  number of bits
#   2  =  index       ( 0 <=     index     <  bits )
#   3  =  offset      ( 0 <=     offset    <= bits )
#   4  =  word index  ( 0 <=     index     <  size )
#   5  =  length      ( 0 <= offset+length <= bits )
#   6  =  arbitrary (non-negative) number
#   7  =  boolean
#   8  =  string
#   9  =  chunksize
#  10  =  anything
#  11  =  rows
#  12  =  columns

    $objects = 0;
    $limited = 1;
    undef @parameter_list;
    for ( $i = 0; $i < $count; $i++ )
    {
        $type = $definition->[$i];
        if ($type >= 16) { $limited = 0; }
        $type &= 0x0F;
        if    ($type == 0)
        {
            $objects++;
            if ($flag)
            {
                $parameter_list[$i] = $vector[0];
            }
            else
            {
                $parameter_list[$i] = $vector[$i];
            }
        }
        elsif ($type == 1)
        {
            $parameter_list[$i] = ($bits << 1) | 1;
        }
        elsif ($type == 2)
        {
            $parameter_list[$i] = $bits - 1;
        }
        elsif ($type == 3)
        {
            $parameter_list[$i] = $bits;
        }
        elsif ($type == 4)
        {
            $parameter_list[$i] = $vector[0]->Word_Size() - 1;
        }
        elsif ($type == 5)
        {
            $parameter_list[$i] = $bits + 1;
        }
        elsif ($type == 6)
        {
            $parameter_list[$i] = (1 << (Bit::Vector->Word_Bits()-1)) - 1;
        }
        elsif ($type == 7)
        {
            $parameter_list[$i] = 1;
        }
        elsif ($type == 8)
        {
            $parameter_list[$i] = '1011';
        }
        elsif ($type == 9)
        {
            $parameter_list[$i] = Bit::Vector->Long_Bits();
        }
        elsif ($type == 10)
        {
            $parameter_list[$i] = 'anything';
        }
        elsif ($type == 11)
        {
            $parameter_list[$i] = int(sqrt($bits) + 0.5);
        }
        elsif ($type == 12)
        {
            $parameter_list[$i] = int(sqrt($bits) + 0.5);
        }
        else
        {
            die "internal error";
        }
    }
}

sub init_values
{
    undef @fake;
    undef @wrong_values;
    undef @error_message;

    $wrong_values[0] = [ ];
    $error_message[0] = [ ];
    $wrong_values[1] = [ ];
    $error_message[1] = [ ];
    $wrong_values[2] = [ ];
    $error_message[2] = [ ];
    $wrong_values[3] = [ ];
    $error_message[3] = [ ];
    $wrong_values[4] = [ ];
    $error_message[4] = [ ];
    $wrong_values[5] = [ ];
    $error_message[5] = [ ];
    $wrong_values[6] = [ ];
    $error_message[6] = [ ];
    $wrong_values[7] = [ ];
    $error_message[7] = [ ];
    $wrong_values[8] = [ ];
    $error_message[8] = [ ];
    $wrong_values[9] = [ ];
    $error_message[9] = [ ];
    $wrong_values[10] = [ ];
    $error_message[10] = [ ];
    $wrong_values[11] = [ ];
    $error_message[11] = [ ];
    $wrong_values[12] = [ ];
    $error_message[12] = [ ];

#   0  =  object reference
#   1  =  number of bits
#   2  =  index       ( 0 <=     index     <  bits )
#   3  =  offset      ( 0 <=     offset    <= bits )
#   4  =  word index  ( 0 <=     index     <  size )
#   5  =  length      ( 0 <= offset+length <= bits )
#   6  =  arbitrary (non-negative) number
#   7  =  boolean
#   8  =  string
#   9  =  chunksize
#  10  =  anything
#  11  =  rows
#  12  =  columns

    if ($objects > 1)
    {
        if ($method !~ /^(?:Concat(?:_List)?|Interval_(?:Copy|Substitute))$/)
        {
            push(@{$wrong_values[0]}, Bit::Vector->new($bits-1));
            push(@{$error_message[0]}, "(?:bit vector|set|matrix) size mismatch");
        }
    }

    $global = 0x000E9CE0;

    if ($method ne "Concat_List")
    {
        push(@{$wrong_values[0]}, $global);
        push(@{$error_message[0]}, "item is not a \"$prefix\" object");
    }

    $fake[0] = Bit::Vector->new($bits);
    $fake[0]->DESTROY();
    push(@{$wrong_values[0]}, $fake[0]);
    push(@{$error_message[0]}, "item is not a \"$prefix\" object");

    $fake[1] = \$global;
    bless($fake[1], $prefix);
    push(@{$wrong_values[0]}, $fake[1]);
    push(@{$error_message[0]}, "item is not a \"$prefix\" object");

#   push(@{$wrong_values[1]}, -1);
#   push(@{$error_message[1]}, "unable to allocate memory");

    push(@{$wrong_values[2]}, $bits);
    push(@{$error_message[2]}, "(?:(?:start |m(?:in|ax)imum )?index|offset) out of range");

    push(@{$wrong_values[2]}, -1);
    push(@{$error_message[2]}, "(?:(?:start |m(?:in|ax)imum )?index|offset) out of range");

    push(@{$wrong_values[3]}, $bits+1);
    push(@{$error_message[3]}, "offset out of range");

    push(@{$wrong_values[3]}, -1);
    push(@{$error_message[3]}, "offset out of range");

    push(@{$wrong_values[4]}, $vector[0]->Word_Size());
    push(@{$error_message[4]}, "offset out of range");

    push(@{$wrong_values[4]}, -1);
    push(@{$error_message[4]}, "offset out of range");

    push(@{$wrong_values[9]}, 0);
    push(@{$error_message[9]}, "chunk size out of range");

    push(@{$wrong_values[9]}, Bit::Vector->Long_Bits()+1);
    push(@{$error_message[9]}, "chunk size out of range");

    push(@{$wrong_values[9]}, -1);
    push(@{$error_message[9]}, "chunk size out of range");

    push(@{$wrong_values[11]}, 0);
    push(@{$error_message[11]}, "matrix size mismatch");

    push(@{$wrong_values[12]}, 0);
    push(@{$error_message[12]}, "matrix size mismatch");

    push(@{$wrong_values[1]}, \$global);
    push(@{$error_message[1]}, "item is not a (?:string|scalar)");

    push(@{$wrong_values[2]}, \$global);
    push(@{$error_message[2]}, "item is not a (?:string|scalar)");

    push(@{$wrong_values[3]}, \$global);
    push(@{$error_message[3]}, "item is not a (?:string|scalar)");

    push(@{$wrong_values[4]}, \$global);
    push(@{$error_message[4]}, "item is not a (?:string|scalar)");

    push(@{$wrong_values[5]}, \$global);
    push(@{$error_message[5]}, "item is not a (?:string|scalar)");

    push(@{$wrong_values[6]}, \$global);
    push(@{$error_message[6]}, "item is not a (?:string|scalar)");

    push(@{$wrong_values[7]}, \$global);
    push(@{$error_message[7]}, "item is not a (?:string|scalar)");

    push(@{$wrong_values[8]}, \$global);
    push(@{$error_message[8]}, "item is not a (?:string|scalar)");

    push(@{$wrong_values[9]}, \$global);
    push(@{$error_message[9]}, "item is not a (?:string|scalar)");

    push(@{$wrong_values[11]}, \$global);
    push(@{$error_message[11]}, "item is not a (?:string|scalar)");

    push(@{$wrong_values[12]}, \$global);
    push(@{$error_message[12]}, "item is not a (?:string|scalar)");
}

__END__