Webkit Coding Style Guidelines

Webkit Coding Style Guidelines
Source: http://webkit.org/coding/coding-style.html

WebKit Coding Style Guidelines

Indentation

Use spaces, not tabs. Tabs should only appear in files that require them for semantic meaning, like Makefiles.

The indent size is 4 spaces.

Right:

int main()
{
    return 0;
}

Wrong:

int main() 
{
        return 0;
}

Code inside a namespace should not be indented.

Right:

// Document.h
namespace WebCore {

class Document {
    Document();
    ...
};

} // namespace WebCore

// Document.cpp
namespace WebCore {

Document::Document()
{
    ...
}

} // namespace WebCore

Wrong:

// Document.h
namespace WebCore {

    class Document {
        Document();
        ...
    };

} // namespace WebCore

// Document.cpp
namespace WebCore {

    Document::Document()
    {
        ...
    }

} // namespace WebCore

A case label should line up with its switch statement. The case statement is indented.

Right:

switch (condition) {
case fooCondition:
case barCondition:
    i++;
    break;
default:
    i--;
}

Wrong:

switch (condition) {
    case fooCondition:
    case barCondition:
        i++;
        break;
    default:
        i--;
}

Boolean expressions at the same nesting level that span multiple lines should have their operators on the left side of the line instead of the right side.

Right:

if (attr->name() == srcAttr
    || attr->name() == lowsrcAttr
    || (attr->name() == usemapAttr && attr->value().domString()[0] != '#'))
    return;

Wrong:

if (attr->name() == srcAttr ||
    attr->name() == lowsrcAttr ||
    (attr->name() == usemapAttr && attr->value().domString()[0] != '#'))
    return;

Spacing

Do not place spaces around unary operators.

Right:
```
i++;
```
Wrong:
```
i ++;
```

Do place spaces around binary and ternary operators.

Right:

y = m * x + b;
f(a, b);
c = a | b;
return condition ? 1 : 0;

Wrong:

y=m*x+b;
f(a,b);
c = a|b;
return condition ? 1:0;

Do not place spaces before comma and semicolon.

Right:

for (int i = 0; i < 10; i++)
    doSomething();

f(a, b);

Wrong:

for (int i = 0 ; i < 10 ; i++)
    doSomething();

f(a , b) ;

Place spaces between control statements and their parentheses.

Right:
```
if (condition)
    doIt();
```
Wrong:
```
if(condition)
    doIt();
```
Do not place spaces between a function and its parentheses, or between a parenthesis and its content.

Right:
```
f(a, b);
```
Wrong:
```
f (a, b);
f( a, b );
```

Line breaking

Each statement should get its own line.

Right:

x++;
y++;
if (condition)
    doIt();

Wrong:

x++; y++;
if (condition) doIt();

An else statement should go on the same line as a preceding close brace if one is present, else it should line up with the if statement.

Right:

if (condition) {
    ...
} else {
    ...
}

if (condition)
    doSomething();
else
    doSomethingElse();

if (condition)
    doSomething();
else {
    ...
}

Wrong:

if (condition) {
    ...
}
else {
    ...
}

if (condition) doSomething(); else doSomethingElse();

if (condition) doSomething(); else {
    ...
}

An else if statement should be written as an if statement when the prior if concludes with a return statement.

Right:

if (condition) {
    ...
    return someValue;
}
if (condition) {
    ...
}

Wrong:

if (condition) {
    ...
    return someValue;
} else if (condition) {
    ...
}

Braces

Function definitions: place each brace on its own line.

Right:
```
int main()
{
    ...
}
```
Wrong:
```
int main() {
    ...
}
```

Other braces: place the open brace on the line preceding the code block; place the close brace on its own line.

Right:

class MyClass {
    ...
};

namespace WebCore {
    ...
}

for (int i = 0; i < 10; i++) {
    ...
}

Wrong:

class MyClass 
{
    ...
};

One-line control clauses should not use braces unless comments are included or a single statement spans multiple lines.

Right:

if (condition)
    doIt();

if (condition) {
    // Some comment
    doIt();
}

if (condition) {
    myFunction(reallyLongParam1, reallyLongParam2, ...
        reallyLongParam5);
}

Wrong:

if (condition) {
    doIt();
}

if (condition)
    // Some comment
    doIt();

