VM: Re-format to use at most one newline between functions

runtime/vm/uri.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/uri.h"
 
 #include "vm/zone.h"
 
 namespace dart {
 
 static bool IsUnreservedChar(intptr_t value) {
   return ((value >= 'a' && value <= 'z') || (value >= 'A' && value <= 'Z') ||
           (value >= '0' && value <= '9') || value == '-' || value == '.' ||
           value == '_' || value == '~');
 }
 
-
 static bool IsDelimiter(intptr_t value) {
   switch (value) {
     case ':':
     case '/':
     case '?':
     case '#':
     case '[':
     case ']':
     case '@':
     case '!':
     case '$':
     case '&':
     case '\'':
     case '(':
     case ')':
     case '*':
     case '+':
     case ',':
     case ';':
     case '=':
       return true;
     default:
       return false;
   }
 }
 
-
 static bool IsHexDigit(char value) {
   return ((value >= '0' && value <= '9') || (value >= 'A' && value <= 'F') ||
           (value >= 'a' && value <= 'f'));
 }
 
-
 static int HexValue(char digit) {
   if ((digit >= '0' && digit <= '9')) {
     return digit - '0';
   }
   if ((digit >= 'A' && digit <= 'F')) {
     return digit - 'A' + 10;
   }
   if ((digit >= 'a' && digit <= 'f')) {
     return digit - 'a' + 10;
   }
   UNREACHABLE();
   return 0;
 }
 
-
 static int GetEscapedValue(const char* str, intptr_t pos, intptr_t len) {
   if (pos + 2 >= len) {
     // Not enough room for a valid escape sequence.
     return -1;
   }
   if (str[pos] != '%') {
     // Escape sequences start with '%'.
     return -1;
   }
 
   char digit1 = str[pos + 1];
   char digit2 = str[pos + 2];
   if (!IsHexDigit(digit1) || !IsHexDigit(digit2)) {
     // Invalid escape sequence.  Ignore it.
     return -1;
   }
   return HexValue(digit1) * 16 + HexValue(digit2);
 }
 
-
 static char* NormalizeEscapes(const char* str, intptr_t len) {
   // Allocate the buffer.
   Zone* zone = Thread::Current()->zone();
   // We multiply len by three because a percent-escape sequence is
   // three characters long (e.g. ' ' -> '%20).  +1 for '\0'.  We could
   // take two passes through the string and avoid the excess
   // allocation, but it's zone-memory so it doesn't seem necessary.
   char* buffer = zone->Alloc<char>(len * 3 + 1);
 
   // Copy the string, normalizing as we go.
@@ skipping 26 matching lines @@
         OS::SNPrint(buffer + buffer_pos, 4, "%%%02X", c);
         buffer_pos += 3;
       }
       pos++;
     }
   }
   buffer[buffer_pos] = '\0';
   return buffer;
 }
 
-
 // Lower-case a string in place.
 static void StringLower(char* str) {
   const intptr_t len = strlen(str);
   intptr_t i = 0;
   while (i < len) {
     int escaped_value = GetEscapedValue(str, i, len);
     if (escaped_value >= 0) {
       // Don't lowercase escape sequences.
       i += 3;
     } else {
       // I don't use tolower() because I don't want the locale
       // transforming any non-acii characters.
       char c = str[i];
       if (c >= 'A' && c <= 'Z') {
         str[i] = c + ('a' - 'A');
       }
       i++;
     }
   }
 }
 
-
 static void ClearParsedUri(ParsedUri* parsed_uri) {
   parsed_uri->scheme = NULL;
   parsed_uri->userinfo = NULL;
   parsed_uri->host = NULL;
   parsed_uri->port = NULL;
   parsed_uri->path = NULL;
   parsed_uri->query = NULL;
   parsed_uri->fragment = NULL;
 }
 
-
 static intptr_t ParseAuthority(const char* authority, ParsedUri* parsed_uri) {
   Zone* zone = Thread::Current()->zone();
   const char* current = authority;
   intptr_t len = 0;
 
   size_t userinfo_len = strcspn(current, "@/");
   if (current[userinfo_len] == '@') {
     // The '@' character follows the optional userinfo string.
     parsed_uri->userinfo = NormalizeEscapes(current, userinfo_len);
     current += userinfo_len + 1;
@@ skipping 13 matching lines @@
     const char* port_start = current + host_len + 1;  // +1 for ':'
     size_t port_len = strcspn(port_start, "/");
     parsed_uri->port = zone->MakeCopyOfStringN(port_start, port_len);
     len += 1 + port_len;  // +1 for ':'
   } else {
     parsed_uri->port = NULL;
   }
   return len;
 }
 
