Make code ANSI C89-friendly.
authorbmcquade <bmcquade@google.com>
Mon, 17 Oct 2011 23:57:23 +0000 (23:57 +0000)
committerbmcquade <bmcquade@google.com>
Mon, 17 Oct 2011 23:57:23 +0000 (23:57 +0000)
13 files changed:
src/domain_registry/domain_registry.h
src/domain_registry/example.c
src/domain_registry/private/assert.c
src/domain_registry/private/assert.h
src/domain_registry/private/init_registry_tables.c
src/domain_registry/private/registry_search.c
src/domain_registry/private/registry_types.h
src/domain_registry/private/string_util.h
src/domain_registry/private/trie_node.h
src/domain_registry/private/trie_search.c
src/domain_registry/private/trie_search.h
src/registry_tables_generator/registry_tables_generator.py
src/registry_tables_generator/table_serializer.py

index e13a05d..78a8d6c 100644 (file)
@@ -1,16 +1,18 @@
-// Copyright 2011 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #ifndef DOMAIN_REGISTRY_DOMAIN_REGISTRY_H_
 #define DOMAIN_REGISTRY_DOMAIN_REGISTRY_H_
 extern "C" {
 #endif
 
-// Call once at program startup to enable domain registry
-// search. Calls to GetRegistryLength will crash if this is not
-// called.
+/*
+ * Call once at program startup to enable domain registry
+ * search. Calls to GetRegistryLength will crash if this is not
+ * called.
+ */
 void InitializeDomainRegistry(void);
 
-// Finds the length in bytes of the registrar portion of the host in
-// the given hostname.  Returns 0 if the hostname is invalid or has no
-// host (e.g. a file: URL). Returns 0 if the hostname has multiple
-// trailing dots. If no matching rule is found in the effective-TLD
-// data, returns 0. Internationalized domain names (IDNs) must be
-// converted to punycode first. Non-ASCII hostnames or hostnames
-// longer than 127 bytes will return 0. It is an error to pass in an
-// IP address (either IPv4 or IPv6) and the return value in this case
-// is undefined.
-//
-// Examples:
-//   www.google.com       -> 3                 (com)
-//   WWW.gOoGlE.cOm       -> 3                 (com, case insensitive)
-//   ..google.com         -> 3                 (com)
-//   google.com.          -> 4                 (com)
-//   a.b.co.uk            -> 5                 (co.uk)
-//   a.b.co..uk           -> 0                 (multiple dots in registry)
-//   C:                   -> 0                 (no host)
-//   google.com..         -> 0                 (multiple trailing dots)
-//   bar                  -> 0                 (no subcomponents)
-//   co.uk                -> 5                 (co.uk)
-//   foo.bar              -> 0                 (not a valid top-level registry)
-//   foo.臺灣               -> 0                 (not converted to punycode)
-//   foo.xn--nnx388a      -> 11                (punycode representation of 臺灣)
-//   192.168.0.1          -> ?                 (IP address, retval undefined)
+/*
+ * Finds the length in bytes of the registrar portion of the host in
+ * the given hostname.  Returns 0 if the hostname is invalid or has no
+ * host (e.g. a file: URL). Returns 0 if the hostname has multiple
+ * trailing dots. If no matching rule is found in the effective-TLD
+ * data, returns 0. Internationalized domain names (IDNs) must be
+ * converted to punycode first. Non-ASCII hostnames or hostnames
+ * longer than 127 bytes will return 0. It is an error to pass in an
+ * IP address (either IPv4 or IPv6) and the return value in this case
+ * is undefined.
+ *
+ * Examples:
+ *   www.google.com       -> 3                 (com)
+ *   WWW.gOoGlE.cOm       -> 3                 (com, case insensitive)
+ *   ..google.com         -> 3                 (com)
+ *   google.com.          -> 4                 (com)
+ *   a.b.co.uk            -> 5                 (co.uk)
+ *   a.b.co..uk           -> 0                 (multiple dots in registry)
+ *   C:                   -> 0                 (no host)
+ *   google.com..         -> 0                 (multiple trailing dots)
+ *   bar                  -> 0                 (no subcomponents)
+ *   co.uk                -> 5                 (co.uk)
+ *   foo.bar              -> 0                 (not a valid top-level registry)
+ *   foo.臺灣               -> 0                 (not converted to punycode)
+ *   foo.xn--nnx388a      -> 11                (punycode representation of 臺灣)
+ *   192.168.0.1          -> ?                 (IP address, retval undefined)
+ */
 size_t GetRegistryLength(const char* hostname);
 
-// Like GetRegistryLength, but allows unknown registries as well. If
-// the hostname is part of a known registry, the return value will be
-// identical to that of GetRegistryLength. If the hostname is not part
-// of a known registry (e.g. foo.bar) then the return value will
-// assume that the rootmost hostname-part is the registry.  It is an
-// error to pass in an IP address (either IPv4 or IPv6) and the return
-// value in this case is undefined.
-//
-// Examples:
-//   foo.bar              -> 3                 (bar)
-//   bar                  -> 0                 (host is a registry)
-//   www.google.com       -> 3                 (com)
-//   com                  -> 0                 (host is a registry)
-//   co.uk                -> 0                 (host is a registry)
-//   foo.臺灣               -> 0                 (not converted to punycode)
-//   foo.xn--nnx388a      -> 11                (punycode representation of 臺灣)
-//   192.168.0.1          -> ?                 (IP address, retval undefined)
+/*
+ * Like GetRegistryLength, but allows unknown registries as well. If
+ * the hostname is part of a known registry, the return value will be
+ * identical to that of GetRegistryLength. If the hostname is not part
+ * of a known registry (e.g. foo.bar) then the return value will
+ * assume that the rootmost hostname-part is the registry.  It is an
+ * error to pass in an IP address (either IPv4 or IPv6) and the return
+ * value in this case is undefined.
+ *
+ * Examples:
+ *   foo.bar              -> 3                 (bar)
+ *   bar                  -> 0                 (host is a registry)
+ *   www.google.com       -> 3                 (com)
+ *   com                  -> 0                 (host is a registry)
+ *   co.uk                -> 0                 (host is a registry)
+ *   foo.臺灣               -> 0                 (not converted to punycode)
+ *   foo.xn--nnx388a      -> 11                (punycode representation of 臺灣)
+ *   192.168.0.1          -> ?                 (IP address, retval undefined)
+ */
 size_t GetRegistryLengthAllowUnknownRegistries(const char* hostname);
 
-// Override the assertion handler by providing a custom assert handler
-// implementation. The assertion handler will be invoked when an
-// internal assertion fails. This is usually indicative of a fatal
-// error and execution should not be allowed to continue. The default
-// implementation logs the assertion information to stderr and invokes
-// abort(). The parameter "file" is the filename where the assertion
-// was triggered. "line_number" is the line number in that
-// file. "cond_str" is the string representation of the assertion that
-// failed.
+/*
+ * Override the assertion handler by providing a custom assert handler
+ * implementation. The assertion handler will be invoked when an
+ * internal assertion fails. This is usually indicative of a fatal
+ * error and execution should not be allowed to continue. The default
+ * implementation logs the assertion information to stderr and invokes
+ * abort(). The parameter "file" is the filename where the assertion
+ * was triggered. "line_number" is the line number in that
+ * file. "cond_str" is the string representation of the assertion that
+ * failed.
+ */
 typedef void (*DomainRegistryAssertHandler)(
     const char* file, int line_number, const char* cond_str);
 void SetDomainRegistryAssertHandler(DomainRegistryAssertHandler handler);
 
 #ifdef __cplusplus
-}  // extern "C"
+}   /* extern "C" */
 #endif
 
