C++Talk.NET Forum Index C++Talk.NET
C++ language newsgroups
 
Archives   FAQFAQ   SearchSearch   MemberlistMemberlist   UsergroupsUsergroups   RegisterRegister 
 ProfileProfile   Log in to check your private messagesLog in to check your private messages   Log inLog in 

when inline function is not inlined
Goto page 1, 2, 3  Next
 
Post new topic   Reply to topic    C++Talk.NET Forum Index -> C++ Language (Moderated)
View previous topic :: View next topic  
Author Message
Tony
Guest





PostPosted: Fri Jan 02, 2004 6:55 pm    Post subject: when inline function is not inlined Reply with quote



Dear C++ Gurus,

As put in many books, inline is only a suggestion to the compiler.
The inline function may not be inlined. When an inline function is not
inlined,
it will be offlined just as a offline function. But I wonder maybe
there is still a difference.


//f1.h
inline void f1() { }
void f2();
void f3();

//f2.cpp
#include "f1.h"
void f2() { f1(); }

//f3.cpp
#include "f1.h"
void f3() { f1(); }

//main.cpp
#include "f1.h"
int main()
{
f2();
f3();
}

If f1() is complex, the inline may be ignored.
But no matter how complex f1() is, the above code can always run.

But if I remove "inline" from f1(), it will have duplicate defintions
in f2.cpp and f3.cpp. The linker will fail.

So if "inline" is used, even if it is not inlined, it is still
different from
not having "inline". What's the exact difference ? Where does the
compile put f1() defintion when "inline" is used ?

Best regards
Tony

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]
Back to top
galathaea
Guest





PostPosted: Sat Jan 03, 2004 4:08 am    Post subject: Re: when inline function is not inlined Reply with quote



"Tony" wrote:
: As put in many books, inline is only a suggestion to the compiler.
: The inline function may not be inlined. When an inline function is not
: inlined,
: it will be offlined just as a offline function. But I wonder maybe
: there is still a difference.
:
:
: //f1.h
: inline void f1() { }
: void f2();
: void f3();
:
: //f2.cpp
: #include "f1.h"
: void f2() { f1(); }
:
: //f3.cpp
: #include "f1.h"
: void f3() { f1(); }
:
: //main.cpp
: #include "f1.h"
: int main()
: {
: f2();
: f3();
: }
:
: If f1() is complex, the inline may be ignored.
: But no matter how complex f1() is, the above code can always run.
:
: But if I remove "inline" from f1(), it will have duplicate defintions
: in f2.cpp and f3.cpp. The linker will fail.
:
: So if "inline" is used, even if it is not inlined, it is still
: different from
: not having "inline". What's the exact difference ? Where does the
: compile put f1() defintion when "inline" is used ?

Its not exactly _where_ it puts the function, but what additional
information is attached to the function that the linker sees. In
particular, it is the linkage specification attached to the function in each
translation unit. You are correct, inline does more than just suggest the
in place expansion / substitution of the code. The use of the keyword
inline is useful anytime one might have violations of the one definition
rule due to code in the header, and this is particularly true for
parametrised functions and algorithmics.

--
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

galathaea: prankster, fablist, magician, liar


[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]
Back to top
Michael Tiomkin
Guest





PostPosted: Sat Jan 03, 2004 4:08 am    Post subject: Re: when inline function is not inlined Reply with quote



It seems that you use a Windows linker that doesn't allow multiple
definitions in object files. Many inline functions usually appear in .h
files and therefore can appear in many object files. As a result,
a WIndows compiler has to use a "weak definition" for inlined functions
in order to allow overriding of multiple appearances of the same item.
Unix linkers usually allow multiple definitions, and then there is
no need in special definition for inlined functions that aren't inlined.
In this case, when you want to enforce the "single definition" rule,
you need to use a special compiler option to treat inline functions
as weak defs and a special linker option against multiple appearances
in the objects.