if (condition)
    myFunction(reallyLongParam1, reallyLongParam2, ...
        reallyLongParam5);

Control clauses without a body should use empty braces:

Right:

for ( ; current; current = current->next) { }

Wrong:

for ( ; current; current = current->next);

Null, false and 0

In C++, the null pointer value should be written as 0. In C, it should be written as NULL. In Objective-C and Objective-C++, follow the guideline for C or C++, respectively, but usenil to represent a null Objective-C object.
C++ and C bool values should be written as true and false. Objective-C BOOL values should be written as YES and NO.

Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons.

Right:

if (condition)
    doIt();
    
if (!ptr)
    return;

if (!count)
    return;

Wrong:

if (condition == true)
    doIt();
    
if (ptr == NULL)
    return;
    
if (count == 0)
    return;

In Objective-C, instance variables are initialized to zero automatically. Don't add explicit initializations to nil or NO in an init method.

Floating point literals

Unless required in order to force floating point math, do not append .0, .f and .0f to floating point literals.

Right:

const double duration = 60;

void setDiameter(float diameter)
{
    radius = diameter / 2;
}

setDiameter(10);

const int framesPerSecond = 12;
double frameDuration = 1.0 / framesPerSecond;

Wrong:

const double duration = 60.0;

void setDiameter(float diameter)
{
    radius = diameter / 2.f;
}

setDiameter(10.f);

const int framesPerSecond = 12;
double frameDuration = 1 / framesPerSecond; // integer division

Names

Use CamelCase. Capitalize the first letter, including all letters in an acronym, in a class, struct, protocol, or namespace name. Lower-case the first letter, including all letters in an acronym, in a variable or function name.

Right:
```
struct Data;
size_t bufferSize;
class HTMLDocument;
String mimeType();
```
Wrong:
```
struct data;
size_t buffer_size;
class HtmlDocument;
String MIMEType();
```

Use full words, except in the rare case where an abbreviation would be more canonical and easier to understand.

Right:

size_t characterSize;
size_t length;
short tabIndex; // more canonical

Wrong:

size_t charSize;
size_t len;
short tabulationIndex; // bizarre

Prefix C++ data members with "m_".

Right:

class String {
    ...
    short m_length;
};

Wrong:

class String {
    ...
    short length;
};

Prefix Objective-C instance variables with "_".

Right:

@class String
    ...
    short _length;
@end

Wrong:

@class String
    ...
    short length;
@end

Precede boolean values with words like "is" and "did".

Right:
```
bool isValid;
bool didSendData;
```
Wrong:
```
bool valid;
bool sentData;
```
Precede setters with the word "set". Use bare words for getters. Setter and getter names should match the names of the variables being set/gotten.

Right:
```
void setCount(size_t); // sets m_count
size_t count(); // returns m_count
```
Wrong:
```
void setCount(size_t); // sets m_theCount
size_t getCount();
```

Use descriptive verbs in function names.

Right:

bool convertToASCII(short*, size_t);

Wrong:

bool toASCII(short*, size_t);

Leave meaningless variable names out of function declarations.

Right:
```
void setCount(size_t);
```
Wrong:
```
void setCount(size_t count);
```
Objective-C method names should follow the Cocoa naming guidelines — they should read like a phrase and each piece of the selector should start with a lowercase letter and use intercaps.
Enum members should user InterCaps with an initial capital letter.
Prefer const to #define. Prefer inline functions to macros.
#defined constants should use all uppercase names with words separated by underscores.
Macros that expand to function calls or other non-constant computation: these should be named like functions, and should have parentheses at the end, even if they take no arguments (with the exception of some special macros like ASSERT). Note that usually it is preferable to use an inline function in such cases instead of a macro.

Right:
```
#define WBStopButtonTitle() \
        NSLocalizedString(@"Stop", @"Stop button title")
```
Wrong:
```
#define WB_STOP_BUTTON_TITLE \
        NSLocalizedString(@"Stop", @"Stop button title")

#define WBStopButtontitle \
        NSLocalizedString(@"Stop", @"Stop button title")
```

#define, #ifdef "header guards" should be named exactly the same as the file (including case), replacing the '.' with a '_'.

Right:

// HTMLDocument.h
#ifndef HTMLDocument_h
#define HTMLDocument_h

Wrong:

// HTMLDocument.h
#ifndef _HTML_DOCUMENT_H_
#define _HTML_DOCUMENT_H_

