DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Mercurial (4a108e94d3e2)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
#!/usr/bin/env python

# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

# This script generates nsStyleStructList.h, which contains macro invocations
# that can be used for three things:
#
# 1. To generate code for each inherited style struct.
# 2. To generate code for each reset style struct.
# 3. To generate a tree of nested if statements that can be used to run
#    some code on each style struct.
#
# As an example, if we assume that we have only four style structs, the
# generated tree of nested if statements looks like this:
#
#   if (STYLE_STRUCT_TEST < 4) {
#     if (STYLE_STRUCT_TEST < 2) {
#       if (STYLE_STRUCT_TEST == 0) {
#         ... code for style struct with id 0 ...
#       } else {
#         ... code for style struct with id 1 ...
#       }
#     } else {
#       if (STYLE_STRUCT_TEST == 2) {
#         ... code for style struct with id 2 ...
#       } else {
#         ... code for style struct with id 3 ...
#       }
#     }
#   }
#
# The TOPLEVELBRANCHES variable controls how widely we branch on the outermost
# if statement.  In the example above, it splits the search space in 2, but with
# a larger number of style structs to test -- particularly when the number is
# closer to one power of two than the next higher one -- the average number of
# comparisons can be reduced by splitting the top level check into more than 2.

from __future__ import print_function

import math

NORMAL_DEP = ["Variables"]
COLOR_DEP = ["Color"]
LENGTH_DEP = ["Font", "Visibility"]

# List of style structs and their corresponding Check callback functions,
# if any.
STYLE_STRUCTS = [("INHERITED",) + x for x in [
    # Inherited style structs.
    ("Font",           "CheckFontCallback",     NORMAL_DEP + ["Visibility"]),
    ("Color",          "CheckColorCallback",    NORMAL_DEP),
    ("List",           "nullptr",               NORMAL_DEP + LENGTH_DEP),
    ("Text",           "CheckTextCallback",     NORMAL_DEP + LENGTH_DEP + COLOR_DEP),
    ("Visibility",     "nullptr",               NORMAL_DEP),
    ("Quotes",         "nullptr",               NORMAL_DEP),
    ("UserInterface",  "nullptr",               NORMAL_DEP),
    ("TableBorder",    "nullptr",               NORMAL_DEP + LENGTH_DEP),
    ("SVG",            "nullptr",               NORMAL_DEP + LENGTH_DEP + COLOR_DEP),
    ("Variables",      "CheckVariablesCallback",[]),
]] + [("RESET",) + x for x in [
    # Reset style structs.
    ("Background",     "nullptr",   NORMAL_DEP + LENGTH_DEP + COLOR_DEP),
    ("Position",       "nullptr",   NORMAL_DEP + LENGTH_DEP),
    ("TextReset",      "nullptr",   NORMAL_DEP + LENGTH_DEP + COLOR_DEP),
    ("Display",        "nullptr",   NORMAL_DEP + LENGTH_DEP),
    ("Content",        "nullptr",   NORMAL_DEP + LENGTH_DEP),
    ("UIReset",        "nullptr",   NORMAL_DEP),
    ("Table",          "nullptr",   NORMAL_DEP),
    ("Margin",         "nullptr",   NORMAL_DEP + LENGTH_DEP),
    ("Padding",        "nullptr",   NORMAL_DEP + LENGTH_DEP),
    ("Border",         "nullptr",   NORMAL_DEP + LENGTH_DEP + COLOR_DEP),
    ("Outline",        "nullptr",   NORMAL_DEP + LENGTH_DEP + COLOR_DEP),
    ("XUL",            "nullptr",   NORMAL_DEP),
    ("SVGReset",       "nullptr",   NORMAL_DEP + LENGTH_DEP + COLOR_DEP),
    ("Column",         "nullptr",   NORMAL_DEP + LENGTH_DEP + COLOR_DEP),
]]

# How widely to branch on the outermost if statement.
TOPLEVELBRANCHES = 4


# ---- Generate nsStyleStructList.h ----

count = len(STYLE_STRUCTS)

# Check for problems with style struct dependencies
resolved_items = []
# This whole loop tries to sort the style structs in topological order
# according to the dependencies. A topological order exists iff there
# are no cyclic dependencies between the style structs. It resolves one
# struct each iteration, and append the resolved one to |resolved_items|.
for i in range(count):
    # This inner loop picks one style struct which does not have
    # unsolved dependencies. If nothing can be picked, then we
    # must have some cyclic dependencies.
    for j in range(count):
        _, name, _, dependencies = STYLE_STRUCTS[j]
        if name in resolved_items:
            continue
        # Check whether all dependencies of this item have been placed
        for dep in dependencies:
            if dep not in resolved_items:
                break
        else:
            resolved_items.append(name)
            break
    else:
        import sys
        print("ERROR: Cannot resolve style struct dependencies", file=sys.stderr)
        print("Resolved items:", " ".join(resolved_items), file=sys.stderr)
        unsolved_items = [name for _, name, _, _ in STYLE_STRUCTS
                          if name not in resolved_items]
        print("There exist cyclic dependencies between " +
                  "the following structs:", " ".join(unsolved_items), file=sys.stderr)
        exit(1)