[email]tongru_huo (AT) yahoo (DOT) com[/email] (Tony) wrote in message news:<1f87458d.0401020847.71074931 (AT) posting (DOT) google.com>...
Quote:
As put in many books, inline is only a suggestion to the compiler.
The inline function may not be inlined. When an inline function is not
inlined,
it will be offlined just as a offline function. But I wonder maybe
there is still a difference.

//f1.h
inline void f1() { }
void f2();
void f3();

//f2.cpp
#include "f1.h"
void f2() { f1(); }

//f3.cpp
#include "f1.h"
void f3() { f1(); }

//main.cpp
#include "f1.h"
int main()
{
f2();
f3();
}

If f1() is complex, the inline may be ignored.
But no matter how complex f1() is, the above code can always run.

But if I remove "inline" from f1(), it will have duplicate defintions
in f2.cpp and f3.cpp. The linker will fail.

So if "inline" is used, even if it is not inlined, it is still
different from
not having "inline". What's the exact difference ? Where does the
compile put f1() defintion when "inline" is used ?

Best regards
Tony

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Back to top
Stefan Rupp
Guest





PostPosted: Sat Jan 03, 2004 4:09 am    Post subject: Re: when inline function is not inlined Reply with quote

Good evening,

Tony schrieb:
Quote:
//f1.h
inline void f1() { }
void f2();
void f3();

Put include guards around all declarations in your headers:

#if !defined(F1_H_)
#define F1_H_
// your C++ header goes here
#endif

Quote:
//f2.cpp
#include "f1.h"
void f2() { f1(); }

//f3.cpp
#include "f1.h"
void f3() { f1(); }

//main.cpp
#include "f1.h"
int main()
{
f2();
f3();
}
[...]
But if I remove "inline" from f1(), it will have duplicate defintions
in f2.cpp and f3.cpp. The linker will fail.

Include guards do not solve *this* problem. If you simply omit the
"include" keyword, the header contains a defnition of function f1 (i.e.
its implementation), rather than just its declaration (i.e. its
prototype). You will need to move the definition of function f1 to a
separate translation unit.

The "include" keyword tells the compiler more than just "this may be
used inlined". If the compiler decides not to inline the code, it must
not create code for each and every occurance of the function, otherwise
you would see the effect you reported.

However, what exactly the various compiler do in this case, is beyond my
knowledge. Some create weak symbols.

Quote:
Where does the
compile put f1() defintion when "inline" is used ?

The question is related to the question for the address for an inlined
function (here &f1).

Stefan


[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Back to top
Rajaram S. Gaunker
Guest





PostPosted: Sat Jan 03, 2004 9:50 am    Post subject: Re: when inline function is not inlined Reply with quote

Quote:

As put in many books, inline is only a suggestion to the compiler.
The inline function may not be inlined.

U r rite.

Quote:


//f1.h
inline void f1() { }
void f2();
void f3();

//f2.cpp
#include "f1.h"
void f2() { f1(); }

//f3.cpp
#include "f1.h"
void f3() { f1(); }

//main.cpp
#include "f1.h"
int main()
{
f2();
f3();
}

If f1() is complex, the inline may be ignored.
But no matter how complex f1() is, the above code can always run.

yes

Quote:

But if I remove "inline" from f1(), it will have duplicate defintions
in f2.cpp and f3.cpp. The linker will fail.

linker wont fail as inline has two meanings
1) Request to inline the function.
2) function has internal linkage.

if function is not inlined then it has internal linkage means it is
linked only within the translation unit, hence there will be no clash
at link time in abave case with inlining failed.

correct if wrong
Regards
Rajaram

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Back to top
Francis Glassborow
Guest





PostPosted: Sat Jan 03, 2004 3:02 pm    Post subject: Re: when inline function is not inlined Reply with quote