Other Punctuation

Constructors for C++ classes should initialize all of their members using C++ initializer syntax. Each member (and superclass) should be indented on a separate line, with the colon or comma preceding the member on that line.

Right:

MyClass::MyClass(Document* doc)
    : MySuperClass()
    , m_myMember(0)
    , m_doc(doc)
{
}

MyOtherClass::MyOtherClass()
    : MySuperClass()
{
}

Wrong:

MyClass::MyClass(Document* doc) : MySuperClass()
{
    m_myMember = 0;
    m_doc = doc;
}

MyOtherClass::MyOtherClass() : MySuperClass() {}

Pointer types in non-C++ code — Pointer types should be written with a space between the type and the * (so the * is adjacent to the following identifier if any).

Pointer and reference types in C++ code — Both pointer types and reference types should be written with no space between the type name and the * or &.

Right:

Image* SVGStyledElement::doSomething(PaintInfo& paintInfo)
{
    SVGStyledElement* element = static_cast(node());
    const KCDashArray& dashes = dashArray();

Wrong:

Image *SVGStyledElement::doSomething(PaintInfo &paintInfo)
{
    SVGStyledElement *element = static_cast(node());
    const KCDashArray &dashes = dashArray();

#include Statements

All implementation files must #include "config.h" first. Header files should never include "config.h".

Right:

// RenderLayer.h
#include "Node.h"
#include "RenderObject.h"
#include "RenderView.h"

Wrong:

// RenderLayer.h
#include "config.h"

#include "RenderObject.h"
#include "RenderView.h"
#include "Node.h"

All implementation files must #include the primary header second, just after "config.h". So for example, Node.cpp should include Node.h first, before other files. This guarantees that each header's completeness is tested. This also assures that each header can be compiled without requiring any other header files be included first.

Other #include statements should be in sorted order (case sensitive, as done by the command-line sort tool or the Xcode sort selection command). Don't bother to organize them in a logical order.

Right:

// HTMLDivElement.cpp
#include "config.h"
#include "HTMLDivElement.h"

#include "Attribute.h"
#include "HTMLElement.h"
#include "QualifiedName.h"

Wrong:

// HTMLDivElement.cpp
#include "HTMLElement.h"
#include "HTMLDivElement.h"
#include "QualifiedName.h"
#include "Attribute.h"

"using" Statements

In header files, do not use "using" statements in namespace (or global) scope.

Right:

// wtf/Vector.h

namespace WTF {

class VectorBuffer {
    using std::min;
    ...
};

} // namespace WTF

Wrong:

// wtf/Vector.h

namespace WTF {

using std::min;
    
class VectorBuffer {
    ...
};

} // namespace WTF

In header files in the WTF sub-library, however, it is acceptable to use "using" declarations at the end of the file to import one or more names in the WTF namespace into the global scope.

Right:

// wtf/Vector.h

namespace WTF {

} // namespace WTF

using WTF::Vector;

Wrong:

// wtf/Vector.h

namespace WTF {

} // namespace WTF

using namespace WTF;

Wrong:

// runtime/UString.h

namespace WTF {

} // namespace WTF

using WTF::PlacementNewAdopt;

In C++ implementation files, do not use statements of the form "using std::foo" to import names in the standard template library. Use "using namespace std" instead.

Right:

// HTMLBaseElement.cpp

using namespace std;

namespace WebCore {

} // namespace WebCore

Wrong:

// HTMLBaseElement.cpp

using std::swap;

namespace WebCore {

} // namespace WebCore

In implementation files, if a "using namespace" statement is for a nested namespace whose parent namespace is defined in the file, put the statement inside that namespace definition.

Right:

// HTMLBaseElement.cpp

namespace WebCore {

using namespace HTMLNames;

} // namespace WebCore

Wrong:

// HTMLBaseElement.cpp

using namespace WebCore::HTMLNames;

namespace WebCore {

} // namespace WebCore

In implementation files, put all other "using" statements at the beginning of the file, before any namespace definitions and after any "include" statements.

Right:

// HTMLSelectElement.cpp

using namespace std;

namespace WebCore {

} // namespace WebCore

Wrong:

// HTMLSelectElement.cpp

namespace WebCore {

using namespace std;

} // namespace WebCore

-----
Cheers,
June

You're the Best! - June

화요일, 2월 02, 2010