-#endif  // DOMAIN_REGISTRY_DOMAIN_REGISTRY_H_
+#endif  /* DOMAIN_REGISTRY_DOMAIN_REGISTRY_H_ */
index 0c02616..6de9c90 100644 (file)
@@ -1,19 +1,21 @@
-// Copyright 2011 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
 
-// Simple example that shows how to use the domain registry provider
-// API.
+ * Simple example that shows how to use the domain registry provider
+ * API.
+ */
 
 #include <stdlib.h>
 #include <stdio.h>
index 48634ca..4afeb80 100644 (file)
@@ -1,16 +1,18 @@
-// Copyright 2011 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #include "domain_registry/private/assert.h"
 
index b865f50..49fba6f 100644 (file)
@@ -1,16 +1,18 @@
-// Copyright 2011 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #ifndef DOMAIN_REGISTRY_PRIVATE_ASSERT_H_
 #define DOMAIN_REGISTRY_PRIVATE_ASSERT_H_
@@ -23,4 +25,4 @@ void DoAssert(const char* file, int line, const char* cond_str, int cond);
 #define DCHECK(x) DoAssert(__FILE__, __LINE__, #x, (x))
 #endif
 
-#endif  // DOMAIN_REGISTRY_PRIVATE_ASSERT_H_
+#endif  /* DOMAIN_REGISTRY_PRIVATE_ASSERT_H_ */
index e59b095..2407557 100644 (file)
@@ -1,16 +1,18 @@
-// Copyright 2011 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #include "domain_registry/domain_registry.h"
 
@@ -20,7 +22,7 @@
 #include "domain_registry/private/trie_node.h"
 #include "domain_registry/private/trie_search.h"
 
