protobuf/php/ext/google/protobuf/names.c

// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.  All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd

#include "names.h"

#include <stdlib.h>

#include "protobuf.h"

/* stringsink *****************************************************************/

typedef struct {
  char* ptr;
  size_t len, size;
} stringsink;

static size_t stringsink_string(stringsink* sink, const char* ptr, size_t len) {
  size_t new_size = sink->size;

  while (sink->len + len > new_size) {
    new_size *= 2;
  }

  if (new_size != sink->size) {
    sink->ptr = realloc(sink->ptr, new_size);
    sink->size = new_size;
  }

  memcpy(sink->ptr + sink->len, ptr, len);
  sink->len += len;

  return len;
}

static void stringsink_init(stringsink* sink) {
  sink->size = 32;
  sink->ptr = malloc(sink->size);
  PBPHP_ASSERT(sink->ptr != NULL);
  sink->len = 0;
}

static void stringsink_uninit(stringsink* sink) { free(sink->ptr); }

/* def name -> classname ******************************************************/

const char* const kReservedNames[] = {
    "abstract",   "and",        "array",      "as",           "break",
    "callable",   "case",       "catch",      "class",        "clone",
    "const",      "continue",   "declare",    "default",      "die",
    "do",         "echo",       "else",       "elseif",       "empty",
    "enddeclare", "endfor",     "endforeach", "endif",        "endswitch",
    "endwhile",   "eval",       "exit",       "extends",      "final",
    "finally",    "fn",         "for",        "foreach",      "function",
    "if",         "implements", "include",    "include_once", "instanceof",
    "global",     "goto",       "insteadof",  "interface",    "isset",
    "list",       "match",      "namespace",  "new",          "object",
    "or",         "parent",     "print",      "private",      "protected",
    "public",     "readonly",   "require",    "require_once", "return",
    "self",       "static",     "switch",     "throw",        "trait",
    "try",        "unset",      "use",        "var",          "while",
    "xor",        "yield",      "int",        "float",        "bool",
    "string",     "true",       "false",      "null",         "void",
    "iterable",   NULL};

const char* const kPreviouslyUnreservedNames[] = {"readonly", NULL};

bool is_reserved_name(const char* name) {
  int i;
  for (i = 0; kReservedNames[i]; i++) {
    if (strcmp(kReservedNames[i], name) == 0) {
      return true;
    }
  }
  return false;
}

bool is_previously_unreserved_name(const char* name) {
  for (int i = 0; kPreviouslyUnreservedNames[i]; i++) {
    if (strcmp(kPreviouslyUnreservedNames[i], name) == 0) {
      return true;
    }
  }
  return false;
}

static char nolocale_tolower(char ch) {
  if (ch >= 'A' && ch <= 'Z') {
    return ch - ('A' - 'a');
  } else {
    return ch;
  }
}

static char nolocale_toupper(char ch) {
  if (ch >= 'a' && ch <= 'z') {
    return ch - ('a' - 'A');
  } else {
    return ch;
  }
}

static char* strdup_nolocale_lower(const char* str, int length) {
  char* lower = malloc(length + 1);
  lower[length] = '\0';
  for (int i = 0; i < length; ++i) {
    lower[i] = nolocale_tolower(str[i]);
  }
  return lower;
}

static bool is_reserved(const char* segment, int length, bool previous) {
  bool result;
  char* lower = strdup_nolocale_lower(segment, length);
  result = is_reserved_name(lower);
  if (result && previous && is_previously_unreserved_name(lower)) {
    result = false;
  }
  free(lower);
  return result;
}

static void fill_prefix(const char* segment, int length,
                        const char* prefix_given, const char* package_name,
                        stringsink* classname, bool previous) {
  if (prefix_given != NULL && strcmp(prefix_given, "") != 0) {
    stringsink_string(classname, prefix_given, strlen(prefix_given));
  } else {
    if (is_reserved(segment, length, previous)) {
      if (package_name != NULL &&
          strcmp("google.protobuf", package_name) == 0) {
        stringsink_string(classname, "GPB", 3);
      } else {
        stringsink_string(classname, "PB", 2);
      }
    }
  }
}

