Searched refs:nlen (Results 1 - 15 of 15) sorted by relevance

/device/linaro/bootloader/edk2/AppPkg/Applications/Python/Python-2.7.2/Modules/
H A Dimageop.c121 int len, size, x, y, newx1, newx2, newy1, newy2, nlen; local
139 nlen = (abs(newx2-newx1)+1)*(abs(newy2-newy1)+1)*size;
140 if ( !check_multiply_size(nlen, abs(newx2-newx1)+1, "abs(newx2-newx1)+1", abs(newy2-newy1)+1, "abs(newy2-newy1)+1", size) )
142 rv = PyString_FromStringAndSize(NULL, nlen);
176 int len, size, x, y, newx, newy, nlen; local
191 nlen = newx*newy*size;
192 if ( !check_multiply_size(nlen, newx, "newx", newy, "newy", size) )
195 rv = PyString_FromStringAndSize(NULL, nlen);
468 int v0, v1, x, y, len, nlen; local
476 nlen
507 int x, y, len, nlen; local
546 int x, y, len, nlen; local
583 int x, y, len, nlen; local
626 int x, y, len, nlen; local
676 int x, y, len, nlen; local
721 int x, y, len, nlen; local
[all...]
/device/linaro/bootloader/edk2/AppPkg/Applications/Python/Python-2.7.10/Modules/zlib/
H A Dinflate.h112 unsigned nlen; /* number of length code lengths */ member in struct:inflate_state
H A Dinfback.c361 state->nlen = BITS(5) + 257;
368 if (state->nlen > 286 || state->ndist > 30) {
399 while (state->have < state->nlen + state->ndist) {
436 if (state->have + copy > state->nlen + state->ndist) {
462 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
471 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
H A Dinflate.c899 state->nlen = BITS(5) + 257;
906 if (state->nlen > 286 || state->ndist > 30) {
937 while (state->have < state->nlen + state->ndist) {
974 if (state->have + copy > state->nlen + state->ndist) {
1000 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
1009 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
/device/linaro/bootloader/edk2/AppPkg/Applications/Python/Python-2.7.2/Modules/zlib/
H A Dinflate.h108 unsigned nlen; /* number of length code lengths */ member in struct:inflate_state
H A Dinfback.c352 state->nlen = BITS(5) + 257;
359 if (state->nlen > 286 || state->ndist > 30) {
390 while (state->have < state->nlen + state->ndist) {
428 if (state->have + copy > state->nlen + state->ndist) {
445 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
454 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
H A Dinflate.c839 state->nlen = BITS(5) + 257;
846 if (state->nlen > 286 || state->ndist > 30) {
877 while (state->have < state->nlen + state->ndist) {
915 if (state->have + copy > state->nlen + state->ndist) {
932 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
941 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
/device/linaro/bootloader/arm-trusted-firmware/tools/fiptool/
H A Dwin_posix.c75 size_t nlen = (opstring == 0) ? 0 : strlen(opstring); local
78 for (loptn = 0; loptn < nlen; loptn++) {
121 size_t nlen = strlen(opstring); local
/device/linaro/bootloader/edk2/EmbeddedPkg/Library/ZLib/
H A Dinflate.h115 unsigned nlen; /* number of length code lengths */ member in struct:inflate_state
H A Dinflate.c922 state->nlen = BITS(5) + 257;
929 if (state->nlen > 286 || state->ndist > 30) {
960 while (state->have < state->nlen + state->ndist) {
997 if (state->have + copy > state->nlen + state->ndist) {
1023 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
1032 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
/device/linaro/bootloader/edk2/AppPkg/Applications/Python/Python-2.7.2/Lib/logging/
H A D__init__.py552 self.nlen = len(name)
561 if self.nlen == 0:
565 elif record.name.find(self.name, 0, self.nlen) != 0:
567 return (record.name[self.nlen] == ".")
/device/linaro/bootloader/edk2/StdLib/LibC/Uefi/
H A Dcompat.c106 size_t nlen = strlen(args); local
113 for (n = 0; n < nlen; n++) {
/device/linaro/bootloader/edk2/AppPkg/Applications/Python/Python-2.7.2/Python/
H A Dcompile.c193 size_t nlen, plen; local
200 nlen = strlen(name);
210 if ((name[nlen-1] == '_' && name[nlen-2] == '_')
224 assert(1 <= PY_SSIZE_T_MAX - nlen);
225 assert(1 + nlen <= PY_SSIZE_T_MAX - plen);
227 ident = PyString_FromStringAndSize(NULL, 1 + nlen + plen);
230 /* ident = "_" + p[:plen] + name # i.e. 1+plen+nlen bytes */
/device/linaro/bootloader/edk2/AppPkg/Applications/Python/Python-2.7.10/Python/
H A Dcompile.c193 size_t nlen, plen; local
200 nlen = strlen(name);
210 if ((name[nlen-1] == '_' && name[nlen-2] == '_')
224 if (plen + nlen >= PY_SSIZE_T_MAX - 1) {
230 ident = PyString_FromStringAndSize(NULL, 1 + nlen + plen);
233 /* ident = "_" + p[:plen] + name # i.e. 1+plen+nlen bytes */
/device/linaro/bootloader/edk2/AppPkg/Applications/Python/Python-2.7.2/Lib/pydoc_data/
H A Dtopics.py75 'typesmapping': u'\nMapping Types --- ``dict``\n**************************\n\nA *mapping* object maps *hashable* values to arbitrary objects.\nMappings are mutable objects. There is currently only one standard\nmapping type, the *dictionary*. (For other containers see the built\nin ``list``, ``set``, and ``tuple`` classes, and the ``collections``\nmodule.)\n\nA dictionary\'s keys are *almost* arbitrary values. Values that are\nnot *hashable*, that is, values containing lists, dictionaries or\nother mutable types (that are compared by value rather than by object\nidentity) may not be used as keys. Numeric types used for keys obey\nthe normal rules for numeric comparison: if two numbers compare equal\n(such as ``1`` and ``1.0``) then they can be used interchangeably to\nindex the same dictionary entry. (Note however, that since computers\nstore floating-point numbers as approximations it is usually unwise to\nuse them as dictionary keys.)\n\nDictionaries can be created by placing a comma-separated list of\n``key: value`` pairs within braces, for example: ``{\'jack\': 4098,\n\'sjoerd\': 4127}`` or ``{4098: \'jack\', 4127: \'sjoerd\'}``, or by the\n``dict`` constructor.\n\nclass class dict([arg])\n\n Return a new dictionary initialized from an optional positional\n argument or from a set of keyword arguments. If no arguments are\n given, return a new empty dictionary. If the positional argument\n *arg* is a mapping object, return a dictionary mapping the same\n keys to the same values as does the mapping object. Otherwise the\n positional argument must be a sequence, a container that supports\n iteration, or an iterator object. The elements of the argument\n must each also be of one of those kinds, and each must in turn\n contain exactly two objects. The first is used as a key in the new\n dictionary, and the second as the key\'s value. If a given key is\n seen more than once, the last value associated with it is retained\n in the new dictionary.\n\n If keyword arguments are given, the keywords themselves with their\n associated values are added as items to the dictionary. If a key is\n specified both in the positional argument and as a keyword\n argument, the value associated with the keyword is retained in the\n dictionary. For example, these all return a dictionary equal to\n ``{"one": 1, "two": 2}``:\n\n * ``dict(one=1, two=2)``\n\n * ``dict({\'one\': 1, \'two\': 2})``\n\n * ``dict(zip((\'one\', \'two\'), (1, 2)))``\n\n * ``dict([[\'two\', 2], [\'one\', 1]])``\n\n The first example only works for keys that are valid Python\n identifiers; the others work with any valid keys.\n\n New in version 2.2.\n\n Changed in version 2.3: Support for building a dictionary from\n keyword arguments added.\n\n These are the operations that dictionaries support (and therefore,\n custom mapping types should support too):\n\n len(d)\n\n Return the number of items in the dictionary *d*.\n\n d[key]\n\n Return the item of *d* with key *key*. Raises a ``KeyError`` if\n *key* is not in the map.\n\n New in version 2.5: If a subclass of dict defines a method\n ``__missing__()``, if the key *key* is not present, the\n ``d[key]`` operation calls that method with the key *key* as\n argument. The ``d[key]`` operation then returns or raises\n whatever is returned or raised by the ``__missing__(key)`` call\n if the key is not present. No other operations or methods invoke\n ``__missing__()``. If ``__missing__()`` is not defined,\n ``KeyError`` is raised. ``__missing__()`` must be a method; it\n cannot be an instance variable. For an example, see\n ``collections.defaultdict``.\n\n d[key] = value\n\n Set ``d[key]`` to *value*.\n\n del d[key]\n\n Remove ``d[key]`` from *d*. Raises a ``KeyError`` if *key* is\n not in the map.\n\n key in d\n\n Return ``True`` if *d* has a key *key*, else ``False``.\n\n New in version 2.2.\n\n key not in d\n\n Equivalent to ``not key in d``.\n\n New in version 2.2.\n\n iter(d)\n\n Return an iterator over the keys of the dictionary. This is a\n shortcut for ``iterkeys()``.\n\n clear()\n\n Remove all items from the dictionary.\n\n copy()\n\n Return a shallow copy of the dictionary.\n\n fromkeys(seq[, value])\n\n Create a new dictionary with keys from *seq* and values set to\n *value*.\n\n ``fromkeys()`` is a class method that returns a new dictionary.\n *value* defaults to ``None``.\n\n New in version 2.3.\n\n get(key[, default])\n\n Return the value for *key* if *key* is in the dictionary, else\n *default*. If *default* is not given, it defaults to ``None``,\n so that this method never raises a ``KeyError``.\n\n has_key(key)\n\n Test for the presence of *key* in the dictionary. ``has_key()``\n is deprecated in favor of ``key in d``.\n\n items()\n\n Return a copy of the dictionary\'s list of ``(key, value)``\n pairs.\n\n **CPython implementation detail:** Keys and values are listed in\n an arbitrary order which is non-random, varies across Python\n implementations, and depends on the dictionary\'s history of\n insertions and deletions.\n\n If ``items()``, ``keys()``, ``values()``, ``iteritems()``,\n ``iterkeys()``, and ``itervalues()`` are called with no\n intervening modifications to the dictionary, the lists will\n directly correspond. This allows the creation of ``(value,\n key)`` pairs using ``zip()``: ``pairs = zip(d.values(),\n d.keys())``. The same relationship holds for the ``iterkeys()``\n and ``itervalues()`` methods: ``pairs = zip(d.itervalues(),\n d.iterkeys())`` provides the same value for ``pairs``. Another\n way to create the same list is ``pairs = [(v, k) for (k, v) in\n d.iteritems()]``.\n\n iteritems()\n\n Return an iterator over the dictionary\'s ``(key, value)`` pairs.\n See the note for ``dict.items()``.\n\n Using ``iteritems()`` while adding or deleting entries in the\n dictionary may raise a ``RuntimeError`` or fail to iterate over\n all entries.\n\n New in version 2.2.\n\n iterkeys()\n\n Return an iterator over the dictionary\'s keys. See the note for\n ``dict.items()``.\n\n Using ``iterkeys()`` while adding or deleting entries in the\n dictionary may raise a ``RuntimeError`` or fail to iterate over\n all entries.\n\n New in version 2.2.\n\n itervalues()\n\n Return an iterator over the dictionary\'s values. See the note\n for ``dict.items()``.\n\n Using ``itervalues()`` while adding or deleting entries in the\n dictionary may raise a ``RuntimeError`` or fail to iterate over\n all entries.\n\n New in version 2.2.\n\n keys()\n\n Return a copy of the dictionary\'s list of keys. See the note\n for ``dict.items()``.\n\n pop(key[, default])\n\n If *key* is in the dictionary, remove it and return its value,\n else return *default*. If *default* is not given and *key* is\n not in the dictionary, a ``KeyError`` is raised.\n\n New in version 2.3.\n\n popitem()\n\n Remove and return an arbitrary ``(key, value)`` pair from the\n dictionary.\n\n ``popitem()`` is useful to destructively iterate over a\n dictionary, as often used in set algorithms. If the dictionary\n is empty, calling ``popitem()`` raises a ``KeyError``.\n\n setdefault(key[, default])\n\n If *key* is in the dictionary, return its value. If not, insert\n *key* with a value of *default* and return *default*. *default*\n defaults to ``None``.\n\n update([other])\n\n Update the dictionary with the key/value pairs from *other*,\n overwriting existing keys. Return ``None``.\n\n ``update()`` accepts either another dictionary object or an\n iterable of key/value pairs (as tuples or other iterables of\n length two). If keyword arguments are specified, the dictionary\n is then updated with those key/value pairs: ``d.update(red=1,\n blue=2)``.\n\n Changed in version 2.4: Allowed the argument to be an iterable\n of key/value pairs and allowed keyword arguments.\n\n values()\n\n Return a copy of the dictionary\'s list of values. See the note\n for ``dict.items()``.\n\n viewitems()\n\n Return a new view of the dictionary\'s items (``(key, value)``\n pairs). See below for documentation of view objects.\n\n New in version 2.7.\n\n viewkeys()\n\n Return a new view of the dictionary\'s keys. See below for\n documentation of view objects.\n\n New in version 2.7.\n\n viewvalues()\n\n Return a new view of the dictionary\'s values. See below for\n documentation of view objects.\n\n New in version 2.7.\n\n\nDictionary view objects\n=======================\n\nThe objects returned by ``dict.viewkeys()``, ``dict.viewvalues()`` and\n``dict.viewitems()`` are *view objects*. They provide a dynamic view\non the dictionary\'s entries, which means that when the dictionary\nchanges, the view reflects these changes.\n\nDictionary views can be iterated over to yield their respective data,\nand support membership tests:\n\nlen(dictview)\n\n Return the number of entries in the dictionary.\n\niter(dictview)\n\n Return an iterator over the keys, values or items (represented as\n tuples of ``(key, value)``) in the dictionary.\n\n Keys and values are iterated over in an arbitrary order which is\n non-random, varies across Python implementations, and depends on\n the dictionary\'s history of insertions and deletions. If keys,\n values and items views are iterated over with no intervening\n modifications to the dictionary, the order of items will directly\n correspond. This allows the creation of ``(value, key)`` pairs\n using ``zip()``: ``pairs = zip(d.values(), d.keys())``. Another\n way to create the same list is ``pairs = [(v, k) for (k, v) in\n d.items()]``.\n\n Iterating views while adding or deleting entries in the dictionary\n may raise a ``RuntimeError`` or fail to iterate over all entries.\n\nx in dictview\n\n Return ``True`` if *x* is in the underlying dictionary\'s keys,\n values or items (in the latter case, *x* should be a ``(key,\n value)`` tuple).\n\nKeys views are set-like since their entries are unique and hashable.\nIf all values are hashable, so that (key, value) pairs are unique and\nhashable, then the items view is also set-like. (Values views are not\ntreated as set-like since the entries are generally not unique.) Then\nthese set operations are available ("other" refers either to another\nview or a set):\n\ndictview & other\n\n Return the intersection of the dictview and the other object as a\n new set.\n\ndictview | other\n\n Return the union of the dictview and the other object as a new set.\n\ndictview - other\n\n Return the difference between the dictview and the other object\n (all elements in *dictview* that aren\'t in *other*) as a new set.\n\ndictview ^ other\n\n Return the symmetric difference (all elements either in *dictview*\n or *other*, but not in both) of the dictview and the other object\n as a new set.\n\nAn example of dictionary view usage:\n\n >>> dishes = {\'eggs\': 2, \'sausage\': 1, \'bacon\': 1, \'spam\': 500}\n >>> keys = dishes.viewkeys()\n >>> values = dishes.viewvalues()\n\n >>> # iteration\n >>> n = 0\n >>> for val in values:\n ... n += val\n >>> print(n)\n 504\n\n >>> # keys and values are iterated over in the same order\n >>> list(keys)\n [\'eggs\', \'bacon\', \'sausage\', \'spam\']\n >>> list(values)\n [2, 1, 1, 500]\n\n >>> # view objects are dynamic and reflect dict changes\n >>> del dishes[\'eggs\']\n >>> del dishes[\'sausage\']\n >>> list(keys)\n [\'spam\', \'bacon\']\n\n >>> # set operations\n >>> keys & {\'eggs\', \'bacon\', \'salad\'}\n {\'bacon\'}\n',

Completed in 332 milliseconds