Read the Swordfish Help file about subroutines overloading.
When you do overloading, you must **not** create, in anyway, an ambiguous situation.
When you call your routine with only one parameter, the compiler (humans also) cannot determine your intentions.
Check help file, it has extensive explanation, and last example in it reproduces absolutely your situation
From SF help file:
Overloading
Overloading enables you to have multiple subroutines and functions in the same scope that share the same name. The compiler will select the most appropriate routine to call, based on its signature. A subroutine or function signature is constructed by using the number of formal parameters and also the type of each parameter. An overloaded routine must therefore have a unique combination of parameters, so that the compiler can identify which routine to call during compilation. For example,
function Multiply(pValueA, pValueB as byte) as word
Result = pValueA * pValueB
end function
function Multiply(pValueA, pValueB as byte) as float
Result = pValueA * pValueB
end function
will generate an error because the overloaded function signatures are identical. That is, they both have two parameters each of type byte. It is important to note that the compiler does not use function return types as part of the signature, only parameters The previous problem can be corrected by overloading the function with a unique parameter signature, like this,
function Multiply(pValueA, pValueB as byte) as word
Result = pValueA * pValueB
end function
function Multiply(pValueA, pValueB as float) as float
Result = pValueA * pValueB
end function
dim Result as word
Result = Multiply(10,20)
In this example, the first overloaded function is called because the parameter arguments are of type byte. The compiler will try and invoke the routine whose parameters have the smallest range that will accommodate the arguments in the call. For example, if the call to Multiply() is made with the following arguments,
Result = Multiply(-10,20)
then the second function will be called, because the floating point parameter is the only one that can accommodate a value of -10.
If the type of the value to be returned is to be the only unique way of identifying an overloaded routine a Sub should be used and the result of the routine passed byRef in the parameters. For example:
sub MySub(byref pValue As Byte)
end sub
Sub MySub(byref pValue As Word)
end sub
If any parameters are assigned a constant in an overloaded routine, care should be taken to ensure you don't inadvertently create a situation where a routine cannot be called, for example,
sub MySub(pValueA as byte, pValueB as word = 0)
end sub
sub MySub(pValueA as byte)
end sub
MySub(10)
In this example, the compiler cannot determine if the first or second overloaded routine should be called, because the parameter arguments are ambiguous.