-
 // Performs a simple parse of a uri into its components.
 // See RFC 3986 Section 3: Syntax.
 bool ParseUri(const char* uri, ParsedUri* parsed_uri) {
   Zone* zone = Thread::Current()->zone();
 
   // The first ':' separates the scheme from the rest of the uri.  If
   // a ':' occurs after the first '/' it doesn't count.
   size_t scheme_len = strcspn(uri, ":/");
   const char* rest = uri;
   if (uri[scheme_len] == ':') {
@@ skipping 42 matching lines @@
     parsed_uri->userinfo = NULL;
     parsed_uri->host = NULL;
     parsed_uri->port = NULL;
   }
 
   // The path is the substring between the authority and the query.
   parsed_uri->path = NormalizeEscapes(path_start, (question_pos - path_start));
   return true;
 }
 
-
 static char* RemoveLastSegment(char* current, char* base) {
   if (current == base) {
     return current;
   }
   ASSERT(current > base);
   for (current--; current > base; current--) {
     if (*current == '/') {
       // We have found the beginning of the last segment.
       return current;
     }
   }
   ASSERT(current == base);
   return current;
 }
 
-
 static intptr_t SegmentLength(const char* input) {
   const char* cp = input;
 
   // Include initial slash in the segment, if any.
   if (*cp == '/') {
     cp++;
   }
 
   // Don't include trailing slash in the segment.
   cp += strcspn(cp, "/");
   return cp - input;
 }
 
-
 // See RFC 3986 Section 5.2.4: Remove Dot Segments.
 static const char* RemoveDotSegments(const char* path) {
   const char* input = path;
 
   // The output path will always be less than or equal to the size of
   // the input path.
   Zone* zone = Thread::Current()->zone();
   char* buffer = zone->Alloc<char>(strlen(path) + 1);  // +1 for '\0'
   char* output = buffer;
 
@@ skipping 42 matching lines @@
       }
       strncpy(output, input, segment_len);
       output += segment_len;
       input += segment_len;
     }
   }
   *output = '\0';
   return buffer;
 }
 
-
 // See RFC 3986 Section 5.2.3: Merge Paths.
 static const char* MergePaths(const char* base_path, const char* ref_path) {
   Zone* zone = Thread::Current()->zone();
   if (base_path[0] == '\0') {
     // If the base_path is empty, we prepend '/'.
     return zone->PrintToString("/%s", ref_path);
   }
 
   // We need to find the last '/' in base_path.
   const char* last_slash = strrchr(base_path, '/');
@@ skipping 17 matching lines @@
 
   // Copy the ref_path.
   strncpy((buffer + truncated_base_len + 1), ref_path, ref_path_len);
 
   // Add the trailing '\0'.
   buffer[len] = '\0';
 
   return buffer;
 }
 
-
 static char* BuildUri(const ParsedUri& uri) {
   Zone* zone = Thread::Current()->zone();
   ASSERT(uri.path != NULL);
 
   const char* fragment = uri.fragment == NULL ? "" : uri.fragment;
   const char* fragment_separator = uri.fragment == NULL ? "" : "#";
   const char* query = uri.query == NULL ? "" : uri.query;
   const char* query_separator = uri.query == NULL ? "" : "?";
 
   // If there is no scheme for this uri, just build a relative uri of
@@ skipping 25 matching lines @@
 
   // Uri with authority:
   //   "scheme://[userinfo@]host[:port][/]path[?query][#fragment]"
   return zone->PrintToString(
       "%s://%s%s%s%s%s%s%s%s%s%s%s",  // There is *nothing* wrong with this.
       uri.scheme, user, user_separator, uri.host, port_separator, port,
       path_separator, uri.path, query_separator, query, fragment_separator,
       fragment);
 }
 
-
 // See RFC 3986 Section 5: Reference Resolution
 bool ResolveUri(const char* ref_uri,
                 const char* base_uri,
                 const char** target_uri) {
   // Parse the reference uri.
   ParsedUri ref;
   if (!ParseUri(ref_uri, &ref)) {
     *target_uri = NULL;
     return false;
   }
@@ skipping 87 matching lines @@
     target.port = base.port;
     target.path = RemoveDotSegments(MergePaths(base.path, ref.path));
     target.query = ref.query;
     target.fragment = ref.fragment;
     *target_uri = BuildUri(target);
     return true;
   }
 }
 
 }  // namespace dart