What scope are struct members in?

Discussion in 'C Programming' started by Johannes Schaub (litb), Mar 11, 2011.

  1. The C spec says

    "
    An identifier can denote an object; a function; a tag or a member of a
    structure, union, or enumeration; a typedef name; a label name; a macro
    name; or a macro parameter.

    The same identifier can denote different entities at different points in the
    program.

    For each different entity that an identifier designates, the identifier is
    visible (i.e., can be used) only within a region of program text called its
    scope.
    "

    and

    "
    If more than one declaration of a particular identifier is visible at any
    point in a translation unit, the syntactic context disambiguates uses that
    refer to different entities. Thus, there are separate name spaces for
    various categories of identifiers, as follows: [...]
    - the members of structures or unions; each structure or union has a
    separate name space for its members (disambiguated by the type of the
    expression used to access the member via the . or -> operator);
    "

    Does all that mean that struct members have a scope? Does the following
    program declare "x" to have file scope?

    struct A {
    int x;
    };

    int main(void) {
    }

    Some people told me that struct members don't have any scope. But if they
    don't have the scope, they are not visible, and if they are not visible,
    they cannot be used. But obviously, we can use them. How do struct members
    interact with scope?
    Johannes Schaub (litb), Mar 11, 2011
    #1
    1. Advertising

  2. Johannes Schaub (litb)

    Stefan Ram Guest

    "Johannes Schaub (litb)" <> writes:
    >Does all that mean that struct members have a scope? Does the following
    >program declare "x" to have file scope?
    >struct A {
    > int x;


    Structure, union, and enumeration tags have scope that
    begins just after the appearance of the tag in a type
    specifier that declares the tag.
    Stefan Ram, Mar 11, 2011
    #2
    1. Advertising

  3. Stefan Ram wrote:

    > "Johannes Schaub (litb)" <> writes:
    >>Does all that mean that struct members have a scope? Does the following
    >>program declare "x" to have file scope?
    >>struct A {
    >> int x;

    >
    > Structure, union, and enumeration tags have scope that
    > begins just after the appearance of the tag in a type
    > specifier that declares the tag.


    Huh?
    Johannes Schaub (litb), Mar 11, 2011
    #3
  4. On Fri, 11 Mar 2011 23:13:05 +0100, "Johannes Schaub (litb)"
    <> wrote:

    >The C spec says
    >
    >"
    >An identifier can denote an object; a function; a tag or a member of a
    >structure, union, or enumeration; a typedef name; a label name; a macro
    >name; or a macro parameter.
    >
    >The same identifier can denote different entities at different points in the
    >program.
    >
    >For each different entity that an identifier designates, the identifier is
    >visible (i.e., can be used) only within a region of program text called its
    >scope.


    Why did you stop quoting here. In two more paragraphs, the answer to
    your question is explicitly stated.

    >"
    >
    >and
    >
    >"
    >If more than one declaration of a particular identifier is visible at any
    >point in a translation unit, the syntactic context disambiguates uses that
    >refer to different entities. Thus, there are separate name spaces for
    >various categories of identifiers, as follows: [...]
    >- the members of structures or unions; each structure or union has a
    >separate name space for its members (disambiguated by the type of the
    >expression used to access the member via the . or -> operator);
    >"


    Why did you bother quoting this. Name space is a different concept
    from scope. These paragraphs have nothing to do with your question.

    >
    >Does all that mean that struct members have a scope? Does the following
    >program declare "x" to have file scope?
    >
    >struct A {
    > int x;
    >};
    >
    >int main(void) {
    >}



    An identifier can denote a member of a structure (6.2.1-1)

    Every other identifier [not a label name described in the previous
    paragraph] has scope (6.2.1-4).

    Therefore x has scope regardless of what people tell you.

    Since the declaration for x appears outside of any block or list of
    parameters, it has file scope (also 6.2.1-4)

    Where do find any room to dispute this?

    >
    >Some people told me that struct members don't have any scope. But if they
    >don't have the scope, they are not visible, and if they are not visible,


    It is possible that this is the first time someone has told you
    something incorrect but you can bet the rent it won't be the last.

    >they cannot be used. But obviously, we can use them. How do struct members
    >interact with scope?


    Exactly as the standard says they do.

    --
    Remove del for email
    Barry Schwarz, Mar 12, 2011
    #4
  5. "Johannes Schaub (litb)" <> writes:
    > Stefan Ram wrote:
    >> "Johannes Schaub (litb)" <> writes:
    >>>Does all that mean that struct members have a scope? Does the following
    >>>program declare "x" to have file scope?
    >>>struct A {
    >>> int x;

    >>
    >> Structure, union, and enumeration tags have scope that
    >> begins just after the appearance of the tag in a type
    >> specifier that declares the tag.

    >
    > Huh?


    That's a direct quotation from the standard, 6.2.1p7.

    For example:

    {
    struct this_is_the_tag {
    int x;
    };
    struct this_is_the_tag obj;
    }

    The token sequence "struct this_is_the_tag { int x; }" is a type
    specifier; it declares the tag "this_is_the_tag". The scope of
    "this_is_the_tag" begins just after the appearance of its name,
    and ends at the last "}", i.e., at the end of the block.

    This means that, for example, you can use use the name
    "this_is_the_tag" inside the struct declaration:

    {
    struct this_is_the_tag {
    int x;
    struct this_is_the_tag *next;
    };
    struct this_is_the_tag obj;
    }

    It's no longer visible (it's out of scope) after the final closing "}".

    --
    Keith Thompson (The_Other_Keith) <http://www.ghoti.net/~kst>
    Nokia
    "We must do something. This is something. Therefore, we must do this."
    -- Antony Jay and Jonathan Lynn, "Yes Minister"
    Keith Thompson, Mar 12, 2011
    #5
  6. Johannes Schaub (litb)

    Stefan Ram Guest

    Keith Thompson <> writes:
    >>Stefan Ram wrote:
    >>>Structure, union, and enumeration tags have scope that

    >That's a direct quotation from the standard, 6.2.1p7.


    I was not careful enough: Actually, I wanted to write
    about members, not about tags.

    The scope of members is not given explicitly, it seems.

    From

    »the identifier is visible (i.e., can be used) only
    within a region of program text called its scope.«,

    however, we can deduce, that the scope of a member might be:

    - the rest of the body of the definition it is
    declared in (except when hidden) and

    - the regions after certain operators (like ».« or
    »->«), when preceded by an expression of
    appropriate type.

    (Ignoring the preprocessor, e.g., offsetof.)

    In older C dialects, members really had file scope, IIRC!
    Stefan Ram, Mar 12, 2011
    #6
  7. Johannes Schaub (litb)

    Stefan Ram Guest

    -berlin.de (Stefan Ram) writes:
    >»the identifier is visible (i.e., can be used) only
    >within a region of program text called its scope.«,


    For example,

    struct a { int b; }; int main( void ){ b; }

    test.c:1: error: 'b' undeclared (first use in this function)

    , doesn't sound as if »b« would be visible in main.

    But, of course, gcc is just a compiler.

    But ISO/IEC 9899:1999 (E) even explains »visible«:
    »can be used« (see quotation above).

    »b« cannot be used in main above.

    We could add »a.« in front of »b« - but then it would
    be another program, so assertions about the scope in
    this other program would not be valid for the program
    above.
    Stefan Ram, Mar 12, 2011
    #7
  8. Keith Thompson wrote:
    > "Johannes Schaub (litb)" <> writes:
    >> Stefan Ram wrote:
    >>> "Johannes Schaub (litb)" <> writes:
    >>>> Does all that mean that struct members have a scope? Does the following
    >>>> program declare "x" to have file scope?
    >>>> struct A {
    >>>> int x;
    >>> Structure, union, and enumeration tags have scope that
    >>> begins just after the appearance of the tag in a type
    >>> specifier that declares the tag.

    >> Huh?

    >
    > That's a direct quotation from the standard, 6.2.1p7.


    Indeed, but what does it have to do with the question?
    J. J. Farrell, Mar 12, 2011
    #8
  9. -berlin.de (Stefan Ram) writes:
    > Keith Thompson <> writes:
    >>>Stefan Ram wrote:
    >>>>Structure, union, and enumeration tags have scope that

    >>That's a direct quotation from the standard, 6.2.1p7.

    >
    > I was not careful enough: Actually, I wanted to write
    > about members, not about tags.
    >
    > The scope of members is not given explicitly, it seems.


    It doesn't need to be. Note the last sentence:

    Structure, union, and enumeration tags have scope that begins
    just after the appearance of the tag in a type speciï¬er that
    declares the tag. Each enumeration constant has scope that
    begins just after the appearance of its defining enumerator
    in an enumerator list. Any other identifier has scope that
    begins just after the completion of its declarator.

    I'm not sure whether the declarator in question is the declaration
    of the member or of the struct or union. It might not matter;
    I can't think of a legal way to use the name of a struct member
    prior to the end of the struct declaration that contains it.

    --
    Keith Thompson (The_Other_Keith) <http://www.ghoti.net/~kst>
    Nokia
    "We must do something. This is something. Therefore, we must do this."
    -- Antony Jay and Jonathan Lynn, "Yes Minister"
    Keith Thompson, Mar 12, 2011
    #9
  10. Johannes Schaub (litb)

    James Kuyper Guest

    On 03/11/2011 05:13 PM, Johannes Schaub (litb) wrote:
    > The C spec says
    >
    > "
    > An identifier can denote an object; a function; a tag or a member of a
    > structure, union, or enumeration; a typedef name; a label name; a macro
    > name; or a macro parameter.
    >
    > The same identifier can denote different entities at different points in the
    > program.
    >
    > For each different entity that an identifier designates, the identifier is
    > visible (i.e., can be used) only within a region of program text called its
    > scope.
    > "

    ....
    > Does all that mean that struct members have a scope? Does the following
    > program declare "x" to have file scope?


    Yes, and yes.

    > struct A {
    > int x;
    > };
    >
    > int main(void) {
    > }
    >
    > Some people told me that struct members don't have any scope. But if they
    > don't have the scope, they are not visible, and if they are not visible,
    > they cannot be used. But obviously, we can use them. How do struct members
    > interact with scope?


    6.2.1p1: "An identifier can denote ... a member of a structure, union,
    or enumeration ..."

    p2 describes the scope of identifiers which are statement labels.

    p3: "Every other identifier has scope determined by the placement of its
    declaration (in a declarator or type specifier). If the declarator or
    type specifier that declares the identifier appears outside of any block
    or list of parameters, the identifier has file scope, which
    terminates at the end of the translation unit. If the declarator or type
    specifier that declares the identifier appears inside a block or within
    the list of parameter declarations in a function definition, the
    identifier has block scope, which terminates at the end of the
    associated block. If the declarator or type specifier that declares the
    identifier appears within the list of parameter declarations in a
    function prototype (not part of a function definition), the identifier
    has function prototype scope, which terminates at the end of the
    function declarator."

    p7: after discussing tags and enumeration constants, it says "Any
    other identifier has scope that begins just after the completion of its
    declarator."

    Example:

    struct one{
    int file_scope_member/* scope starts here */, another;
    };

    void func(
    struct two {
    int prototype_scope_member/* scope starts here */,
    yet_another;
    },
    int
    /* scope of prototype_scope_member ends here */);

    int main(void)
    {
    struct three{
    int block_scope_member/* scope starts here */, the_last_one;
    }

    return 0;

    /* Scope of block_scope_member ends here */}

    /* Scope of file_scope_member ends here */


    --
    James Kuyper
    James Kuyper, Mar 12, 2011
    #10
  11. Johannes Schaub (litb)

    Eric Sosman Guest

    On 3/11/2011 9:45 PM, Stefan Ram wrote:
    > -berlin.de (Stefan Ram) writes:
    >> »the identifier is visible (i.e., can be used) only
    >> within a region of program text called its scope.«,

    >
    > For example,
    >
    > struct a { int b; }; int main( void ){ b; }
    >
    > test.c:1: error: 'b' undeclared (first use in this function)
    >
    > , doesn't sound as if »b« would be visible in main.
    >
    > But, of course, gcc is just a compiler.
    >
    > But ISO/IEC 9899:1999 (E) even explains »visible«:
    > »can be used« (see quotation above).
    >
    > »b« cannot be used in main above.
    >
    > We could add »a.« in front of »b« - but then it would
    > be another program, so assertions about the scope in
    > this other program would not be valid for the program
    > above.


    You're using "scope" for two notions that the Standard calls
    "scope" and "name space." The identifier `b' is in scope everywhere
    after its declaration -- including inside main() -- but has meaning
    only in the name space of `struct a'. See 6.2.3.

    --
    Eric Sosman
    d
    Eric Sosman, Mar 12, 2011
    #11
  12. "J. J. Farrell" <> writes:
    > Keith Thompson wrote:
    >> "Johannes Schaub (litb)" <> writes:
    >>> Stefan Ram wrote:
    >>>> "Johannes Schaub (litb)" <> writes:
    >>>>> Does all that mean that struct members have a scope? Does the following
    >>>>> program declare "x" to have file scope?
    >>>>> struct A {
    >>>>> int x;
    >>>> Structure, union, and enumeration tags have scope that
    >>>> begins just after the appearance of the tag in a type
    >>>> specifier that declares the tag.
    >>> Huh?

    >>
    >> That's a direct quotation from the standard, 6.2.1p7.

    >
    > Indeed, but what does it have to do with the question?


    Not much; I didn't look closely enough at the context.

    --
    Keith Thompson (The_Other_Keith) <http://www.ghoti.net/~kst>
    Nokia
    "We must do something. This is something. Therefore, we must do this."
    -- Antony Jay and Jonathan Lynn, "Yes Minister"
    Keith Thompson, Mar 12, 2011
    #12
  13. Eric Sosman wrote:

    > On 3/11/2011 9:45 PM, Stefan Ram wrote:
    >> -berlin.de (Stefan Ram) writes:
    >>> »the identifier is visible (i.e., can be used) only
    >>> within a region of program text called its scope.«,

    >>
    >> For example,
    >>
    >> struct a { int b; }; int main( void ){ b; }
    >>
    >> test.c:1: error: 'b' undeclared (first use in this function)
    >>
    >> , doesn't sound as if »b« would be visible in main.
    >>
    >> But, of course, gcc is just a compiler.
    >>
    >> But ISO/IEC 9899:1999 (E) even explains »visible«:
    >> »can be used« (see quotation above).
    >>
    >> »b« cannot be used in main above.
    >>
    >> We could add »a.« in front of »b« - but then it would
    >> be another program, so assertions about the scope in
    >> this other program would not be valid for the program
    >> above.

    >
    > You're using "scope" for two notions that the Standard calls
    > "scope" and "name space." The identifier `b' is in scope everywhere
    > after its declaration -- including inside main() -- but has meaning
    > only in the name space of `struct a'. See 6.2.3.
    >


    The Standard introduces the concept of "namespaces" as merely a syntactic
    construct to disambiguate uses, and not as a semantic entity that somehow
    "contains" identifiers.

    What does "in the namespace" mean?
    Johannes Schaub (litb), Mar 12, 2011
    #13
  14. Johannes Schaub (litb) wrote:

    > Eric Sosman wrote:
    >
    >> On 3/11/2011 9:45 PM, Stefan Ram wrote:
    >>> -berlin.de (Stefan Ram) writes:
    >>>> »the identifier is visible (i.e., can be used) only
    >>>> within a region of program text called its scope.«,
    >>>
    >>> For example,
    >>>
    >>> struct a { int b; }; int main( void ){ b; }
    >>>
    >>> test.c:1: error: 'b' undeclared (first use in this function)
    >>>
    >>> , doesn't sound as if »b« would be visible in main.
    >>>
    >>> But, of course, gcc is just a compiler.
    >>>
    >>> But ISO/IEC 9899:1999 (E) even explains »visible«:
    >>> »can be used« (see quotation above).
    >>>
    >>> »b« cannot be used in main above.
    >>>
    >>> We could add »a.« in front of »b« - but then it would
    >>> be another program, so assertions about the scope in
    >>> this other program would not be valid for the program
    >>> above.

    >>
    >> You're using "scope" for two notions that the Standard calls
    >> "scope" and "name space." The identifier `b' is in scope everywhere
    >> after its declaration -- including inside main() -- but has meaning
    >> only in the name space of `struct a'. See 6.2.3.
    >>

    >
    > The Standard introduces the concept of "namespaces" as merely a syntactic
    > construct to disambiguate uses, and not as a semantic entity that somehow
    > "contains" identifiers.
    >
    > What does "in the namespace" mean?


    Ah I think I get this now. The name spaces divide a scope into multiple
    sections.
    Johannes Schaub (litb), Mar 12, 2011
    #14
  15. Stefan Ram wrote:

    > -berlin.de (Stefan Ram) writes:
    >>»the identifier is visible (i.e., can be used) only
    >>within a region of program text called its scope.«,

    >
    > For example,
    >
    > struct a { int b; }; int main( void ){ b; }
    >
    > test.c:1: error: 'b' undeclared (first use in this function)
    >
    > , doesn't sound as if »b« would be visible in main.
    >
    > But, of course, gcc is just a compiler.
    >
    > But ISO/IEC 9899:1999 (E) even explains »visible«:
    > »can be used« (see quotation above).
    >
    > »b« cannot be used in main above.
    >
    > We could add »a.« in front of »b« - but then it would
    > be another program, so assertions about the scope in
    > this other program would not be valid for the program
    > above.


    No, "b" can be used in "main". But if you just do "b;", it will look into
    the ordinary namespace for identifiers. You have to use an "a." or "a->" to
    make it look into the struct-A members namespace of the global scope to use
    "b" in main.

    Just like you have to use "struct a" to use the identifier "a" in main,
    which is in the tags namespace of the global scope.
    Johannes Schaub (litb), Mar 12, 2011
    #15
  16. Scott Fluhrer wrote:

    >
    > "Keith Thompson" <> wrote in message
    > news:...
    >> -berlin.de (Stefan Ram) writes:
    >>> Keith Thompson <> writes:
    >>>>>Stefan Ram wrote:
    >>>>>>Structure, union, and enumeration tags have scope that
    >>>>That's a direct quotation from the standard, 6.2.1p7.
    >>>
    >>> I was not careful enough: Actually, I wanted to write
    >>> about members, not about tags.
    >>>
    >>> The scope of members is not given explicitly, it seems.

    >>
    >> It doesn't need to be. Note the last sentence:
    >>
    >> Structure, union, and enumeration tags have scope that begins
    >> just after the appearance of the tag in a type speci?er that
    >> declares the tag. Each enumeration constant has scope that
    >> begins just after the appearance of its defining enumerator
    >> in an enumerator list. Any other identifier has scope that
    >> begins just after the completion of its declarator.
    >>
    >> I'm not sure whether the declarator in question is the declaration
    >> of the member or of the struct or union. It might not matter;
    >> I can't think of a legal way to use the name of a struct member
    >> prior to the end of the struct declaration that contains it.

    >
    > Sounds like a challenge. How about:
    >
    >
    > struct foo *x;
    >
    > struct foo {
    > int a;
    > char b[ sizeof x->a ];
    > };
    >
    >
    > gcc didn't like it; I haven't gone through the standard yet to see if
    > there's any language to explicitly allow or disallow this.
    >


    Interesting. This seems to be allowed/not forbidden.
    Johannes Schaub (litb), Mar 12, 2011
    #16
  17. Johannes Schaub (litb)

    Tim Rentsch Guest

    "Johannes Schaub (litb)" <> writes:

    > Scott Fluhrer wrote:
    >
    >>
    >> "Keith Thompson" <> wrote in message
    >> news:...
    >>> -berlin.de (Stefan Ram) writes:
    >>>> Keith Thompson <> writes:
    >>>>>>Stefan Ram wrote:
    >>>>>>>Structure, union, and enumeration tags have scope that
    >>>>>That's a direct quotation from the standard, 6.2.1p7.
    >>>>
    >>>> I was not careful enough: Actually, I wanted to write
    >>>> about members, not about tags.
    >>>>
    >>>> The scope of members is not given explicitly, it seems.
    >>>
    >>> It doesn't need to be. Note the last sentence:
    >>>
    >>> Structure, union, and enumeration tags have scope that begins
    >>> just after the appearance of the tag in a type speci?er that
    >>> declares the tag. Each enumeration constant has scope that
    >>> begins just after the appearance of its defining enumerator
    >>> in an enumerator list. Any other identifier has scope that
    >>> begins just after the completion of its declarator.
    >>>
    >>> I'm not sure whether the declarator in question is the declaration
    >>> of the member or of the struct or union. It might not matter;
    >>> I can't think of a legal way to use the name of a struct member
    >>> prior to the end of the struct declaration that contains it.

    >>
    >> Sounds like a challenge. How about:
    >>
    >>
    >> struct foo *x;
    >>
    >> struct foo {
    >> int a;
    >> char b[ sizeof x->a ];
    >> };
    >>
    >>
    >> gcc didn't like it; I haven't gone through the standard yet to see if
    >> there's any language to explicitly allow or disallow this.
    >>

    >
    > Interesting. This seems to be allowed/not forbidden.


    Assuming there isn't any text that forbids it, surely
    that's just an oversight in the Standard. The operators
    '.' and '->' are expected to require complete types, no?
    Tim Rentsch, Mar 12, 2011
    #17
  18. On Mar 12, 7:15 pm, Tim Rentsch <> wrote:
    > "Johannes Schaub (litb)" <> writes:
    > > Scott Fluhrer wrote:
    > >> Sounds like a challenge.  How about:

    >
    > >> struct foo *x;

    >
    > >> struct foo {
    > >>     int a;
    > >>     char b[ sizeof x->a ];
    > >> };

    >
    > >> gcc didn't like it; I haven't gone through the standard yet to see if
    > >> there's any language to explicitly allow or disallow this.

    >
    > > Interesting. This seems to be allowed/not forbidden.

    >
    > Assuming there isn't any text that forbids it, surely
    > that's just an oversight in the Standard.  The operators
    > '.' and '->' are expected to require complete types, no?


    There is no reason why they should require a complete type, even
    though many compilers reject the above code. Referring to a previously
    declared member of a not yet completed structure type is possible in
    theory, and at least one compiler permits it: OpenWatcom gives no
    error, warning, or any other diagnostic for it.
    Harald van Dijk, Mar 12, 2011
    #18
  19. Harald van Dijk wrote:

    > On Mar 12, 7:15 pm, Tim Rentsch <> wrote:
    >> "Johannes Schaub (litb)" <> writes:
    >> > Scott Fluhrer wrote:
    >> >> Sounds like a challenge. How about:

    >>
    >> >> struct foo *x;

    >>
    >> >> struct foo {
    >> >> int a;
    >> >> char b[ sizeof x->a ];
    >> >> };

    >>
    >> >> gcc didn't like it; I haven't gone through the standard yet to see if
    >> >> there's any language to explicitly allow or disallow this.

    >>
    >> > Interesting. This seems to be allowed/not forbidden.

    >>
    >> Assuming there isn't any text that forbids it, surely
    >> that's just an oversight in the Standard. The operators
    >> '.' and '->' are expected to require complete types, no?

    >
    > There is no reason why they should require a complete type, even
    > though many compilers reject the above code. Referring to a previously
    > declared member of a not yet completed structure type is possible in
    > theory, and at least one compiler permits it: OpenWatcom gives no
    > error, warning, or any other diagnostic for it.


    I filed a report on clang: http://llvm.org/bugs/show_bug.cgi?id=9471
    Johannes Schaub (litb), Mar 12, 2011
    #19
  20. Johannes Schaub (litb)

    Tim Rentsch Guest

    Harald van Dij <> writes:

    > On Mar 12, 7:15 pm, Tim Rentsch <> wrote:
    >> "Johannes Schaub (litb)" <> writes:
    >> > Scott Fluhrer wrote:
    >> >> Sounds like a challenge. How about:

    >>
    >> >> struct foo *x;

    >>
    >> >> struct foo {
    >> >> int a;
    >> >> char b[ sizeof x->a ];
    >> >> };

    >>
    >> >> gcc didn't like it; I haven't gone through the standard yet to see if
    >> >> there's any language to explicitly allow or disallow this.

    >>
    >> > Interesting. This seems to be allowed/not forbidden.

    >>
    >> Assuming there isn't any text that forbids it, surely
    >> that's just an oversight in the Standard. The operators
    >> '.' and '->' are expected to require complete types, no?

    >
    > There is no reason why they should require a complete type, even
    > though many compilers reject the above code.


    I meant 'require' in the sense of 'only guaranteed to be defined
    for'.

    > Referring to a previously
    > declared member of a not yet completed structure type is possible in
    > theory, and at least one compiler permits it: OpenWatcom gives no
    > error, warning, or any other diagnostic for it.


    And this behavior is reasonable, or at least permissible, if such
    cases were specified as undefined behavior, which is how I expect
    the Standard would specify it. So too is giving an error message
    and refusing to proceed.
    Tim Rentsch, Mar 13, 2011
    #20
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. JFCM
    Replies:
    4
    Views:
    5,720
  2. CoolPint
    Replies:
    8
    Views:
    955
    Jeff Schwab
    Dec 14, 2003
  3. Dave
    Replies:
    3
    Views:
    358
    tom_usenet
    Aug 10, 2004
  4. Chris Fogelklou
    Replies:
    36
    Views:
    1,348
    Chris Fogelklou
    Apr 20, 2004
  5. John Reye
    Replies:
    28
    Views:
    1,333
    Tim Rentsch
    May 8, 2012
Loading...

Share This Page