If you have a known number of dimensions, known data type, and in-line code, the loop within a loop method is common-place. If, however, you are working inside of function or subroutine and the array is passed in as an argument, you will need to use the array access functions:

"function dims( var a as array ) as int"
"function dimLimit( n as int, var a as array ) as int"
"function elementType( var a as array ) as string"

"function intElement( var a as array, ... as int ) as int"
"function doubleElement( var a as array, ... as int ) as double"
"function moneyElement( var a as array, ... as int ) as money"
"function booleanElement( var a as array, ... as int ) as boolean"
"function charElement( var a as array, ... as int ) as char"
"function dateElement( var a as array, ... as int ) as date"
"function timeElement( var a as array, ... as int ) as time"
"function stringElement( var a as array, ... as int ) as string"

"subroutine setIntElement( newValue as int, var a as array, ... as int )"
"subroutine setDoubleElement( newValue as double, var a as array, ... as int )"
"subroutine setMoneyElement( newValue as money, var a as array, ... as int )"
"subroutine setBooleanElement( newValue as boolean, var a as array, ... as int )"
"subroutine setCharElement( newValue as char, var a as array, ... as int )"
"subroutine setDateElement( newValue as date, var a as array, ... as int )"
"subroutine setTimeElement( newValue as time, var a as array, ... as int )"
"subroutine setStringElement( newValue as string, var a as array, ... as int )"

These allow you to access arrays without having to pass in the number of dimensions or even the data type of the array. You could write a single subroutine that "empties" (I assume you mean initializes) all of your arrays.

If you have a need for truly arbitrary dimensions, I recommend that you consider using a one dimensional array, and use read and write access functions that "flatten" the additional dimensions:

2D:
position = (width * y) + x

3D:
position = (height * width * z) + (width * y) + x;

etc...

If you use an array to hold the boundaries for each dimension, you can literally create an array as many dimensions as your memory capacity will allow.

Finally realized that 3-D is the way to go (still pretty generic!): -
Subroutine EmptyArray(var sAR as array)

/*An investment management application contains string, money and int LE's. 3-D arrays
housed in Global Code are used as 'warehouses' for manipulating and parsing
information entered on one form of a 3-tier relational database to several others,
where each open form may have a result set to be populated.
LE Names are on the x-axis: [x, 1, 1], [x, 1, 2], [x, 1, 3] and so on.
The z-axis represents the several forms, the result set totals of each of which are on the y-axis.
These are entered in Global Code. The subroutine leaves the LE Names unaltered.*/

var vType as string
var vZ as int
var vY as int
var vX as int
var line as int
var col as int
var deep as int

vX = DimLimit(1, sAR)      //The first form (z = 1) is chosen as having the greatest no. of LE's
vY = DimLimit(2, sAR)      //Result set total for the form with the greatest number of instances open
vZ = DimLimit(3, sAR)   //The mumber of different forms being processed

vType = ElementType(sAR)
if vType = "string"
{
While line <= vX
     {
     line = 1
     col = 2
     While col <= vY
           {
           deep = 1
           while deep <= vZ
                 {
                 SetStringElement("", sAR, line, col, deep)
                 deep = deep + 1
                 }
           col = col + 1
           }
     line = line + 1
     }
}
if vType = "int"
{
While line <= vX
     {
     line = 1
     col = 2
     While col <= vY
           {
           deep = 1
           while deep <= vZ
                 {
                 SetIntElement(0, sAR, line, col, deep)
                 deep = deep + 1
                 }
           col = col + 1
           }
     line = line + 1
     }
}
if vType = "money"
{
While line <= vX
     {
     line = 1
     col = 2
     While col <= vY
           {
           deep = 1
           while deep <= vZ
                 {
                 SetMoneyElement(0, sAR, line, col, deep)
                 deep = deep + 1
                 }
           col = col + 1
           }
     line = line + 1
     }
}
End Subroutine

OK, sure. I get it now.