Open Watcom Developer's Guide - HEAnet Mirror Service

More documents

Recommendations

Info

Style • function declarations and global variable definitions • function implementation As you can see, nothing fancy. Many programmers prefer to order functions so as to minimize forward declarations, ie. a main() function would be located at the end and every function fully defined before it is first used. You can use extern declarations but you should be very careful. It is strongly encouraged that all declarations of external functions and variable be located in header files which are included in modules that use them as well as modules that define them. The reason is simple — this way the compiler will tell you if you change the definition but not the header file. If you use ad-hoc extern declarations, you better make sure they’re in sync with the actual definitions. 7.2 Help the compiler and it will help you While the compiler is a rather sophisticated piece of software, it cannot divine your intentions. Hence you have to help it a bit by giving hints here and there. And if you help the compiler in this way, it will be better able to help you. First of all, always compile with maximum warning level. Just because a message is called a warning and not error doesn’t mean you can ignore it. In fact many projects treat warnings as errors and will not build if any warnings are present. That is a Good Thing. Use the static keyword often because it is good. This is a multi-faceted keyword and its exact semantics depend on where it is applied: globals locals here the static modifier does not change the storage class but makes the variables local to the module where they are defined, that is they won’t be visible from other modules. If a variable needs to be global but doesn’t have to be accessed from other modules, you should definitely make it static. That way you will not needlessly pollute the global namespace (reducing the chance of name clashes) and if you stop using the variable, the compiler will warn you. If you have a non-static global variable that is unused, the compiler cannot warn you as it has to assume that it is used from other modules. in this case the static keyword changes the storage class and the variable will be stored in data segment instead of on stack. If you need a variable that has global lifetime but only needs to be accessible from one function, making it local and static is a good choice. 36 Help the compiler and it will help you
Programming Style functions the effect of the static keyword here is similar to the global variables. The function will not be visible from other modules. Again, the compiler will warn you if you stop using such a function. But declaring a function static also helps the optimizer. For instance if the optimizer inlines a static function, it can completely remove the non-inlined version. If the function weren’t static, the non-inlined version always has to be present for potential external callers. Similar in vein to the static keyword is the const keyword. Again it can be applied in various ways and it helps the compiler and optimizer by giving it hints about how you intend to use a particular variable or argument. Saying that a variable is constant is essentially the same as saying that it’s read-only. The compiler/linker might place such variable in a read-only segment. While it is possible to circumvent the const modifier by taking the address of a constant variable and modifying it through a pointer, this is a bad thing to do and it may not work at all because the variable might be not be physically writable. It is perhaps worthwhile to remark that there are three possible outomes of applying the const modifier to a pointer: • a constant pointer, that is the value of the pointer is constant but the data it points to isn’t • a pointer to a constant, that is the pointer itself is not constant but the value it points to cannot be modified through it • a constant pointer to a constant, that is both the pointer itself and the value it points to are constant. The const keyword is especially useful when used in function declarations. Consider the following typical declaration: char *strcpy( char *s1, const char *s2 ); Here we have a function which takes two arguments that are both pointers to char but one of them is a pointer to a constant. In the function body the compiler will not let you modify the contents of *s2 but the declaration is also important for the caller. In the calling funtion, the optimizer now knows that the data the s2 argument points to will not be modified by strcpy() and it can take advantage of this knowledge. Help the compiler and it will help you 37
Page 1 and 2: Open Watcom Developer’s Guide Fir
Page 3 and 4: Table of Contents Introduction ....
Page 5 and 6: Introduction
Page 7 and 8: 1 Project Overview This document se
Page 9 and 10: Project Overview The root of the Op
Page 11 and 12: Project Overview dwarf editdll emu
Page 13 and 14: Project Overview ui vi viper viprde
Page 15 and 16: 2 First Steps This chapter briefly
Page 17 and 18: Building
Page 19 and 20: 3 Build Architecture In an effort t
Page 21 and 22: Build Architecture $(AS): $(RC): $(
Page 23 and 24: Build Architecture 3.6 Memory Track
Page 25 and 26: Build Architecture tools required d
Page 27 and 28: Build Architecture 5. Add proj_name
Page 29 and 30: 4 Technical Notes 4.1 32-bit Window
Page 31 and 32: 5 Build Process We use the (Open) W
Page 33 and 34: 6 Testing There is undoubtedly a qu
Page 35 and 36: Testing orl plustest ssl trmem vipr
Page 37 and 38: Style
Page 39: 7 Programming Style Programming sty
Page 43 and 44: Documentation
Page 45 and 46: 8 Producing Documentation The purpo
Page 47 and 48: Producing Documentation • Note th
Page 49 and 50: Producing Documentation .np The rec
Page 51 and 52: Index # F #include 35 fastest 16-bi

Open Watcom Developer's Guide - HEAnet Mirror Service

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?