static void fill_segment(const char* segment, int length, stringsink* classname,
                         bool use_camel) {
  if (use_camel && (segment[0] < 'A' || segment[0] > 'Z')) {
    char first = nolocale_toupper(segment[0]);
    stringsink_string(classname, &first, 1);
    stringsink_string(classname, segment + 1, length - 1);
  } else {
    stringsink_string(classname, segment, length);
  }
}

static void fill_namespace(const char* package, const char* php_namespace,
                           stringsink* classname, bool previous) {
  if (php_namespace != NULL) {
    if (strlen(php_namespace) != 0) {
      stringsink_string(classname, php_namespace, strlen(php_namespace));
      stringsink_string(classname, "\\", 1);
    }
  } else if (package != NULL) {
    int i = 0, j = 0;
    size_t package_len = strlen(package);
    while (i < package_len) {
      j = i;
      while (j < package_len && package[j] != '.') {
        j++;
      }
      fill_prefix(package + i, j - i, "", package, classname, previous);
      fill_segment(package + i, j - i, classname, true);
      stringsink_string(classname, "\\", 1);
      i = j + 1;
    }
  }
}

static void fill_classname(const char* fullname, const char* package,
                           const char* prefix, stringsink* classname,
                           bool previous) {
  int classname_start = 0;
  if (package != NULL) {
    size_t package_len = strlen(package);
    classname_start = package_len == 0 ? 0 : package_len + 1;
  }
  size_t fullname_len = strlen(fullname);

  int i = classname_start, j;
  while (i < fullname_len) {
    j = i;
    while (j < fullname_len && fullname[j] != '.') {
      j++;
    }
    fill_prefix(fullname + i, j - i, prefix, package, classname, previous);
    fill_segment(fullname + i, j - i, classname, false);
    if (j != fullname_len) {
      stringsink_string(classname, "\\", 1);
    }
    i = j + 1;
  }
}

char* str_view_dup(upb_StringView str) {
  char* ret = malloc(str.size + 1);
  memcpy(ret, str.data, str.size);
  ret[str.size] = '\0';
  return ret;
}

char* GetPhpClassname(const upb_FileDef* file, const char* fullname,
                      bool previous) {
  // Prepend '.' to package name to make it absolute. In the 5 additional
  // bytes allocated, one for '.', one for trailing 0, and 3 for 'GPB' if
  // given message is google.protobuf.Empty.
  const google_protobuf_FileOptions* opts = upb_FileDef_Options(file);
  const char* package = upb_FileDef_Package(file);
  char* php_namespace =
      google_protobuf_FileOptions_has_php_namespace(opts)
          ? str_view_dup(google_protobuf_FileOptions_php_namespace(opts))
          : NULL;
  char* prefix =
      google_protobuf_FileOptions_has_php_class_prefix(opts)
          ? str_view_dup(google_protobuf_FileOptions_php_class_prefix(opts))
          : NULL;
  char* ret;

  stringsink namesink;
  stringsink_init(&namesink);

  fill_namespace(package, php_namespace, &namesink, previous);
  fill_classname(fullname, package, prefix, &namesink, previous);
  stringsink_string(&namesink, "\0", 1);
  ret = strdup(namesink.ptr);
  stringsink_uninit(&namesink);
  free(php_namespace);
  free(prefix);
  return ret;
}

bool IsPreviouslyUnreservedClassName(const char* fullname) {
  const char* classname = strrchr(fullname, '\\');
  if (classname) {
    classname += 1;
  } else {
    classname = fullname;
  }
  if (strncmp(classname, "PB", 2) != 0) {
    return false;
  }
  classname += 2;
  int length = strlen(classname);
  char* lower = strdup_nolocale_lower(classname, length);
  for (int j = 0; kPreviouslyUnreservedNames[j]; j++) {
    if (strcmp(kPreviouslyUnreservedNames[j], lower) == 0) {
      free(lower);
      return true;
    }
  }
  free(lower);
  return false;
}