Without knowing enough about VB, it's kind of difficult to solve the problem, but here are some pointers and suggestions...

For general cases, you could refer to all variables through objects. It might make it easier for your compiler to refer to variables, since they'd be accessable in a more VBScript-type way. It would be be a little less efficient, but would give you a way of dealing with the fact that the thing named 'x' could be a list, a hash, or a scalar. Like so:

use VBVar;

use strict;

# We have b_split return a VBVar object
my $x = b_split('john,biran,someone',',');

# Use value_of(), with optional arguments, to return
# the value of the variable
$response->write( $x->value_of(0), $x->value_of(2));

sub b_split {
    # not fully finished, needs $count and $compare
    my ($string, $delimiter, $count, $compare) = @_;
    $delimiter = quotemeta($delimiter);

    # Passes an array ref to the VBVar constructor,
    # which then creates the underlying object of the right
    # kind
    return VBVar->new([ split(/$delimiter/, $string) ]);
}
[download]

package VBVar;

use strict;

our %VarTypes = ( ARRAY => 'VBVar::Array',
                  SCALAR => 'VBVar::Scalar',
                  HASH => 'VBVar::Hash'
                );

## Have our child classes refer to VBVar as needed
@VBVar::Array::ISA = ('VBVar');
@VBVar::Scalar::ISA = ('VBVar');
@VBVar::Hash::ISA = ('VBVar');

##
## Blesses the reference we pass in to the appropriate
## VBVar type.
##
sub new {
   my $type = shift;
   my $self = shift;

   bless $self, $VarTypes{ref $self};
}

## Return the value of VBVar if contents are an array
sub VBVar::Array::value_of {
   my $self = shift;
   my @indices = @_;

   # If someone passed in a list of indices to return
   if (@indices) {
       return $self->[@indices];
   }
   # Otherwise, return the whole array
   else {
       return @$self;
   }
}

## Return the value of VBVar if contents are
## a scalar
sub VBVar::Scalar::value_of {
   return ${ $_[0] };
}
[download]

N.B. Code not tested, may not even compile, and should not be used directly; just trying to get the idea across.

The advantage to this is that you can have the function that returns the value decide what kind of variable it is. You could also do the same thing by just returning references all the time, and have all of your functions check for type with 'ref' and take whatever action is appropriate.

For information on tie, see perltie.

stephen

You are clearly building your own namespace table -- that's how you determined in the first example that x was an array. In nonstrict code, you're just going to have to determine a variable's type based on assignment. In the second example, that's not too difficult: split would imply an array. But what if the unknown Object is returned from a function:

x = FetchSomethingStrange(a)

Function FetchSomethingStrange(p as Integer)
  If p < 5 Then
    FetchSomethingStrange = split("my,array,result", ",")
  Else
    FetchSomethingStrange = "my string result"
  End If
End Function
[download]

Now, in this case, there's no way of knowing until runtime whether FetchSomethingStrange is going to return a String or an array. That leaves you with 2 options (as I see it):

• a VBVar object, like stephen suggested
• translating all VB arrays to Perl listrefs.

The listrefs would translate your nonstrict code as follows:

$x = b_split('john,biran,someone',',');
print($x->[0] . $x->[2]);

sub b_split {
    # not fully finished, needs $count and $compare
    my ($string, $delimiter, $count, $compare) = @_;
    $delimiter = quotemeta($delimiter);
    return [ split(/$delimiter/, $string) ];
}
[download]

My code translates well, too:

$x = FetchSomethingStrange($a);

sub FetchSomethingStrange {
  my($p) = @_;
  my $FetchSomethingStrange; # Autogenerated return value for VB funct
+ions
  if ($p < 5) {
    $FetchSomethingStrange = b_split("my,array,result", ",");
  }
  else {
    $FetchSomethingStrange = "my string result"
  }
  return $FetchSomethingStrange; # Autoreturn 
}
[download]

Again, you should be fine as long as the Perl translation is always talking in scalars, be they adapted VB scalars (String, Integer, Double) , Variant or Object types, or listrefs derived from Variant/Object auto-arrays or even from explicitly Dimed arrays.

- Richie

* translating all VB arrays to Perl listrefs.

arrayrefs.

U28geW91IGNhbiBhbGwgcm90MTMgY
W5kIHBhY2soKS4gQnV0IGRvIHlvdS
ByZWNvZ25pc2UgQmFzZTY0IHdoZW4
geW91IHNlZSBpdD8gIC0tIEp1ZXJk

Wow, I've done some testing with that, and I seem to be able to get some of it working :-). I'm still unsure of whether to go with the 'VBVar' idea or the listref idea - the listref seems faster, but VBVar seems like it would provide more compatibility.

tlhf
xxx
btw, my converter is for VBScript, not VB. Think ASP.