In message <fVnJb.4779$HT.948 (AT) newssvr27 (DOT) news.prodigy.com>, galathaea
<galathaea (AT) excite (DOT) com> writes
Quote:
Its not exactly _where_ it puts the function, but what additional
information is attached to the function that the linker sees. In
particular, it is the linkage specification attached to the function in each
translation unit. You are correct, inline does more than just suggest the
in place expansion / substitution of the code. The use of the keyword
inline is useful anytime one might have violations of the one definition
rule due to code in the header, and this is particularly true for
parametrised functions and algorithmics.

But you better be careful that you do not break the one definition rule.
I.e. you need to ensure that all the definitions the linker sees are the
same else you may get surprises when it discards some of them.


--
Francis Glassborow ACCU
Author of 'You Can Do It!' see http://www.spellen.org/youcandoit
or http://www.robinton.demon.co.uk
Happy Xmas, Hanukkah, Yuletide, Winter/Summer Solstice to all.


[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Back to top
Francis Glassborow
Guest





PostPosted: Sat Jan 03, 2004 3:03 pm    Post subject: Re: when inline function is not inlined Reply with quote

In message <ef72c6cb.0401021459.4438a837 (AT) posting (DOT) google.com>, Michael
Tiomkin <tmk (AT) netvision (DOT) net.il> writes
Quote:
It seems that you use a Windows linker that doesn't allow multiple
definitions in object files. Many inline functions usually appear in .h
files and therefore can appear in many object files. As a result,
a WIndows compiler has to use a "weak definition" for inlined functions
in order to allow overriding of multiple appearances of the same item.
Unix linkers usually allow multiple definitions, and then there is
no need in special definition for inlined functions that aren't inlined.
In this case, when you want to enforce the "single definition" rule,
you need to use a special compiler option to treat inline functions
as weak defs and a special linker option against multiple appearances
in the objects.

Are you saying that Unix systems support code bloat?

--
Francis Glassborow ACCU
Author of 'You Can Do It!' see http://www.spellen.org/youcandoit
or http://www.robinton.demon.co.uk
Happy Xmas, Hanukkah, Yuletide, Winter/Summer Solstice to all.


[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Back to top
Francis Glassborow
Guest





PostPosted: Sat Jan 03, 2004 3:05 pm    Post subject: Re: when inline function is not inlined Reply with quote

In message <e3c5fdc7.0401022130.73e41aae (AT) posting (DOT) google.com>, Rajaram S.
Gaunker <rajaram (AT) emuzed (DOT) com> writes
Quote:
linker wont fail as inline has two meanings
1) Request to inline the function.
2) function has internal linkage.

Not really true any longer (see 7.1.2). It is far from clear to me
exactly what inline now does with regard to linkage of functions. What
the Standard does say is that an inline function must have exactly the
same definition in all TUs where it is used and that a function with
external linkage that is declared inline in one TU must be declared as
inline in all TUs where it appears.