def nextPowerOf2(x):
    return int(pow(2, math.ceil(math.log(x, 2))))

def printEntry(header, i):
    print("STYLE_STRUCT_%s(%s, %s)" % STYLE_STRUCTS[i][:3], file=header)
    for dep in STYLE_STRUCTS[i][3]:
        print("STYLE_STRUCT_DEP(%s)" % (dep,), file=header)
    print("STYLE_STRUCT_END()", file=header)

def printTestTree(header, min, max, depth, branches):
    indent = "  " * depth
    if min == count - 1 and max >= count:
        print("  STYLE_STRUCT_TEST_CODE(%sNS_ASSERTION(STYLE_STRUCT_TEST == %d, \"out of range\");)" % (indent, min), file=header)
        printEntry(header, min)
    elif max - min == 2:
        print("  STYLE_STRUCT_TEST_CODE(%sif (STYLE_STRUCT_TEST == %d) {)" % (indent, min), file=header)
        printEntry(header, min)
        print("  STYLE_STRUCT_TEST_CODE(%s} else {)" % indent, file=header)
        printEntry(header, min + 1)
        print("  STYLE_STRUCT_TEST_CODE(%s})" % indent, file=header)
    elif min < count:
        mid = min + (max - min) / branches
        print("  STYLE_STRUCT_TEST_CODE(%sif (STYLE_STRUCT_TEST < %d) {)" % (indent, mid), file=header)
        printTestTree(header, min, mid, depth + 1, 2)
        for branch in range(1, branches):
            lo = min + branch * (max - min) / branches
            hi = min + (branch + 1) * (max - min) / branches
            if lo >= count:
                break
            if branch == branches - 1 or hi >= count:
                print("  STYLE_STRUCT_TEST_CODE(%s} else {)" % indent, file=header)
            else:
                print("  STYLE_STRUCT_TEST_CODE(%s} else if (STYLE_STRUCT_TEST < %d) {)" % (indent, hi), file=header)
            printTestTree(header, lo, hi, depth + 1, 2)
        print("  STYLE_STRUCT_TEST_CODE(%s})" % indent, file=header)

HEADER = """/* THIS FILE IS AUTOGENERATED BY generate-stylestructlist.py - DO NOT EDIT */

// IWYU pragma: private, include "nsStyleStructFwd.h"

/*
 * list of structs that contain the data provided by nsStyleContext, the
 * internal API for computed style data for an element
 */

/*
 * This file is intended to be used by different parts of the code, with
 * the STYLE_STRUCT macro (or the STYLE_STRUCT_INHERITED and
 * STYLE_STRUCT_RESET pair of macros) defined in different ways.
 */

#ifndef STYLE_STRUCT_INHERITED
#define STYLE_STRUCT_INHERITED(name, checkdata_cb) \\
  STYLE_STRUCT(name, checkdata_cb)
#define UNDEF_STYLE_STRUCT_INHERITED
#endif

#ifndef STYLE_STRUCT_RESET
#define STYLE_STRUCT_RESET(name, checkdata_cb) \\
  STYLE_STRUCT(name, checkdata_cb)
#define UNDEF_STYLE_STRUCT_RESET
#endif

#ifndef STYLE_STRUCT_DEP
#define STYLE_STRUCT_DEP(dep)
#define UNDEF_STYLE_STRUCT_DEP
#endif

#ifndef STYLE_STRUCT_END
#define STYLE_STRUCT_END()
#define UNDEF_STYLE_STRUCT_END
#endif

#ifdef STYLE_STRUCT_TEST
#define STYLE_STRUCT_TEST_CODE(c) c
#else
#define STYLE_STRUCT_TEST_CODE(c)
#endif

// The inherited structs are listed before the Reset structs.
// nsStyleStructID assumes this is the case, and callers other than
// nsStyleStructFwd.h that want the structs in id-order just define
// STYLE_STRUCT rather than including the file twice.

"""
FOOTER = """
#ifdef UNDEF_STYLE_STRUCT_INHERITED
#undef STYLE_STRUCT_INHERITED
#undef UNDEF_STYLE_STRUCT_INHERITED
#endif

#ifdef UNDEF_STYLE_STRUCT_RESET
#undef STYLE_STRUCT_RESET
#undef UNDEF_STYLE_STRUCT_RESET
#endif

#ifdef UNDEF_STYLE_STRUCT_DEP
#undef STYLE_STRUCT_DEP
#undef UNDEF_STYLE_STRUCT_DEP
#endif

#ifdef UNDEF_STYLE_STRUCT_END
#undef STYLE_STRUCT_END
#undef UNDEF_STYLE_STRUCT_END
#endif

#undef STYLE_STRUCT_TEST_CODE
"""

def main(header):
    print(HEADER, file=header)
    printTestTree(header, 0, nextPowerOf2(count), 0, TOPLEVELBRANCHES)
    print(FOOTER, file=header)