current community

your communities

more stack exchange communities

Stack Exchange
tour help
careers 2.0
Take the 2-minute tour ×
Stack Overflow is a question and answer site for professional and enthusiast programmers. It's 100% free, no registration required.
up vote 0 down vote favorite

I know this is a bit long, but it's a tricky problem. Thanks for looking! I've been working on this far too long. I've done a lot of research and tried a lot of things, hopefully somebody can help explain.

Outline:

Writing in C. I need to get an array of data from an instrument. The size of the array will vary depending on how much data is collected. I can query the number of data points. I've written a function to collect the data (shown below). This works when the function is called directly in main(). Which I use to test. However, this function will be a dll and called from a function within a higher dll. This does not work. I believe because of the variable size.

I'm lost in the details of variable size and pointers. Any help is appreciated.

Functioning code, called from main()

*Note - Below ViInt16 is a signed short type specific to VISA (communication protocol for instrument). Function returns an int as the status/error (set in other code).

header:

    int GetSamples (ViInt16 *DataArray, int DataSize);

function:

    int GetSamples (ViInt16 *DataArray, int DataSize)
    {
        ViUInt16 N=0;
        ViInt16 Datatemp[DataSize];

        viMoveIn (Handle, N, 0, DataSize, Datatemp);
        memcpy (DataArray, Datatemp, sizeof(Datatemp);
    }

main:

    int totalsamples = (PreTrigPts() + AcqPts())
    ViInt16 Data [totalsamples];
    GetSamples (Data, totalsamples);

This works! I think, only because I can get the total size and then allocate the ViInt16 array from main(). Truthfully, not sure what I'm doing with the pointers, etc. in passing around arrays

The problem is, I'm not sure what to do when it's a function calling a function because, I think, the array needs to be allocated at the top, before I've queried the size. Here is how I am trying to do it (that's not working)

Problem Code

Low level "driver" (called as a dll): 

    Header and function definition from above.

Functions_header: (what calls the low level driver as dll)

    void AutoSample(void);  //No returns. Writes to UI in Functions_list.c

