CompuServe Thread

Bart, I don't know enough to help you with the stack question, but I think I can help you with the rest. The (argc, *argv[]) construct is quite common in C. When a program is executed on most systems, the whole argument line from the CLI is passed to the executing program. Using a fairly simple routine, it is possible to parse the argument string and figure out what the user typed so that arguments are accepted. K&R (Kernighan & Ritchie) "The C Language," Second Edition, provides an adequate example of how to parse CLI arguments in pages 114-118. As you stated, a knowledge of the C language helps immensely with programming this beast. I did wonder as to your use of (argc, **argv). The first value is the number of arguments, including the first argument, i.e. the program name, that is passed to the called program. The second argument, *argv[], is an array of strings (characters) that can be indexed into to parse the strings. While **argv is "technically" correct, the more familiar usage is *argv[] (which is exactly the same thing as **argv). What does this mean to you? A bit of discussion is called for. In C, pointers are one of the more powerful tools available to the programmer. I'm sure, at this point, that you understand "what" a pointer is (i.e. an address of a data _value_), but I don't think you understand the syntax involved. In C, when you declare a pointer, you declare it in the following syntax: long *x; where x is the address of some long integer (i.e. 32 bit integer) you have somewhere, and *x is the value stored there. (Confused? I was! * in the declaration of a variable tells the compiler that you want to store an address, * in the usage of a variable means "I want the contents referred to by this address"). It is a given that you may already have the data _value_ stored somewhere, all you are doing here is telling the compiler to provide space to store the _pointer_ (i.e. address of) that _value_. Okay, now that you have the pointer, what do you do with it? Well, you can have it point to successive values stored in the system. If you have 20 long integers stored _succesively_, you can simply bump (increment) the pointer by one to point to the next value in memory. If, for instance, you had 3 long integers stored in memory, in successive memory locations, you could do an assignment picking off each of the successive values. Look at the following code fragment: long a[]={32, 64, 128}; /* Array of three elements 32, 64, 128 */ long *x=a; /* Assign pointer x to a[0]'s location */ printf("%l",*x); /* print first element */ printf("%l, *x+1); /* print second element */ printf("%l, *x+2); /* print third element */ As you will notice, bumping the pointer automagically skips, no matter what the element size, be it short, long, or even a complex record, to the next element, as it should, since we _are_ incrementing the "address of" some structural element's pointer. One of the curious, but nice, features of C is that array names behave like pointers, i.e., the first array element (element 0) is exactly the same address as a pointer of the same name. They are one and the same. So, when you see **argv, this is the same thing as *argv[0], which means, I've passed you a pointer to the first element of an array. You can bump this variable to point to the next element in the array. **argv+1 should give you the next string in the array of strings. So, if you, the user, had typed in a command line as follows: Whatzit abc def The programmer would see, passed to him, is an array of three strings with the following values: **argv = Whatzit **argv+1 = abc **argv+2 = def What is passed to you, the programmer, is a sequence of strings in an array. What you need to do is create a loop that, using argc (the ARGument Count) as the loop counter, grabs each of the strings and parses the meaning, or non-meaning, of each of the arguments. Each element will end in a C standard null byte, i.e. \0 = 0x00. The first argument *argv[0], or **argv, is, supposedly, the program name of your program. I hope this helps. Brian

In standard C, ALL arguments are always passed on the stack. Every C compiler I have seen though, allows you to choose to pass params in registers, and some allow both stack AND registers to be used. Since the startup would be expected to be "standard" however, the stack is the place to look. Coincidentally, there *may* happen to be some leftovers in registers from when the startup fromend did its magic processing. The * is the neophyte C programmers nightmare. Its use is *very* context-dependent. When declaring a variable, it means address (such as would be stored in A1). In an expression where it does not mean multiplication, it dereferences an address (such as move.b (a3),d0. Double asterisks mean the address of an address. This only makes sense in assembly terms if you realise that an address is stored in memory like any other variable. UBYTE and BYTE are non-standard definitions that refer to 8bit quantities. The first is unsigned and the second signed. The only difference is subtleties such as sign extending when you convert them into 16 bit quantities, ASR vs LSR when shifting them right, etc. Brackets around a type (UBYTE) means that you are converting a variable to another type. So if you have a 16bit quantity (move.w d0,d1) and then use (UBYTE), the compiler will start generating move.b instructions. Steve the G. [BEDFORDSHIRE, UK]