What really muddies the water is that through most of this sub-clause it
refers to functions with external linkage (or else makes no
specification. However right at the end it places two requirements on
functions declared as 'extern inline'. It seems to me that those
requirements (re static variables and string literals) should apply to
all inline functions with external linkage however that linkage is
acquired.





--
Francis Glassborow ACCU
Author of 'You Can Do It!' see http://www.spellen.org/youcandoit
or http://www.robinton.demon.co.uk
Happy Xmas, Hanukkah, Yuletide, Winter/Summer Solstice to all.


[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Back to top
Michael Tiomkin
Guest





PostPosted: Sun Jan 04, 2004 2:17 am    Post subject: Re: when inline function is not inlined Reply with quote

Francis Glassborow <francis (AT) robinton (DOT) demon.co.uk> wrote

Quote:
In message <ef72c6cb.0401021459.4438a837 (AT) posting (DOT) google.com>, Michael
Tiomkin <tmk (AT) netvision (DOT) net.il> writes
It seems that you use a Windows linker that doesn't allow multiple
definitions in object files. Many inline functions usually appear in .h
files and therefore can appear in many object files. As a result,
a WIndows compiler has to use a "weak definition" for inlined functions
in order to allow overriding of multiple appearances of the same item.
Unix linkers usually allow multiple definitions, and then there is
no need in special definition for inlined functions that aren't inlined.
In this case, when you want to enforce the "single definition" rule,
you need to use a special compiler option to treat inline functions
as weak defs and a special linker option against multiple appearances
in the objects.

Are you saying that Unix systems support code bloat?

Not at all. The difference is in object formats and common practice.
In Unix tradition, the executables can easily be relinked, e.g. in
"mv new-exe old-exe.o; cc -o new-exe 1st.o 2nd.o old-exe.o",
where the new items from 1st.o and 2nd.o are replacing their
previous versions from the same compilation units. In this case
you do have multiple definitions, but the linker chooses one of them.
On Windows, the executable format (PE) is different from
the object format (COFF), and an executable is not supposed
to be freely updated, allowing the linker to enforce the "single definition"
rule.

As a result, if you use two different functions with the same name
and signature, you'll get linker error in Windows, but on Unix
you might have the linker silently replace the functions with
one of the versions. It's not code bloat, but rather more error-prone
environment. This is the reason why you might want to enforce
the "signle definition" rule on Unix with the right compiler/linker options.
Many people compare Unix with Swiss Army knife - we should be
careful using it.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Back to top
Max Zinal
Guest





PostPosted: Sun Jan 04, 2004 2:23 am    Post subject: Re: when inline function is not inlined Reply with quote

Tony wrote:
Quote:
So if "inline" is used, even if it is not inlined, it is still
different from
not having "inline". What's the exact difference ? Where does the
compile put f1() defintion when "inline" is used ?

If it is inlined, it is inlined - no need to put its definition anywhere
but to the exact point of call. If the compiler refuses to make the
function inline, it makes it static. So the linker does not complain
on duplicate definitions, but you still have code to that function in
*any* translation unit from which the function is called.

I am not a guru in the Holy Standard, so I am not sure that language
specification requires such behaviour. Instead, I'm pretty shure that
is the way the things really happen (and *should* happen) in practice.

Thanks,
Max Zinal.


[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Back to top
James Dennett
Guest





PostPosted: Sun Jan 04, 2004 11:18 am    Post subject: Re: when inline function is not inlined Reply with quote

Max Zinal wrote:

Quote:
Tony wrote:

So if "inline" is used, even if it is not inlined, it is still
different from
not having "inline". What's the exact difference ? Where does the
compile put f1() defintion when "inline" is used ?


If it is inlined, it is inlined - no need to put its definition anywhere
but to the exact point of call. If the compiler refuses to make the
function inline, it makes it static. So the linker does not complain
on duplicate definitions, but you still have code to that function in
*any* translation unit from which the function is called.

I am not a guru in the Holy Standard, so I am not sure that language
specification requires such behaviour. Instead, I'm pretty shure that
is the way the things really happen (and *should* happen) in practice.

Not quite -- if you take the address of an inline function,
you must get the same result in each translation unit, for
example, and that wouldn't happen if the compiler just
treated the inline function as a static function. Similar
issues arise with uniqueness of static variables within
inline functions, and this is one are in which the rules
of C++ and those of C have diverged.

-- James.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Back to top
Francis Glassborow
Guest





PostPosted: Sun Jan 04, 2004 4:12 pm    Post subject: Re: when inline function is not inlined Reply with quote

In message <1073148357.537454 (AT) smtp (DOT) tvcom.ru>, Max Zinal <Zlat0 (AT) mail (DOT) ru>
writes
Quote:
Tony wrote:
So if "inline" is used, even if it is not inlined, it is still
different from
not having "inline". What's the exact difference ? Where does the
compile put f1() defintion when "inline" is used ?

If it is inlined, it is inlined - no need to put its definition anywhere
but to the exact point of call. If the compiler refuses to make the
function inline, it makes it static. So the linker does not complain
on duplicate definitions, but you still have code to that function in
*any* translation unit from which the function is called.

I am not a guru in the Holy Standard, so I am not sure that language
specification requires such behaviour. Instead, I'm pretty shure that
is the way the things really happen (and *should* happen) in practice.

That used to be true in pre-Standard days but I am far from sure that it
is the case today (see 7.1.2). Apart from issues of code bloat through
multiple instantiations of the same definition (though the requirement
that the definitions be the same in all TUs allows the linker to remove
duplicates -- something it must not do for real 'static' functions)
there is also the issue of string literals and static block scope
variables.

--
Francis Glassborow ACCU
Author of 'You Can Do It!' see http://www.spellen.org/youcandoit
or http://www.robinton.demon.co.uk
Happy Xmas, Hanukkah, Yuletide, Winter/Summer Solstice to all.


[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Back to top
James Kanze
Guest





PostPosted: Sun Jan 04, 2004 4:26 pm    Post subject: Re: when inline function is not inlined Reply with quote

[email]tongru_huo (AT) yahoo (DOT) com[/email] (Tony) writes:

Quote:
As put in many books, inline is only a suggestion to the compiler.
The inline function may not be inlined. When an inline function is
not inlined, it will be offlined just as a offline function. But I
wonder maybe there is still a difference.

//f1.h
inline void f1() { }
void f2();
void f3();

//f2.cpp
#include "f1.h"
void f2() { f1(); }

//f3.cpp
#include "f1.h"
void f3() { f1(); }

//main.cpp
#include "f1.h"
int main()
{
f2();
f3();
}

If f1() is complex, the inline may be ignored. But no matter how
complex f1() is, the above code can always run.

But if I remove "inline" from f1(), it will have duplicate
defintions in f2.cpp and f3.cpp. The linker will fail.

So if "inline" is used, even if it is not inlined, it is still
different from not having "inline". What's the exact difference ?
Where does the compile put f1() defintion when "inline" is used ?

You've just stated the only formal difference -- inline allows (and in
fact requires) multiple definitions, where as without inline, they are
illegal.

Practically, the intent of inline is clear, and any compiler who doesn't
respect it except for exceptional cases has a serious quality problem.
Because what constitutes an exceptional case depends at least a little
on how the compiler is implemented, the standard doesn't really have a
way of specifying this. But that shouldn't be taken as a license for
the compiler implementer to ignore inline (unless the compiler really
can do better than the programmer -- not often the case today). I
rarely use inline, but when I do, it is because I need it -- the
compiler had better not ignore it.

--
James Kanze mailto:kanze (AT) gabi-soft (DOT) fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France +33 1 41 89 80 93

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Back to top
James Kanze
Guest





PostPosted: Sun Jan 04, 2004 9:40 pm    Post subject: Re: when inline function is not inlined Reply with quote

[email]tmk (AT) netvision (DOT) net.il[/email] (Michael Tiomkin) writes:

Quote:
It seems that you use a Windows linker that doesn't allow multiple
definitions in object files. Many inline functions usually appear
in .h files and therefore can appear in many object files. As a
result, a WIndows compiler has to use a "weak definition" for
inlined functions in order to allow overriding of multiple
appearances of the same item.

Unix linkers usually allow multiple definitions, and then there is
no need in special definition for inlined functions that aren't
inlined.

I've never seen a Unix linker which allowed multiple definitions. The
GNU linker for Linux (version 2.13.90.0.1Cool certainly doesn't, nor does
the Sun linker on my Sparc (/usr/ccs/bin/ld, version 3.0).

Quote:
In this case, when you want to enforce the "single definition"
rule, you need to use a special compiler option to treat inline
functions as weak defs and a special linker option against multiple
appearances in the objects.

That's exactly how it is done under Unix, as well.

--
James Kanze mailto:kanze (AT) gabi-soft (DOT) fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France +33 1 41 89 80 93

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Back to top
James Kanze
Guest





PostPosted: Sun Jan 04, 2004 9:40 pm    Post subject: Re: when inline function is not inlined Reply with quote

[email]tmk (AT) netvision (DOT) net.il[/email] (Michael Tiomkin) writes:

Quote:
Francis Glassborow <francis (AT) robinton (DOT) demon.co.uk> wrote in message
news:<TUG1j3DI2o9$EwvP (AT) robinton (DOT) demon.co.uk>...
In message <ef72c6cb.0401021459.4438a837 (AT) posting (DOT) google.com>, Michael
Tiomkin <tmk (AT) netvision (DOT) net.il> writes
It seems that you use a Windows linker that doesn't allow
multiple definitions in object files. Many inline functions
usually appear in .h files and therefore can appear in many
object files. As a result, a WIndows compiler has to use a "weak
definition" for inlined functions in order to allow overriding of
multiple appearances of the same item. Unix linkers usually allow
multiple definitions, and then there is no need in special
definition for inlined functions that aren't inlined. In this
case, when you want to enforce the "single definition" rule, you
need to use a special compiler option to treat inline functions
as weak defs and a special linker option against multiple
appearances in the objects.

Are you saying that Unix systems support code bloat?

All systems support code bloat:-).

Quote:
Not at all. The difference is in object formats and common
practice.

In Unix tradition, the executables can easily be relinked, e.g. in
"mv new-exe old-exe.o; cc -o new-exe 1st.o 2nd.o old-exe.o", where
the new items from 1st.o and 2nd.o are replacing their previous
versions from the same compilation units. In this case you do have
multiple definitions, but the linker chooses one of them. On
Windows, the executable format (PE) is different from the object
format (COFF), and an executable is not supposed to be freely
updated, allowing the linker to enforce the "single definition"
rule.

I don't know what the current situation is, but the earliest Intel
compilers I used (circa 1979) certainly supported relinking an already
linked module. I don't remember being able to do this under early
Unix. (I don't remember trying, either, so it may have been possible.
But the a.out files and .o files definitely had a different magic
number, and some differences in the format. In 1985, at least.)

But my impression is that what you are describing is incremental
linking. Again, I don't know what the current situation under Windows
is, but it is a relatively recent feature (say in the last five or ten
years) under Unix -- it certainly didn't exist when I started using
Unix.

Incremental linking is a separate feature, and does not require that the
executable and the object files have the same format; for it to work
correctly, in fact, the linker has to know which file is the old
executable file, and treat it differently.

Quote:
As a result, if you use two different functions with the same name
and signature, you'll get linker error in Windows, but on Unix you
might have the linker silently replace the functions with one of the
versions.

Could you cite which Unix version does this. As I said, I've never seen
it, and the two current Unix I have access to (Linux and Solaris) both
give me a definite error when I have a function defined in two different
translation units.

Or perhaps you are thinking of what happens with dynamic linking. I
think that there are differences there -- at least with dlopen under
Unix, if a dynamic object contains a definition for a symbol already
defined, that definition can be ignored. I don't know very much about
DLL's under Windows, but I seem to recall hearing that you can't export
the same symbol in two different DLL's. (There is a fundamental
difference in philosophy between the Unix and Windows work here. Under
Unix, you decide what symbols interest you in the dynamic object when
you load it. Under Windows, you seem to have to specify this
information when you create the dynamic object.)

--
James Kanze mailto:kanze (AT) gabi-soft (DOT) fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France +33 1 41 89 80 93

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Back to top
Display posts from previous:   
Post new topic   Reply to topic    C++Talk.NET Forum Index -> C++ Language (Moderated) All times are GMT
Goto page 1, 2, 3  Next
Page 1 of 3

 
Jump to:  
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum


Powered by phpBB © 2001, 2006 phpBB Group
SEO toolkit © 2004-2006 webmedic.