const array

[jackymaillist]

here is my data structure

typedef struct{
char colorType;
unsigned short numEntries;
unsigned int* palette;
}CLUT;

const unsigned int clut001palette[16] = {
0x8000F000, 0x0000E000, 0x0000C800, 0x0000C000,
0x00009800, 0x00009800, 0x00009800, 0x00048004,
0x00006C00, 0x00006400, 0x0008500C, 0x00106810,
0x00108C10, 0x00149814, 0x0018A818, 0x0018A018,
//...
};

const CLUT clut001 = {RGBA555, 256, clut001palette};
const CLUT clutList[] = {
clut001,
};

however, it lead to an compile error, anyhope that I can use a
variable to store my CLUT attribute then assign it to an array?

thanks a lot

[jackymaillist]

just brainstorming think that I can code like this

const CLUT* clutList[] = {
&clut001, &clut002
};

Any other better approach?

On 7 30 , 3 44 , [e-mail] wrote:

here is my data structure

typedef struct{
char colorType;
unsigned short numEntries;
unsigned int* palette;

}CLUT;

const unsigned int clut001palette[16] = {
0x8000F000, 0x0000E000, 0x0000C800, 0x0000C000,
0x00009800, 0x00009800, 0x00009800, 0x00048004,
0x00006C00, 0x00006400, 0x0008500C, 0x00106810,
0x00108C10, 0x00149814, 0x0018A818, 0x0018A018,
//...

};

const CLUT clut001 = {RGBA555, 256, clut001palette};

const CLUT clutList[] = {
clut001,

};

however, it lead to an compile error, anyhope that I can use a
variable to store my CLUT attribute then assign it to an array?

thanks a lot

[Default User]

ja***********@gmail.com wrote:

here is my data structure

typedef struct{
char colorType;
unsigned short numEntries;
unsigned int* palette;
}CLUT;

const unsigned int clut001palette[16] = {
0x8000F000, 0x0000E000, 0x0000C800, 0x0000C000,
0x00009800, 0x00009800, 0x00009800, 0x00048004,
0x00006C00, 0x00006400, 0x0008500C, 0x00106810,
0x00108C10, 0x00149814, 0x0018A818, 0x0018A018,
//...
};

const CLUT clut001 = {RGBA555, 256, clut001palette};
const CLUT clutList[] = {
clut001,
};

however, it lead to an compile error, anyhope that I can use a
variable to store my CLUT attribute then assign it to an array?

What is the compile error?

Post a complete, minimal program with all the errors.


Brian

[jackymaillist]

It point to my last array
const CLUT clutList[] = {
clut001,

};
and said
"initializer is not a constant"
On 7 30 , 4 29 , "Default User" <[e-mail]:

[e-mail] wrote:

here is my data structure

typedef struct{
char colorType;
unsigned short numEntries;
unsigned int* palette;
}CLUT;

const unsigned int clut001palette[16] = {
0x8000F000, 0x0000E000, 0x0000C800, 0x0000C000,
0x00009800, 0x00009800, 0x00009800, 0x00048004,
0x00006C00, 0x00006400, 0x0008500C, 0x00106810,
0x00108C10, 0x00149814, 0x0018A818, 0x0018A018,
//...
};

const CLUT clut001 = {RGBA555, 256, clut001palette};

const CLUT clutList[] = {
clut001,
};

however, it lead to an compile error, anyhope that I can use a
variable to store my CLUT attribute then assign it to an array?

What is the compile error?

Post a complete, minimal program with all the errors.

Brian

[Ian Collins]

ja***********@gmail.com wrote:

>
const CLUT clut001 = {RGBA555, 256, clut001palette};

const CLUT clutList[] = {
clut001,
};

however, it lead to an compile error, anyhope that I can use a
variable to store my CLUT attribute then assign it to an array?

In C a const CLUT isn't a compile time constant. One of the things I
was surprised C99 didn't fix.

--
Ian Collins.

[Keith Thompson]

Ian Collins <ia******@hotmail.comwrites:

ja***********@gmail.com wrote:

>const CLUT clut001 = {RGBA555, 256, clut001palette};

const CLUT clutList[] = {
clut001,
};

however, it lead to an compile error, anyhope that I can use a
variable to store my CLUT attribute then assign it to an array?

In C a const CLUT isn't a compile time constant. One of the things I
was surprised C99 didn't fix.

The value of a const object sometimes *can't* be a compile-time constant:

const int const_but_not_constant = rand();

But yes, the language could have defined some *const* objects to be
compile-time constants, depending on how they're initialized.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <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."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Ian Collins]

Keith Thompson wrote:

Ian Collins <ia******@hotmail.comwrites:

>ja***********@gmail.com wrote:

>>const CLUT clut001 = {RGBA555, 256, clut001palette};

const CLUT clutList[] = {
clut001,
};

however, it lead to an compile error, anyhope that I can use a
variable to store my CLUT attribute then assign it to an array?

In C a const CLUT isn't a compile time constant. One of the things I
was surprised C99 didn't fix.

The value of a const object sometimes *can't* be a compile-time constant:

const int const_but_not_constant = rand();

But yes, the language could have defined some *const* objects to be
compile-time constants, depending on how they're initialized.

Following the C++ rules would have been a sensible option, they
certainly lead to cleaner code and fewer ugly macros or the kludgey enum
hack.

--
Ian Collins.

[Barry Schwarz]

On Mon, 30 Jul 2007 00:54:29 -0700, ja***********@gmail.com wrote:

>just brainstorming think that I can code like this

