Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C Programming > simple array question

Reply
Thread Tools

simple array question

 
 
Michael
Guest
Posts: n/a
 
      08-18-2006
Hi,

I am trying to pass a function an array of strings, but I am having trouble
getting the indexing to index the strings rather than the individual
characters of one of the strings.
I have declared an array as:

char *stringArray[] = {"one","two","three","a"};

When I pass the array using:
CompareStringArray(*stringArray, 3, min); /*I know I have a magic number
here*/

Then try to access the elements with
func(array+i, array+result); /* func(char *, char
*) */
the array+i is indexing through the first string, rather than through the
array of strings.

I dont understand why array+1 = "ne" and not "two"

can anyone help me with this please?

Regards

Michael



 
Reply With Quote
 
 
 
 
Michael Mair
Guest
Posts: n/a
 
      08-18-2006
Michael schrieb:
> Hi,
>
> I am trying to pass a function an array of strings, but I am having trouble
> getting the indexing to index the strings rather than the individual
> characters of one of the strings.
> I have declared an array as:
>
> char *stringArray[] = {"one","two","three","a"};
>
> When I pass the array using:
> CompareStringArray(*stringArray, 3, min); /*I know I have a magic number
> here*/


Passing *stringArray is equivalent to passing stringArray[0]
which is the start address of a string containing "one".

> Then try to access the elements with
> func(array+i, array+result); /* func(char *, char
> *) */
> the array+i is indexing through the first string, rather than through the
> array of strings.


If you posted actual code, then I would not have to guess whether
func is supposed to be CompareStringArray() even though the number
of parameters changed.

The correct prototype for CompareStringArray() has
"char *StringArray[]" or "char **StringArray" as first parameter.

>
> I dont understand why array+1 = "ne" and not "two"


Probably because you passed the address of "one"...


Cheers
Michael
--
E-Mail: Mine is an /at/ gmx /dot/ de address.
 
Reply With Quote
 
 
 
 
Keith Thompson
Guest
Posts: n/a
 
      08-18-2006
"Michael" <(E-Mail Removed)> writes:
> I am trying to pass a function an array of strings, but I am having trouble
> getting the indexing to index the strings rather than the individual
> characters of one of the strings.
> I have declared an array as:
>
> char *stringArray[] = {"one","two","three","a"};


That's an array of pointers.

A "string" is really more of a data format that a data type. It's
defined by the standard as "a contiguous sequence of characters
terminated by and including the first null character".

What you've declared is an array of pointers to strings (where a
"pointer to a string" is defined as "a pointer to its initial (lowest
addressed) character").

> When I pass the array using:
> CompareStringArray(*stringArray, 3, min); /*I know I have a magic number
> here*/


*stringArray is a value of type char*. It points to the string "one".

> Then try to access the elements with
> func(array+i, array+result); /* func(char *, char
> *) */
> the array+i is indexing through the first string, rather than through the
> array of strings.