Function_list.c:

    void AutoSample ()
    {
        int PreTriggerPts = 0;  //Declare all variables at top, or won't compile
        int Points = 0;
        int TotalSamples = 0
        ViInt16 MyData [5] = {0};  //arbitrary since don't know size yet

        TotalSamples = (PreTrigPts() + AcqPts());

        ViInt16 MyData[TotalSamples];  //Trying to size by reinitializing? 

        GetSamples (MyData, TotalSamples);

        //...calls another function to write MyData to UI...etc. etc.

Main.c:

    AutoSample();

Errors

I've gotten a lot of errors as I've tried different things. If needed I can be more specific, but if I try to initialize the variable after I know it's size (like I did in the working code), it tells me that's illegal. Putting the declaration up top fixes that. Now I don't know the size to initialize. From here I've just been hacking away, no more specific. There's something I need to do with pointers and memory but I can't figure out what. Please, any help is appreciated!

share|improve this question
    
When you say "it tells me that's illegal", what is the precise error message from the compiler? –  jxh May 31 '13 at 19:08

4 Answers 4

up vote 0 down vote accepted

I think you are going to have to make ViInt16 MyData into a pointer instead of an array, like this:

 ViInt16 *MyData;

Then dynamically allocate a buffer to hold the data once you know its length, like so:

 MyData = (ViInt16*)malloc((sizeof ViInt16) *  TotalSamples);

Note that you will have to free this buffer later, with a call to free.

share|improve this answer
    
How will that affect my original code where I was passing the actual array, since now I'll be passing a pointer? –  Harvster May 31 '13 at 18:57
1  
Using the name of an array in an expression, like this: GetSamples (MyData, TotalSamples); is equivleant to using a pointer to the first element of an array, like this: GetSamples (MyData, &(TotalSamples[0])); So you have been passing a pointer all along. –  npr May 31 '13 at 19:05
    
Using the above gives 2 errors during compile: (1) Illegal use of type name "ViInt16" and (2) Operands of = have illegal types "pointer to int" and "pointer to ViInt16" If I replace ViInt16 with just int (I assume they are compatible) and it compiles and runs. It's not returning the correct data, but I'm getting somewhere. –  Harvster May 31 '13 at 19:53
    
ViInt16 is a signed short. Using int or signed int creates binary points of 32 bits ea. Anyway, all working now. I could swear I tried malloc yesterday. Probably bad syntax or was fiddling with another part of the code when I tried it. –  Harvster May 31 '13 at 20:45
    
Thanks you!!!!! –  Harvster May 31 '13 at 20:45
up vote 0 down vote

You may need to enable C99 mode (gcc --std=c99) to use variable-length arrays. Another option would be to use malloc. The "reinitializing" is never going to work. C cannot resize arrays like that.

share|improve this answer
    
Tried using malloc and realloc, but they don't work with the VISA data types (ViInt16). That stopped me there. I'll put it on the list to try with just an array of int though and see if the data types are compatible. –  Harvster May 31 '13 at 18:54
up vote 0 down vote

A couple of things.

Try this in AutoSample (just like in main):

void AutoSample ()
{
    int PreTriggerPts = 0;  //Declare all variables at top, or won't compile
    int Points = 0;
    int TotalSamples = (PreTrigPts() + AcqPts());
    ViInt16 MyData[TotalSamples];  //Trying to size by reinitializing? 

    GetSamples (MyData, TotalSamples);

    //...calls another function to write MyData to UI...etc. etc.

Also, in GetSamples() you can avoid the memcpy():

int GetSamples (ViInt16 *DataArray, int DataSize)
{
    ViUInt16 N=0;

    viMoveIn (Handle, N, 0, DataSize, DataArray);
}
share|improve this answer
    
Yeah, I got rid of the memcpy. Don't remember why I did that, but obviously not needed. –  Harvster May 31 '13 at 19:47
    
I suppose I simplified an important part, the PreTrigPts and AcqPts also return to variables just like the sampling function, so I can't call them like that, they need to be called and their results put into a variable. –  Harvster May 31 '13 at 19:49
    
Why not? Have your tired it? –  Ziffusion May 31 '13 at 20:09
up vote 0 down vote

You should be able to defer the declaration of your VLA until after you know the number of elements you need1:

void AutoSample ()
{
    int PreTriggerPts = 0;  
    int Points = 0;
    int TotalSamples = 0

    TotalSamples = (PreTrigPts() + AcqPts());

    ViInt16 MyData[TotalSamples];     // initializer not allowed for VLAs
                                      // If you *really* need to initialize a VLA,
                                      // use memset or memcpy

    GetSamples (MyData, TotalSamples);

    //...calls another function to write MyData to UI...etc. etc.

If not, you may need to set a flag on your compiler to allow mixed declarations and code.

Regarding pointers and arrays...

In most circumstances, an expression of type "N-element array of T" will be converted to an expression of type "pointer to T", and the value of the expression will be the address of the first element of the array2. The exceptions to this rule occur when the expression is the operand of the sizeof or unary & operators, or is a string literal being used to initialize another array.

So in the function call

GetSamples (MyData, TotalSamples);

the expression MyData is converted from type "TotalSamples-element array of ViInt16" to type "pointer to ViInt16", and the value received by GetSamples is a pointer to the first element of MyData. This is why your function declaration is written as

int GetSamples (ViInt16 *DataArray, int DataSize);

because what GetSamples actually receives is a pointer value, not an array. You could also have written it as

int GetSamples (ViInt16 DataArray[], int DataSize);

In the context of a function parameter declaration, T a[] and T a[N] are equivalent to T *a. Note that this is only true for function parameter declarations.

VLAs are useful, but they have limitations:

  • They cannot be used at file scope (outside of any function), nor may they be declared static;
  • They cannot be initialized with the usual array initialization syntax;
  • Despite the name, they cannot be resized on the fly;
  • They cannot be arbitarily large;
  • They are not universally supported, and as of the C2011 standard they are optional;

Depending on how many samples you get back, you may want to abandon VLAs and allocate memory from the heap using malloc or realloc.

1 - C99 allows you to mix declarations and code, and if you're successfully using VLAs, then you're most likely using a C99 or later compiler.
2 - Believe it or not, there is a rational explanation for this behavior -- scroll down to the section titled "Embryonic C".

share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.