Please don't top post.

>const CLUT* clutList[] = {
&clut001, &clut002
};

How long would it have taken to generate a small function to compile
so you could see the errors before posting?

clutList is an array of two pointers to CLUT. Each element of the
array must contain a value of type CLUT*. clut001 is an array of 16
int. &clut001 has type pointer to array of 16 int, that is
int(*)[16]. The two are not related and the attempting to initialize
the former with the latter is a constraint violation requiring a
diagnostic.

>
Any other better approach?

On 7 30 , 3 44 , [e-mail] wrote:

>here is my data structure

typedef struct{
char colorType;
unsigned short numEntries;
unsigned int* palette;

}CLUT;

const unsigned int clut001palette[16] = {
0x8000F000, 0x0000E000, 0x0000C800, 0x0000C000,
0x00009800, 0x00009800, 0x00009800, 0x00048004,
0x00006C00, 0x00006400, 0x0008500C, 0x00106810,
0x00108C10, 0x00149814, 0x0018A818, 0x0018A018,
//...

Remove del for email

[Martin Ambuhl]

ja***********@gmail.com wrote:

here is my data structure

[replacement with comments below]

however, it lead to an compile error, anyhope that I can use a
variable to store my CLUT attribute then assign it to an array?

#define RGBA555 127 /* mha: some definition is needed for
compilation. Make sure that
whatever this value is that it is in
the range of a signed char, else
change colorType in your struct to
be unsigned char, or else be sure
that RGBA555 >= 0 or that colorType
is an unsigned char. */
typedef struct
{
char colorType;
unsigned short numEntries;
const unsigned int *palette; /* mha: added 'const' to avoid
discarding constness. */
} CLUT;

const unsigned int clut001palette[16] = {
0x8000F000, 0x0000E000, 0x0000C800, 0x0000C000,
0x00009800, 0x00009800, 0x00009800, 0x00048004,
0x00006C00, 0x00006400, 0x0008500C, 0x00106810,
0x00108C10, 0x00149814, 0x0018A818, 0x0018A018,
};

const CLUT clut001 = { RGBA555, 256, clut001palette };


int main(void)
{
const CLUT clutList[] = { clut001, }; /* mha: This cannot have
file scope, since the
initializer is not
constant. If you think
it is, check the FAQ. */

return 0;
}

[Ian Collins]

Barry Schwarz wrote:

On Mon, 30 Jul 2007 00:54:29 -0700, ja***********@gmail.com wrote:

>just brainstorming think that I can code like this

Please don't top post.

>const CLUT* clutList[] = {
&clut001, &clut002
};

How long would it have taken to generate a small function to compile
so you could see the errors before posting?

clutList is an array of two pointers to CLUT. Each element of the
array must contain a value of type CLUT*. clut001 is an array of 16
int.

No, it isn't. Read the OP again:

const CLUT clut001 = {RGBA555, 256, clut001palette};

--
Ian Collins.

[Barry Schwarz]

On Tue, 31 Jul 2007 12:43:26 +1200, Ian Collins <ia******@hotmail.com>
wrote:

>Barry Schwarz wrote:

>On Mon, 30 Jul 2007 00:54:29 -0700, ja***********@gmail.com wrote:

>>just brainstorming think that I can code like this

Please don't top post.

>>const CLUT* clutList[] = {
&clut001, &clut002
};

How long would it have taken to generate a small function to compile
so you could see the errors before posting?

clutList is an array of two pointers to CLUT. Each element of the
array must contain a value of type CLUT*. clut001 is an array of 16
int.

No, it isn't. Read the OP again:

const CLUT clut001 = {RGBA555, 256, clut001palette};

By george, you're right. I wonder where the palette went.
Remove del for email

[David Thompson]

On Tue, 31 Jul 2007 10:32:01 +1200, Ian Collins <ia******@hotmail.com>
wrote:

Keith Thompson wrote:

Ian Collins <ia******@hotmail.comwrites:

<snip example>

In C a const CLUT isn't a compile time constant. One of the things I
was surprised C99 didn't fix.

The value of a const object sometimes *can't* be a compile-time constant:

const int const_but_not_constant = rand();

But yes, the language could have defined some *const* objects to be
compile-time constants, depending on how they're initialized.

Following the C++ rules would have been a sensible option, they
certainly lead to cleaner code and fewer ugly macros or the kludgey enum
hack.

Although it wouldn't have helped in this example, since the C++ rules
only apply to scalar integer and enumeration types (which are distinct
in C++ but in C enumeration types _are_ integer types).

- formerly david.thompson1 || achar(64) || worldnet.att.net

[Ian Collins]

David Thompson wrote:

On Tue, 31 Jul 2007 10:32:01 +1200, Ian Collins <ia******@hotmail.com>
wrote:

>Keith Thompson wrote:

>>Ian Collins <ia******@hotmail.comwrites:

<snip example>

>>>In C a const CLUT isn't a compile time constant. One of the things I
was surprised C99 didn't fix.
The value of a const object sometimes *can't* be a compile-time constant:

const int const_but_not_constant = rand();

But yes, the language could have defined some *const* objects to be
compile-time constants, depending on how they're initialized.

Following the C++ rules would have been a sensible option, they
certainly lead to cleaner code and fewer ugly macros or the kludgey enum
hack.

Although it wouldn't have helped in this example, since the C++ rules
only apply to scalar integer and enumeration types (which are distinct
in C++ but in C enumeration types _are_ integer types).

But it would have helped the OP.

--
Ian Collins.