Right. When you increment a pointer to FOO, the result points to the
next FOO in memory (assuming there is one). In this case, you're
incrementing a pointer to char (pointing to the 'o' of "one" and
getting a pointer to the next char (pointig to the 'n' of "one").

Your CompareStringArray function needs to have a parameter of type
char**, and you need to pass it stringArray, not *stringArray.

And you need to read section 6 of the comp.lang.c FAQ,
<http://www.c-faq.com/>.

--
Keith Thompson (The_Other_Keith) http://www.velocityreviews.com/forums/(E-Mail Removed) <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.
 
Reply With Quote
 
CBFalconer
Guest
Posts: n/a
 
      08-18-2006
Michael wrote:
>
> I am trying to pass a function an array of strings, but I am
> having trouble getting the indexing to index the strings rather
> than the individual characters of one of the strings.
> I have declared an array as:
>
> char *stringArray[] = {"one","two","three","a"};
>
> When I pass the array using:
> CompareStringArray(*stringArray, 3, min); /*I know I have a
> magic number here*/
>
> Then try to access the elements with
> func(array+i, array+result); /* func(char *, char *) */
> the array+i is indexing through the first string, rather than
> through the array of strings.
>
> I dont understand why array+1 = "ne" and not "two"
>
> can anyone help me with this please?


You are not keeping the types of things clear. Keeping your
declaration only, if we then pass that to a function:

foo(stringarray)

the function would be declared as:

foo(char **arr)
or
foo(char *arr[])

the point being that what foo sees is an array of pointers to char,
identified by a pointer to the first of those, i.e. the char **.
You can now get pointers to the various strings by dereferencing
arr[i] for some i from 0 to the number available.

foo(char **arr) {
char *p;
int i;

for (i = 0; i < 3; i++) {
p = arr[i];
/* operate on p to access the string */
/* which is read-only for your declaration */
puts(p); /* for example */
}
}

It would be well to have the original declaration mark its own
boundary by terminating it with a NULL, ie:

char *stringArray[] = {"one", "two", "three", "a", NULL};

--
"The power of the Executive to cast a man into prison without
formulating any charge known to the law, and particularly to
deny him the judgement of his peers, is in the highest degree
odious and is the foundation of all totalitarian government
whether Nazi or Communist." -- W. Churchill, Nov 21, 1943

 
Reply With Quote
 
Michael
Guest
Posts: n/a
 
      08-18-2006

"Michael Mair" <(E-Mail Removed)> wrote in message
news:(E-Mail Removed)...
> Michael schrieb:
>> Hi,
>>
>> I am trying to pass a function an array of strings, but I am having
>> trouble getting the indexing to index the strings rather than the
>> individual characters of one of the strings.
>> I have declared an array as:
>>
>> char *stringArray[] = {"one","two","three","a"};
>>
>> When I pass the array using:
>> CompareStringArray(*stringArray, 3, min); /*I know I have a magic
>> number here*/

>
> Passing *stringArray is equivalent to passing stringArray[0]
> which is the start address of a string containing "one".
>
>> Then try to access the elements with
>> func(array+i, array+result); /* func(char *,
>> char *) */
>> the array+i is indexing through the first string, rather than through the
>> array of strings.

>
> If you posted actual code, then I would not have to guess whether
> func is supposed to be CompareStringArray() even though the number
> of parameters changed.
>
> The correct prototype for CompareStringArray() has
> "char *StringArray[]" or "char **StringArray" as first parameter.
>
>>
>> I dont understand why array+1 = "ne" and not "two"

>
> Probably because you passed the address of "one"...
>
>
> Cheers
> Michael
> --
> E-Mail: Mine is an /at/ gmx /dot/ de address.


Ok, following is what I have written.

When I originally wrote this I had **stringArray, not *stringArray in my
function call, but the compiler complained:
"passing arg 1 of CompareStringArray makes pointer from integer without a
cast".
I know I have some magic numbers and stuff, I'm really just trying to sort
out the array stuff though.

int main(){
char *stringArray[] = {"one","two","three","four","five"};
int smallest;
int largest;

smallest = CompareStringArray(*stringArray, 4, min);
largest = CompareStringArray(*stringArray, 4, max);

if(smallest > -1){
printf("\nsmallest is %s at position
%d",stringArray[smallest], smallest);
}else {
printf("\nempty array");
}
if(largest > -1){
printf("\nlargest is %s at position
%d",stringArray[largest], largest);
}else {
printf("\nempty array");
}

fgetc(stdin);
return 0;
}



int max(char *string1, char *string2){
int result = FALSE;

if(strlen(string1) > strlen(string2)){
result = TRUE;
}

return result;
}

int min(char *string1, char *string2){
int result = FALSE;

if(strlen(string1) < strlen(string2)){
result = TRUE;
}

return result;
}

int CompareStringArray(char *array, int size, int (*func)(char*, char*)){
int i;
int result;

if(!strlen(array)){
result = 0; /*arbitrary starting point
for result*/
for(i = 0; i < size; i++){
if(func(array+i, array+result)){ /*check if current is longer
than longest found yet*/
result = i;
}
}
} else {
result = -1; /*zero length array*/
}
return result;
}


 
Reply With Quote
 
pete
Guest
Posts: n/a
 
      08-18-2006
Michael wrote:
>
> "Michael Mair" <(E-Mail Removed)> wrote in message
> news:(E-Mail Removed)...
> > Michael schrieb:
> >> Hi,
> >>
> >> I am trying to pass a function an array of strings, but I am having
> >> trouble getting the indexing to index the strings rather than the
> >> individual characters of one of the strings.
> >> I have declared an array as:
> >>
> >> char *stringArray[] = {"one","two","three","a"};
> >>
> >> When I pass the array using:
> >> CompareStringArray(*stringArray, 3, min); /*I know I have a magic
> >> number here*/

> >
> > Passing *stringArray is equivalent to passing stringArray[0]
> > which is the start address of a string containing "one".
> >
> >> Then try to access the elements with
> >> func(array+i, array+result); /* func(char *,
> >> char *) */
> >> the array+i is indexing through the first string, rather than through the
> >> array of strings.

> >
> > If you posted actual code, then I would not have to guess whether
> > func is supposed to be CompareStringArray() even though the number
> > of parameters changed.
> >
> > The correct prototype for CompareStringArray() has
> > "char *StringArray[]" or "char **StringArray" as first parameter.
> >
> >>
> >> I dont understand why array+1 = "ne" and not "two"

> >
> > Probably because you passed the address of "one"...
> >
> >
> > Cheers
> > Michael
> > --
> > E-Mail: Mine is an /at/ gmx /dot/ de address.

>
> Ok, following is what I have written.
>
> When I originally wrote this I had **stringArray, not *stringArray in my
> function call, but the compiler complained:
> "passing arg 1 of CompareStringArray makes pointer from integer without a
> cast".
> I know I have some magic numbers and stuff, I'm really just trying to sort
> out the array stuff though.
>
> int main(){
> char *stringArray[] = {"one","two","three","four","five"};
> int smallest;
> int largest;
>
> smallest = CompareStringArray(*stringArray, 4, min);
> largest = CompareStringArray(*stringArray, 4, max);
>
> if(smallest > -1){
> printf("\nsmallest is %s at position
> %d",stringArray[smallest], smallest);
> }else {
> printf("\nempty array");
> }
> if(largest > -1){
> printf("\nlargest is %s at position
> %d",stringArray[largest], largest);
> }else {
> printf("\nempty array");
> }
>
> fgetc(stdin);
> return 0;
> }
>
> int max(char *string1, char *string2){
> int result = FALSE;
>
> if(strlen(string1) > strlen(string2)){
> result = TRUE;
> }
>
> return result;
> }
>
> int min(char *string1, char *string2){
> int result = FALSE;
>
> if(strlen(string1) < strlen(string2)){
> result = TRUE;
> }
>
> return result;
> }
>
> int CompareStringArray(char *array, int size, int (*func)(char*, char*)){
> int i;
> int result;
>
> if(!strlen(array)){
> result = 0; /*arbitrary starting point
> for result*/
> for(i = 0; i < size; i++){
> if(func(array+i, array+result)){ /*check if current is longer
> than longest found yet*/
> result = i;
> }
> }
> } else {
> result = -1; /*zero length array*/
> }
> return result;
> }


/* BEGIN ptr_sort.c */
/*
** lencomp() compares pointers to strings,
** according to string length.
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define SORT_FUNCTIONS { \
no_sort, "This is the original order of the test array:",\
si_sort, "Stable insertionsort:", \
s38sort, "Nonstable Shellsort, four is after " \
"nine, and eight is before three:", \
q_sort, "Standard library qsort, " \
"unspecified ordering of equal keys:", \
}
#define NUMBERS { \
{"one"},{ "two"},{"three"},{"four"},{"five"}, \
{"six"},{"seven"},{"eight"},{"nine"},{ "ten"}, \
}
#define GT(A, B) (lencomp((A), (B)) > 0)
#define NMEMB (sizeof numbers / sizeof *numbers)
#define SORTS (sizeof s_F / sizeof *s_F)
#define str(s) # s
#define xstr(s) str(s)
#define E_TYPE char *

typedef E_TYPE e_type;

int lencomp(const void *, const void *);
void no_sort(e_type *, size_t);
void si_sort(e_type *, size_t);
void s38sort(e_type *, size_t);
void q_sort(e_type *, size_t);

int main(void)
{
size_t element, sort;
struct sf {
void (*function)(e_type *, size_t);
const char *description;
} s_F[] = SORT_FUNCTIONS;
const e_type numbers[] = NUMBERS;
e_type copy[NMEMB];

puts("/* BEGIN output from ptr_sort.c */\n");
puts("Arrays of type " xstr(E_TYPE)
",\nare being sorted by string length.");
for (sort = 0; sort != SORTS; ++sort) {
putchar('\n');
puts(s_F[sort].description);
memcpy(copy, numbers, sizeof copy);
s_F[sort].function(copy, NMEMB);
for (element = 0; element != NMEMB; ++element) {
puts(copy[element]);
}
}
puts("\n/* END output from ptr_sort.c */");
return 0;
}

int lencomp(const void *a, const void *b)
{
const size_t a_len = strlen(*(e_type *)a);
const size_t b_len = strlen(*(e_type *)b);

return b_len > a_len ? -1 : a_len != b_len;
}

void no_sort(e_type *array, size_t nmemb)
{
array, nmemb;
}

void si_sort(e_type *array, size_t nmemb)
{
e_type temp, *base, *low, *high;

if (nmemb-- > 1) {
base = array;
do {
low = array++;
if (GT(low, array)) {
high = array;
temp = *high;
do {
*high-- = *low;
if (low == base) {
break;
}
--low;
} while (GT(low, &temp));
*high = temp;
}
} while (--nmemb != 0);
}
}

void s38sort(e_type *array, size_t nmemb)
{
e_type temp, *i, *j, *k, *after;

after = array + nmemb;
if (nmemb > (size_t)-1 / 3) {
nmemb /= 3;
}
do {
for (i = array + nmemb; after != i; ++i) {
j = i - nmemb;
if (GT(j, i)) {
k = i;
temp = *k;
do {
*k = *j;
k = j;
if (nmemb + array > j) {
break;
}
j -= nmemb;
} while (GT(j, &temp));
*k = temp;
}
}
nmemb = nmemb != 2 ? 3 * nmemb / 8 : 1;
} while (nmemb != 0);
}

void q_sort(e_type *array, size_t nmemb)
{
qsort(array, nmemb, sizeof *array, lencomp);
}

/* END ptr_sort.c */


--
pete
 
Reply With Quote
 
CBFalconer
Guest
Posts: n/a
 
      08-18-2006
Michael wrote:
> "Michael Mair" <(E-Mail Removed)> wrote in message
>

.... snip ...
>>
>> The correct prototype for CompareStringArray() has
>> "char *StringArray[]" or "char **StringArray" as first parameter.
>>

REMEMBER THE ABOVE
... snip ...
>
> Ok, following is what I have written.
>
> When I originally wrote this I had **stringArray, not *stringArray in my
> function call, but the compiler complained:
> "passing arg 1 of CompareStringArray makes pointer from integer without a
> cast".


And remember that too.

The following is only what I had to do to your source to make it
compile (not run). The changes consist of proper formatting (via
indent), judicious insertion of the 'const' keyword, and addition
of the #includes and #defines at the start. In addition I had to
move the function definitions so that functions are defined before
use. The source line length is limited to something that will
avoid wrapping on most newsreaders, and the 'void' is added to the
definition of main.

You are still using some nominally illegal variable names, i.e.
"stri....". These, among others, are reserved for the
implementation and can nip you in the butt.

With the above 'remember's and the cleaned up compilable source,
see if you can figure out the basic problems that remain.

#include <stdio.h>
#include <string.h>

#define FALSE (0)
#define TRUE (1)

/* ----------------------- */

int max(const char *string1, const char *string2)
{
int result = FALSE;

if (strlen(string1) > strlen(string2)) {
result = TRUE;
}
return result;
}

/* ----------------------- */

int min(const char *string1, const char *string2)
{
int result = FALSE;

if (strlen(string1) < strlen(string2)) {
result = TRUE;
}
return result;
}

/* ----------------------- */

int CompareStringArray(const char *array, int size,
int (*func)(const char *, const char *))
{
int i;
int result;

if (!strlen(array)) {
result = 0; /* arbitrary starting point for result */
for (i = 0; i < size; i++) {
if (func(array + i, array + result)) {
/* check if current is longer than longest found yet */
result = i;
}
}
}
else {
result = -1; /* zero length array */
}
return result;
}

/* ----------------------- */

int main(void)
{
const char *stringArray[] =
{ "one", "two", "three", "four", "five" };
int smallest;
int largest;

smallest = CompareStringArray(*stringArray, 4, min);
largest = CompareStringArray(*stringArray, 4, max);

if (smallest > -1) {
printf("\nsmallest is %s at position %d",
stringArray[smallest], smallest);
}
else {
printf("\nempty array");
}
if (largest > -1) {
printf("\nlargest is %s at position %d",
stringArray[largest], largest);
}
else {
printf("\nempty array");
}
fgetc(stdin);
return 0;
}

--
"The power of the Executive to cast a man into prison without
formulating any charge known to the law, and particularly to
deny him the judgement of his peers, is in the highest degree
odious and is the foundation of all totalitarian government
whether Nazi or Communist." -- W. Churchill, Nov 21, 1943


 
Reply With Quote
 
Joe Wright
Guest
Posts: n/a
 
      08-18-2006
Michael wrote:
> Hi,
>
> I am trying to pass a function an array of strings, but I am having trouble
> getting the indexing to index the strings rather than the individual
> characters of one of the strings.
> I have declared an array as:
>
> char *stringArray[] = {"one","two","three","a"};
>
> When I pass the array using:
> CompareStringArray(*stringArray, 3, min); /*I know I have a magic number
> here*/
>
> Then try to access the elements with
> func(array+i, array+result); /* func(char *, char
> *) */
> the array+i is indexing through the first string, rather than through the
> array of strings.
>
> I dont understand why array+1 = "ne" and not "two"
>
> can anyone help me with this please?
>


Your definition of stringArray is 'array of pointer to char'. Expressing
stringArray will give you the first pointer. *stringArray is the first
character of the first string. Think about it.

--
Joe Wright
"Everything should be made as simple as possible, but not simpler."
--- Albert Einstein ---
 
Reply With Quote
 
Michael
Guest
Posts: n/a
 
      08-19-2006

"CBFalconer" <(E-Mail Removed)> wrote in message
news:(E-Mail Removed)...
> Michael wrote:
>> "Michael Mair" <(E-Mail Removed)> wrote in message
>>

> ... snip ...
>>>
>>> The correct prototype for CompareStringArray() has
>>> "char *StringArray[]" or "char **StringArray" as first parameter.
>>>

> REMEMBER THE ABOVE
> ... snip ...
>>
>> Ok, following is what I have written.
>>
>> When I originally wrote this I had **stringArray, not *stringArray in my
>> function call, but the compiler complained:
>> "passing arg 1 of CompareStringArray makes pointer from integer without a
>> cast".

>
> And remember that too.
>
> The following is only what I had to do to your source to make it
> compile (not run). The changes consist of proper formatting (via
> indent), judicious insertion of the 'const' keyword, and addition
> of the #includes and #defines at the start. In addition I had to
> move the function definitions so that functions are defined before
> use. The source line length is limited to something that will
> avoid wrapping on most newsreaders, and the 'void' is added to the
> definition of main.
>
> You are still using some nominally illegal variable names, i.e.
> "stri....". These, among others, are reserved for the
> implementation and can nip you in the butt.
>
> With the above 'remember's and the cleaned up compilable source,
> see if you can figure out the basic problems that remain.
>
> #include <stdio.h>
> #include <string.h>
>
> #define FALSE (0)
> #define TRUE (1)
>
> /* ----------------------- */
>
> int max(const char *string1, const char *string2)
> {
> int result = FALSE;
>
> if (strlen(string1) > strlen(string2)) {
> result = TRUE;
> }
> return result;
> }
>
> /* ----------------------- */
>
> int min(const char *string1, const char *string2)
> {
> int result = FALSE;
>
> if (strlen(string1) < strlen(string2)) {
> result = TRUE;
> }
> return result;
> }
>
> /* ----------------------- */
>
> int CompareStringArray(const char *array, int size,
> int (*func)(const char *, const char *))
> {
> int i;
> int result;
>
> if (!strlen(array)) {
> result = 0; /* arbitrary starting point for result */
> for (i = 0; i < size; i++) {
> if (func(array + i, array + result)) {
> /* check if current is longer than longest found yet */
> result = i;
> }
> }
> }
> else {
> result = -1; /* zero length array */
> }
> return result;
> }
>
> /* ----------------------- */
>
> int main(void)
> {
> const char *stringArray[] =
> { "one", "two", "three", "four", "five" };
> int smallest;
> int largest;
>
> smallest = CompareStringArray(*stringArray, 4, min);
> largest = CompareStringArray(*stringArray, 4, max);
>
> if (smallest > -1) {
> printf("\nsmallest is %s at position %d",
> stringArray[smallest], smallest);
> }
> else {
> printf("\nempty array");
> }
> if (largest > -1) {
> printf("\nlargest is %s at position %d",
> stringArray[largest], largest);
> }
> else {
> printf("\nempty array");
> }
> fgetc(stdin);
> return 0;
> }
>
> --
> "The power of the Executive to cast a man into prison without
> formulating any charge known to the law, and particularly to
> deny him the judgement of his peers, is in the highest degree
> odious and is the foundation of all totalitarian government
> whether Nazi or Communist." -- W. Churchill, Nov 21, 1943
>
>


Thanks for the help, but you don't seem to have changed anything about the
way the array is passed or handled, which is where my problem is.
The array+i still indexes through the first element, rather than through the
array of strings.
I know this is to do with the way I am passing the array, but I cant figure
out what concept I have misunderstood.

const char *stringArray[] =
{ "one", "two", "three", "four", "five" };
so
stringArray[0][0] = 'o'
stringArray[0][1] = 'n'
stringArray[0][2] = 'e'
correct?

so
stringArray[0] = 'one'
correct?

so
*stringArray = 'one'
correct?

Regards

Michael


 
Reply With Quote
 
CBFalconer
Guest
Posts: n/a
 
      08-19-2006
Michael wrote:
> "CBFalconer" <(E-Mail Removed)> wrote in message
>> Michael wrote:
>>> "Michael Mair" <(E-Mail Removed)> wrote in message
>>>

>> ... snip ...
>>>>
>>>> The correct prototype for CompareStringArray() has
>>>> "char *StringArray[]" or "char **StringArray" as first parameter.
>>>>

>> REMEMBER THE ABOVE
>> ... snip ...
>>>
>>> Ok, following is what I have written.
>>>
>>> When I originally wrote this I had **stringArray, not *stringArray
>>> in my function call, but the compiler complained:
>>> "passing arg 1 of CompareStringArray makes pointer from integer
>>> without a cast".

>>
>> And remember that too.
>>

.... snip ...
>
> Thanks for the help, but you don't seem to have changed anything
> about the way the array is passed or handled, which is where my
> problem is. The array+i still indexes through the first element,
> rather than through the array of strings.
> I know this is to do with the way I am passing the array, but I
> cant figure out what concept I have misunderstood.
>
> const char *stringArray[] =
> { "one", "two", "three", "four", "five" };
> so
> stringArray[0][0] = 'o'
> stringArray[0][1] = 'n'
> stringArray[0][2] = 'e'
> correct?
>
> so
> stringArray[0] = 'one'
> correct?


No. stringArray[0] is a pointer to the char array "one\0", which
in turn is a C string.

I deliberately left your program fundamentally unchanged but
readable (and compileable) so you could learn something. Look up
at the start of this message at the two "remember"s I left about
earlier comments for some clues.

--
"The power of the Executive to cast a man into prison without
formulating any charge known to the law, and particularly to
deny him the judgement of his peers, is in the highest degree
odious and is the foundation of all totalitarian government
whether Nazi or Communist." -- W. Churchill, Nov 21, 1943


 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
const and array of array (of array ...) Mara Guida C Programming 3 09-03-2009 07:54 AM
simple, simple array question Peter Bailey Ruby 7 04-08-2008 01:54 PM
length of an array in a struct in an array of structs in a struct in an array of structs Tuan Bui Perl Misc 14 07-29-2005 02:39 PM
Length of Array of Array of Array Tom Perl Misc 3 12-20-2004 05:23 PM
Re: Simple Simple question!!! ashelley@inlandkwpp.com ASP .Net 0 06-25-2004 04:18 PM



Advertisments