-// Include the generated file that contains the actual registry tables.
+/* Include the generated file that contains the actual registry tables. */
 #include "registry_tables_genfiles/registry_tables.h"
 
 void InitializeDomainRegistry(void) {
index 1889707..6ba433c 100644 (file)
@@ -1,16 +1,18 @@
-// Copyright 2011 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #include "domain_registry/domain_registry.h"
 
 #include "domain_registry/private/string_util.h"
 #include "domain_registry/private/trie_search.h"
 
-// RFCs 1035 and 1123 specify a max hostname length of 255 bytes.
+/* RFCs 1035 and 1123 specify a max hostname length of 255 bytes. */
 static const size_t kMaxHostnameLen = 255;
 
+/* strdup() is not part of ANSI C89 so we define our own. */
+static char* StrDup(const char* s) {
+  const size_t len = strlen(s);
+  char* s2 = malloc(len + 1);
+  if (s2 == NULL) {
+    return NULL;
+  }
+  memcpy(s2, s, len);
+  s2[len] = 0;
+  return s2;
+}
+
+/* strnlen() is not part of ANSI C89 so we define our own. */
+static size_t StrnLen(const char* s, size_t max) {
+  const char* end = s + max;
+  const char* i;
+  for (i = s; i < end; ++i) {
+    if (*i == 0) break;
+  }
+  return i - s;
+}
+
 static int IsStringASCII(const char* s) {
   const char* it = s;
   for (; *it != 0; ++it) {
@@ -35,25 +59,29 @@ static int IsStringASCII(const char* s) {
 }
 
 static int IsValidHostname(const char* hostname) {
-  // http://www.ietf.org/rfc/rfc1035.txt (DNS) and
-  // http://tools.ietf.org/html/rfc1123 (Internet host requirements)
-  // specify a maximum hostname length of 255 characters. To make sure
-  // string comparisons, etc are bounded elsewhere in the codebase, we
-  // enforce the 255 character limit here. There are various other
-  // hostname constraints specified in the RFCs (63 bytes per
-  // hostname-part, etc) but we do not enforce those here since doing
-  // so would not change correctness of the overall implementation,
-  // and it's possible that hostnames used in other contexts
-  // (e.g. outside of DNS) would not be subject to the 63-byte
-  // hostname-part limit. So we let the DNS layer enforce its policy,
-  // and enforce only the maximum hostname length here.
-  if (strnlen(hostname, kMaxHostnameLen + 1) > kMaxHostnameLen) {
+  /*
+   * http://www.ietf.org/rfc/rfc1035.txt (DNS) and
+   * http://tools.ietf.org/html/rfc1123 (Internet host requirements)
+   * specify a maximum hostname length of 255 characters. To make sure
+   * string comparisons, etc are bounded elsewhere in the codebase, we
+   * enforce the 255 character limit here. There are various other
+   * hostname constraints specified in the RFCs (63 bytes per
+   * hostname-part, etc) but we do not enforce those here since doing
+   * so would not change correctness of the overall implementation,
+   * and it's possible that hostnames used in other contexts
+   * (e.g. outside of DNS) would not be subject to the 63-byte
+   * hostname-part limit. So we let the DNS layer enforce its policy,
+   * and enforce only the maximum hostname length here.
+   */
+  if (StrnLen(hostname, kMaxHostnameLen + 1) > kMaxHostnameLen) {
     return 0;
   }
 
-  // All hostnames must contain only ASCII characters. If a hostname
-  // is passed in that contains non-ASCII (e.g. an IDN that hasn't been
-  // converted to ASCII via punycode) we want to reject it outright.
+  /*
+   * All hostnames must contain only ASCII characters. If a hostname
+   * is passed in that contains non-ASCII (e.g. an IDN that hasn't been
+   * converted to ASCII via punycode) we want to reject it outright.
+   */
   if (IsStringASCII(hostname) == 0) {
     return 0;
   }
@@ -61,9 +89,11 @@ static int IsValidHostname(const char* hostname) {
   return 1;
 }
 
-// Get a pointer to the beginning of the valid registry. If rule_part
-// is an exception component, this will seek past the
-// rule_part. Otherwise this will simply return the component itself.
+/*
+ * Get a pointer to the beginning of the valid registry. If rule_part
+ * is an exception component, this will seek past the
+ * rule_part. Otherwise this will simply return the component itself.
+ */
 static const char* GetDomainRegistryStr(const char* rule_part,
                                         const char* component) {
   if (IsExceptionComponent(rule_part)) {
@@ -73,11 +103,13 @@ static const char* GetDomainRegistryStr(const char* rule_part,
   }
 }
 
-// Iterates the hostname-parts between start and end in reverse order,
-// separated by the character specified by sep. For instance if the
-// string between start and end is "foo\0bar\0com" and sep is the null
-// character, we will return a pointer to "com", then "bar", then
-// "foo".
+/*
+ * Iterates the hostname-parts between start and end in reverse order,
+ * separated by the character specified by sep. For instance if the
+ * string between start and end is "foo\0bar\0com" and sep is the null
+ * character, we will return a pointer to "com", then "bar", then
+ * "foo".
+ */
 static const char* GetNextHostnamePartImpl(const char* start,
                                            const char* end,
                                            char sep,
@@ -88,9 +120,11 @@ static const char* GetNextHostnamePartImpl(const char* start,
   if (*ctx == NULL) {
     *ctx = (void*) end;
 
-    // Special case: a single trailing dot indicates a fully-qualified
-    // domain name. Skip over it.
-    if (*(end - 1) == 0) {
+    /*
+     * Special case: a single trailing dot indicates a fully-qualified
+     * domain name. Skip over it.
+     */
+     if (*(end - 1) == 0) {
       *ctx = (void*) (end - 1);
     }
   }
@@ -103,10 +137,12 @@ static const char* GetNextHostnamePartImpl(const char* start,
     }
   }
   if (last != start && *start != 0) {
-    // Special case: If we didn't find a match, but the context
-    // indicates that we haven't visited the first component yet, and
-    // there is a non-NULL first component, then visit the first
-    // component.
+    /*
+     * Special case: If we didn't find a match, but the context
+     * indicates that we haven't visited the first component yet, and
+     * there is a non-NULL first component, then visit the first
+     * component.
+     */
     *ctx = (void*) start;
     return start;
   }
@@ -124,8 +160,10 @@ static const char* GetNextHostnamePart(const char* start,
   return hostname_part;
 }
 
-// Iterate over all hostname-parts between value and value_end, where
-// the hostname-parts are separated by character sep.
+/*
+ * Iterate over all hostname-parts between value and value_end, where
+ * the hostname-parts are separated by character sep.
+ */
 static const char* GetRegistryForHostname(const char* value,
                                           const char* value_end,
                                           const char sep) {
@@ -134,8 +172,10 @@ static const char* GetRegistryForHostname(const char* value,
   const char* component = NULL;
   const char* last_valid = NULL;
 
-  // Iterate over the hostname components one at a time, e.g. if value
-  // is foo.com, we will first visit component com, then component foo.
+  /*
+   * Iterate over the hostname components one at a time, e.g. if value
+   * is foo.com, we will first visit component com, then component foo.
+   */
   while ((component =
           GetNextHostnamePart(value, value_end, sep, &ctx)) != NULL) {
     const char* leaf_node;
@@ -151,8 +191,10 @@ static const char* GetRegistryForHostname(const char* value,
       last_valid = NULL;
     }
     if (HasLeafChildren(current)) {
-      // The child nodes are in the leaf node table, so perform a
-      // search in that table.
+      /*
+       * The child nodes are in the leaf node table, so perform a
+       * search in that table.
+       */
       component = GetNextHostnamePart(value, value_end, sep, &ctx);
       if (component == NULL) {
         break;
@@ -177,21 +219,25 @@ static size_t GetRegistryLengthImpl(
   size_t match_len;
 
   while (*value == sep && value < value_end) {
-    // Skip over leading separators.
+    /* Skip over leading separators. */
     ++value;
   }
   registry = GetRegistryForHostname(value, value_end, sep);
   if (registry == NULL) {
-    // Didn't find a match. If unknown registries are allowed, see if
-    // the root hostname part is not in the table. If so, consider it to be a
-    // valid registry, and return its length.
+    /*
+     * Didn't find a match. If unknown registries are allowed, see if
+     * the root hostname part is not in the table. If so, consider it to be a
+     * valid registry, and return its length.
+     */
     if (allow_unknown_registries != 0) {
       void* ctx = NULL;
       const char* root_hostname_part =
           GetNextHostnamePart(value, value_end, sep, &ctx);
-      // See if the root hostname-part is in the table. If it's not in
-      // the table, then consider the unknown registry to be a valid
-      // registry.
+      /*
+       * See if the root hostname-part is in the table. If it's not in
+       * the table, then consider the unknown registry to be a valid
+       * registry.
+       */
       if (root_hostname_part != NULL &&
           FindRegistryNode(root_hostname_part, NULL) == NULL) {
         registry = root_hostname_part;
@@ -202,7 +248,7 @@ static size_t GetRegistryLengthImpl(
     }
   }
   if (registry < value || registry >= value_end) {
-    // Error cases.
+    /* Error cases. */
     DCHECK(registry >= value);
     DCHECK(registry < value_end);
     return 0;
@@ -213,22 +259,28 @@ static size_t GetRegistryLengthImpl(
 
 size_t GetRegistryLength(const char* hostname) {
   const char* buf_end;
+  char* buf;
   size_t registry_length;
 
   if (IsValidHostname(hostname) == 0) {
     return 0;
   }
 
-  // Replace dots between hostname parts with the null byte. This
-  // allows us to index directly into the string and refer to each
-  // hostname-part as if it were its own null-terminated string.
-  char* buf = strdup(hostname);
+  /*
+   * Replace dots between hostname parts with the null byte. This
+   * allows us to index directly into the string and refer to each
+   * hostname-part as if it were its own null-terminated string.
+   */
+  buf = StrDup(hostname);
+  if (buf == NULL) {
+    return 0;
+  }
   ReplaceChar(buf, '.', '\0');
 
   buf_end = buf + strlen(hostname);
   DCHECK(*buf_end == 0);
 
-  // Normalize the input by converting all characters to lowercase.
+  /* Normalize the input by converting all characters to lowercase. */
   ToLowerASCII(buf, buf_end);
   registry_length = GetRegistryLengthImpl(buf, buf_end, '\0', 0);
   free(buf);
@@ -237,22 +289,28 @@ size_t GetRegistryLength(const char* hostname) {
 
 size_t GetRegistryLengthAllowUnknownRegistries(const char* hostname) {
   const char* buf_end;
+  char* buf;
   size_t registry_length;
 
   if (IsValidHostname(hostname) == 0) {
     return 0;
   }
 
-  // Replace dots between hostname parts with the null byte. This
-  // allows us to index directly into the string and refer to each
-  // hostname-part as if it were its own null-terminated string.
-  char* buf = strdup(hostname);
+  /*
+   * Replace dots between hostname parts with the null byte. This
+   * allows us to index directly into the string and refer to each
+   * hostname-part as if it were its own null-terminated string.
+   */
+  buf = StrDup(hostname);
+  if (buf == NULL) {
+    return 0;
+  }
   ReplaceChar(buf, '.', '\0');
 
   buf_end = buf + strlen(hostname);
   DCHECK(*buf_end == 0);
 
-  // Normalize the input by converting all characters to lowercase.
+  /* Normalize the input by converting all characters to lowercase. */
   ToLowerASCII(buf, buf_end);
   registry_length = GetRegistryLengthImpl(buf, buf_end, '\0', 1);
   free(buf);
index 68a1bd7..3fbda2c 100644 (file)
@@ -1,20 +1,22 @@
-// Copyright 2011 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #ifndef DOMAIN_REGISTRY_PRIVATE_REGISTRY_TYPES_H_
 #define DOMAIN_REGISTRY_PRIVATE_REGISTRY_TYPES_H_
 
 typedef unsigned short REGISTRY_U16;
 
-#endif  // DOMAIN_REGISTRY_PRIVATE_REGISTRY_TYPES_H_
+#endif  /* DOMAIN_REGISTRY_PRIVATE_REGISTRY_TYPES_H_ */
index d72f471..909f727 100644 (file)
@@ -1,16 +1,18 @@
-// Copyright 2011 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #ifndef DOMAIN_REGISTRY_PRIVATE_STRING_UTIL_H_
 #define DOMAIN_REGISTRY_PRIVATE_STRING_UTIL_H_
 static const char kUpperLowerDistance = 'A' - 'a';
 
 #if _WINDOWS
-#define inline __inline
+#define __inline__ __inline
 #endif
 
-static inline int IsWildcardComponent(const char* component) {
+static __inline__ int IsWildcardComponent(const char* component) {
   if (component[0] == '*') {
     return 1;
   }
   return 0;
 }
 
-static inline int IsExceptionComponent(const char* component) {
+static __inline__ int IsExceptionComponent(const char* component) {
   if (component[0] == '!') {
     return 1;
   }
   return 0;
 }
 
-static inline int IsInvalidComponent(const char* component) {
+static __inline__ int IsInvalidComponent(const char* component) {
   if (component == NULL ||
       component[0] == 0 ||
       IsExceptionComponent(component) ||
@@ -50,14 +52,14 @@ static inline int IsInvalidComponent(const char* component) {
   return 0;
 }
 
-static inline void ReplaceChar(char* value, char old, char newval) {
+static __inline__ void ReplaceChar(char* value, char old, char newval) {
   while ((value = strchr(value, old)) != NULL) {
     *value = newval;
     ++value;
   }
 }
 
-static inline void ToLowerASCII(char* buf, const char* end) {
+static __inline__ void ToLowerASCII(char* buf, const char* end) {
   for (; buf < end; ++buf) {
     char c = *buf;
     if (c >= 'A' && c <= 'Z') {
@@ -66,18 +68,22 @@ static inline void ToLowerASCII(char* buf, const char* end) {
   }
 }
 
-static inline int HostnamePartCmp(const char *a, const char *b) {
-  // Optimization: do not invoke strcmp() unless the first characters
-  // in each string match. Since we are performing a binary search, we
-  // expect most invocations to strcmp to not have matching arguments,
-  // and thus not invoke strcmp. This reduces overall runtime by 5-10%
-  // on a Linux laptop running a -O2 optimized build.
+static __inline__ int HostnamePartCmp(const char *a, const char *b) {
+  /*
+   * Optimization: do not invoke strcmp() unless the first characters
+   * in each string match. Since we are performing a binary search, we
+   * expect most invocations to strcmp to not have matching arguments,
+   * and thus not invoke strcmp. This reduces overall runtime by 5-10%
+   * on a Linux laptop running a -O2 optimized build.
+   */
   int ret = *(unsigned char *)a - *(unsigned char *)b;
-  // NOTE: we could invoke strcmp on a+1,b+1 if we are
-  // certain that neither a nor b are the empty string. For now we
-  // take the more conservative approach.
+  /*
+   * NOTE: we could invoke strcmp on a+1,b+1 if we are
+   * certain that neither a nor b are the empty string. For now we
+   * take the more conservative approach.
+   */
   if (ret == 0) return strcmp(a, b);
   return ret;
 }
 
-#endif  // DOMAIN_REGISTRY_PRIVATE_STRING_UTIL_H_
+#endif  /* DOMAIN_REGISTRY_PRIVATE_STRING_UTIL_H_ */
index 4f2fc67..962a3c4 100644 (file)
@@ -1,16 +1,18 @@
-// Copyright 2011 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #ifndef DOMAIN_REGISTRY_PRIVATE_TRIE_NODE_H_
 #define DOMAIN_REGISTRY_PRIVATE_TRIE_NODE_H_
 #pragma pack(push)
 #pragma pack(1)
 
-// TrieNode represents a single node in a Trie. It uses 5 bytes of
-// storage.
+/*
+ * TrieNode represents a single node in a Trie. It uses 5 bytes of
+ * storage.
+ */
 struct TrieNode {
-  // Index in the string table for the hostname-part associated with
-  // this node.
+  /*
+   * Index in the string table for the hostname-part associated with
+   * this node.
+   */
   unsigned int string_table_offset  : 15;
 
-  // Offset of the first child of this node in the node table. All
-  // children are stored adjacent to each other, sorted
-  // lexicographically by their hostname parts.
+  /*
+   * Offset of the first child of this node in the node table. All
+   * children are stored adjacent to each other, sorted
+   * lexicographically by their hostname parts.
+   */
   unsigned int first_child_offset   : 13;
 
-  // Number of children of this node.
+  /*
+   * Number of children of this node.
+   */
   unsigned int num_children         : 11;
 
-  // Whether this node is a "terminal" node. A terminal node is one
-  // that represents the end of a sequence of nodes in the trie. For
-  // instance if the sequences "com.foo.bar" and "com.foo" are added
-  // to the trie, "bar" and "foo" are terminal nodes, since they are
-  // both at the end of their sequences.
+  /*
+   * Whether this node is a "terminal" node. A terminal node is one
+   * that represents the end of a sequence of nodes in the trie. For
+   * instance if the sequences "com.foo.bar" and "com.foo" are added
+   * to the trie, "bar" and "foo" are terminal nodes, since they are
+   * both at the end of their sequences.
+   */
   unsigned int is_terminal          :  1;
 };
 
 #pragma pack(pop)
 
-#endif  // DOMAIN_REGISTRY_PRIVATE_TRIE_NODE_H_
+#endif  /* DOMAIN_REGISTRY_PRIVATE_TRIE_NODE_H_ */
index 3cc6c3a..0196997 100644 (file)
@@ -1,16 +1,18 @@
-// Copyright 2011 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #include "domain_registry/private/assert.h"
 #include "domain_registry/private/string_util.h"
 #include <stdlib.h>
 #include <string.h>
 
-// Helper macro that chooses the node half-way between the start and
-// end nodes. Used for binary search.
+/*
+ * Helper macro that chooses the node half-way between the start and
+ * end nodes. Used for binary search.
+ */
 #define MIDDLE(start, end) ((start) + ((((end) - (start)) + 1) / 2));
 
-// Global data structures used to perform the search. Should be
-// populated once at startup by a call to SetRegistryTables.
+/*
+ * Global data structures used to perform the search. Should be
+ * populated once at startup by a call to SetRegistryTables.
+ */
 static const char* g_string_table = NULL;
 static const struct TrieNode* g_node_table = NULL;
 static size_t g_num_root_children = 0;
 static const REGISTRY_U16* g_leaf_node_table = NULL;
 static size_t g_leaf_node_table_offset = 0;
 
-// Create an "exception" version of the given component. For instance
-// if component is "foo", will return "!foo". The caller is
-// responsible for freeing the returned memory.
+/*
+ * Create an "exception" version of the given component. For instance
+ * if component is "foo", will return "!foo". The caller is
+ * responsible for freeing the returned memory.
+ */
 static char* StrDupExceptionComponent(const char* component) {
-  // TODO(bmcquade): could use thread-local storage of sufficient size
-  // to avoid this allocation. This should be invoked infrequently
-  // enough that it's probably fine for us to perform the allocation.
+  /*
+   * TODO(bmcquade): could use thread-local storage of sufficient size
+   * to avoid this allocation. This should be invoked infrequently
+   * enough that it's probably fine for us to perform the allocation.
+   */
   const size_t component_len = strlen(component);
   char* exception_component = malloc(component_len + 2);
+  if (exception_component == NULL) {
+    return NULL;
+  }
   memcpy(exception_component + 1, component, component_len);
   exception_component[0] = '!';
   exception_component[component_len + 1] = 0;
   return exception_component;
 }
 
-// Performs a binary search looking for value, between the nodes start
-// and end, inclusive. Would normally have static linkage but is made
-// public for testing.
+/*
+ * Performs a binary search looking for value, between the nodes start
+ * and end, inclusive. Would normally have static linkage but is made
+ * public for testing.
+ */
 const struct TrieNode* FindNodeInRange(
     const char* value,
     const struct TrieNode* start,
@@ -77,9 +92,11 @@ const struct TrieNode* FindNodeInRange(
   }
 }
 
-// Performs a binary search looking for value, between the nodes start
-// and end, inclusive. Would normally have static linkage but is made
-// public for testing.
+/*
+ * Performs a binary search looking for value, between the nodes start
+ * and end, inclusive. Would normally have static linkage but is made
+ * public for testing.
+ */
 const char* FindLeafNodeInRange(
     const char* value,
     const REGISTRY_U16* start,
@@ -107,14 +124,17 @@ const char* FindLeafNodeInRange(
   }
 }
 
-// Searches to find a registry node with the given component
-// identifier and the given parent node. If parent is null, searches
-// starting from the root node.
+/*
+ * Searches to find a registry node with the given component
+ * identifier and the given parent node. If parent is null, searches
+ * starting from the root node.
+ */
 const struct TrieNode* FindRegistryNode(const char* component,
                                         const struct TrieNode* parent) {
   const struct TrieNode* start;
   const struct TrieNode* end;
   const struct TrieNode* current;
+  const struct TrieNode* exception;
 
   DCHECK(g_string_table != NULL);
   DCHECK(g_node_table != NULL);
@@ -125,46 +145,55 @@ const struct TrieNode* FindRegistryNode(const char* component,
     return NULL;
   }
   if (parent == NULL) {
-    // If parent is NULL, start the search at the root node.
+    /* If parent is NULL, start the search at the root node. */
     start = g_node_table;
     end = start + (g_num_root_children - 1);
   } else {
     if (HasLeafChildren(parent) != 0) {
-      // If the parent has leaf children, FindRegistryLeafNode should
-      // have been called instead.
+      /*
+       * If the parent has leaf children, FindRegistryLeafNode should
+       * have been called instead.
+       */
       DCHECK(0);
       return NULL;
     }
 
-    // We'll be searching the specified parent node's children.
+    /* We'll be searching the specified parent node's children. */
     start = g_node_table + parent->first_child_offset;
     end = start + (parent->num_children - 1);
   }
   current = FindNodeInRange(component, start, end);
   if (current != NULL) {
-    // Found a match. Return it.
+    /* Found a match. Return it. */
     return current;
   }
 
-  // We didn't find an exact match, so see if there's a wildcard
-  // match. From http://publicsuffix.org/format/: "The wildcard
-  // character * (asterisk) matches any valid sequence of characters
-  // in a hostname part. (Note: the list uses Unicode, not Punycode
-  // forms, and is encoded using UTF-8.) Wildcards may only be used to
-  // wildcard an entire level. That is, they must be surrounded by
-  // dots (or implicit dots, at the beginning of a line)."
+  /*
+   * We didn't find an exact match, so see if there's a wildcard
+   * match. From http://publicsuffix.org/format/: "The wildcard
+   * character * (asterisk) matches any valid sequence of characters
+   * in a hostname part. (Note: the list uses Unicode, not Punycode
+   * forms, and is encoded using UTF-8.) Wildcards may only be used to
+   * wildcard an entire level. That is, they must be surrounded by
+   * dots (or implicit dots, at the beginning of a line)."
+   */
   current = FindNodeInRange("*", start, end);
   if (current != NULL) {
-    // If there was a wildcard match, see if there is a wildcard
-    // exception match, and prefer it if so. From
-    // http://publicsuffix.org/format/: "An exclamation mark (!) at
-    // the start of a rule marks an exception to a previous wildcard
-    // rule. An exception rule takes priority over any other matching
-    // rule.".
+    /*
+     * If there was a wildcard match, see if there is a wildcard
+     * exception match, and prefer it if so. From
+     * http://publicsuffix.org/format/: "An exclamation mark (!) at
+     * the start of a rule marks an exception to a previous wildcard
+     * rule. An exception rule takes priority over any other matching
+     * rule.".
+     */
     char* exception_component = StrDupExceptionComponent(component);
-    const struct TrieNode* exception = FindNodeInRange(exception_component,
-                                                       start,
-                                                       end);
+    if (exception_component == NULL) {
+      return NULL;
+    }
+    exception = FindNodeInRange(exception_component,
+                                start,
+                                end);
     free(exception_component);
     if (exception != NULL) {
       current = exception;
@@ -179,6 +208,7 @@ const char* FindRegistryLeafNode(const char* component,
   const REGISTRY_U16* leaf_start;
   const REGISTRY_U16* leaf_end;
   const char* match;
+  const char* exception;
 
   DCHECK(g_string_table != NULL);
   DCHECK(g_node_table != NULL);
@@ -207,25 +237,32 @@ const char* FindRegistryLeafNode(const char* component,
     return match;
   }
 
-  // We didn't find an exact match, so see if there's a wildcard
-  // match. From http://publicsuffix.org/format/: "The wildcard
-  // character * (asterisk) matches any valid sequence of characters
-  // in a hostname part. (Note: the list uses Unicode, not Punycode
-  // forms, and is encoded using UTF-8.) Wildcards may only be used to
-  // wildcard an entire level. That is, they must be surrounded by
-  // dots (or implicit dots, at the beginning of a line)."
+  /*
+   * We didn't find an exact match, so see if there's a wildcard
+   * match. From http://publicsuffix.org/format/: "The wildcard
+   * character * (asterisk) matches any valid sequence of characters
+   * in a hostname part. (Note: the list uses Unicode, not Punycode
+   * forms, and is encoded using UTF-8.) Wildcards may only be used to
+   * wildcard an entire level. That is, they must be surrounded by
+   * dots (or implicit dots, at the beginning of a line)."
+   */
   match = FindLeafNodeInRange("*", leaf_start, leaf_end);
   if (match != NULL) {
-    // There was a wildcard match, so see if there is a wildcard
-    // exception match, and prefer it if so. From
-    // http://publicsuffix.org/format/: "An exclamation mark (!) at
-    // the start of a rule marks an exception to a previous wildcard
-    // rule. An exception rule takes priority over any other matching
-    // rule.".
+    /*
+     * There was a wildcard match, so see if there is a wildcard
+     * exception match, and prefer it if so. From
+     * http://publicsuffix.org/format/: "An exclamation mark (!) at
+     * the start of a rule marks an exception to a previous wildcard
+     * rule. An exception rule takes priority over any other matching
+     * rule.".
+     */
     char* exception_component = StrDupExceptionComponent(component);
-    const char* exception = FindLeafNodeInRange(exception_component,
-                                                leaf_start,
-                                                leaf_end);
+    if (exception_component == NULL) {
+      return NULL;
+    }
+    exception = FindLeafNodeInRange(exception_component,
+                                    leaf_start,
+                                    leaf_end);
     free(exception_component);
     if (exception != NULL) {
       match = exception;
index 0135b60..813d9f7 100644 (file)
@@ -1,19 +1,21 @@
-// Copyright 2011 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Functions to search the registry tables. These should not
-// need to be invoked directly.
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Functions to search the registry tables. These should not
+ * need to be invoked directly.
+ */
 
 #ifndef DOMAIN_REGISTRY_PRIVATE_TRIE_SEARCH_H_
 #define DOMAIN_REGISTRY_PRIVATE_TRIE_SEARCH_H_
 #include "domain_registry/private/registry_types.h"
 #include "domain_registry/private/trie_node.h"
 
-// Find a TrieNode under the given parent node with the specified
-// name. If parent is NULL then the search is performed at the root
-// TrieNode.
+/*
+ * Find a TrieNode under the given parent node with the specified
+ * name. If parent is NULL then the search is performed at the root
+ * TrieNode.
+ */
 const struct TrieNode* FindRegistryNode(const char* component,
                                         const struct TrieNode* parent);
 
-// Find a leaf TrieNode under the given parent node with the specified
-// name. If parent does not have all leaf children (i.e. if
-// HasLeafChildren(parent) returns zero), will assert and return
-// NULL. If parent is NULL then the search is performed at the root
-// TrieNode.
+/*
+ * Find a leaf TrieNode under the given parent node with the specified
+ * name. If parent does not have all leaf children (i.e. if
+ * HasLeafChildren(parent) returns zero), will assert and return
+ * NULL. If parent is NULL then the search is performed at the root
+ * TrieNode.
+ */
 const char* FindRegistryLeafNode(const char* component,
                                  const struct TrieNode* parent);
 
-// Get the hostname part for the given string table offset.
+/* Get the hostname part for the given string table offset. */
 const char* GetHostnamePart(size_t offset);
 
-// Does the given node have all leaf children?
+/* Does the given node have all leaf children? */
 int HasLeafChildren(const struct TrieNode* node);
 
-// Initialize the registry tables. Called at system startup by
-// InitializeDomainRegistry().
+/*
+ * Initialize the registry tables. Called at system startup by
+ * InitializeDomainRegistry().
+ */
 void SetRegistryTables(const char* string_table,
                        const struct TrieNode* node_table,
                        size_t num_root_children,
                        const REGISTRY_U16* leaf_node_table,
                        size_t leaf_node_table_offset);
 
-#endif  // DOMAIN_REGISTRY_PRIVATE_TRIE_SEARCH_H_
+#endif  /* DOMAIN_REGISTRY_PRIVATE_TRIE_SEARCH_H_ */
index d490b10..dba935a 100755 (executable)
@@ -203,13 +203,13 @@ def RegistryTablesGenerator(in_file, out_file, out_test_file):
                                                 child_node_offset_bits = 13,
                                                 num_children_bits = 11)
 
-  out_file.write('// Size of kStringTable %d\n' %
+  out_file.write('/* Size of kStringTable %d */\n' %
                  len(string_table.GetStringTable()))
-  out_file.write('// Size of kNodeTable %d\n' %
+  out_file.write('/* Size of kNodeTable %d */\n' %
                  len(node_table.GetNodeTable()))
-  out_file.write('// Size of kLeafNodeTable %d\n' %
+  out_file.write('/* Size of kLeafNodeTable %d */\n' %
                  len(node_table.GetLeafNodeTable()))
-  out_file.write('// Total size %d bytes\n' % (
+  out_file.write('/* Total size %d bytes */\n' % (
       # Each entry in the string table is a char (1 byte).
       len(string_table.GetStringTable()) +
       # Each entry in the node table is 5 bytes:
index 9b00d0e..fa35cb6 100644 (file)
@@ -63,11 +63,12 @@ class TableSerializer(object):
           raise OverflowError(
               'Values %d %d %d out of range.' %
               (component_offset, child_node_offset, num_children))
-      out.append(r'  { %5d, %5d, %5d, %d },  // %s' % (component_offset,
-                                                       child_node_offset,
-                                                       num_children,
-                                                       is_root,
-                                                       node.GetIdentifier('.')))
+      out.append(r'  { %5d, %5d, %5d, %d },  /* %s */' % (
+          component_offset,
+          child_node_offset,
+          num_children,
+          is_root,
+          node.GetIdentifier('.')))
     return '\n'.join(out)
 
   def SerializeLeafChildNodeTable(self,
@@ -86,7 +87,8 @@ class TableSerializer(object):
       if component_offset > self.max_component_offset:
           raise OverflowError(
               'component_offset %d out of range.' % component_offset)
-      out.append(r'%5d,  // %s' % (component_offset, node.GetIdentifier('.')))
+      out.append(r'%5d,  /* %s */' % (
+          component_offset, node.GetIdentifier('.')))
     return '\n'.join(out)
 
   @staticmethod