Yields the tuple ``(character, symbol name)`` for all keysyms.
482948
def keysyms_from_strings():
    
    for number, codepoint, status, name in keysym_definitions():
        # Ignore keysyms that do not map to unicode characters
        if all(c == '0' for c in codepoint):
            continue

        # Ignore keysyms that are not well established
        if status != '.':
            continue

        yield (codepoint, name)
1293840
def lookup_character_keycode(self, character):
        
        keysym = Xlib.XK.string_to_keysym(character)
        if not keysym:
            try:
                keysym = getattr(Xlib.keysymdef.xkb, 'XK_' + character, 0)
            except:
                keysym = 0
        if not keysym:
            keysym = Xlib.XK.string_to_keysym(KEYSYMS[character])
        return self.display.keysym_to_keycode(keysym)
334878
def _parseSymbols(self, sections):
        """"""
        for section in sections:
            strtab = sections[section.header.sh_link]
            if section.header.sh_type in (int(SHT.DYNSYM), int(SHT.SYMTAB)):
                section.symbols = self.__parseSymbolEntriesForSection(section, strtab)
949434
def iterate_symbols():
    
    for prefix in search_prefixes():
        package = importlib.import_module(prefix)
        for importer, modname, ispkg in pkgutil.walk_packages(path=package.__path__, onerror=lambda x: None):
            network = network_for_netcode(modname)
            if network:
                yield network.symbol.upper()
1247507
def all_characters(self):
        '''
        
        '''
        qs = self.assoc_characters.all()
        for node in self.get_descendants():
            qs2 = node.assoc_characters.all()
            qs = qs.union(qs2).distinct('pk')
        return qs
432096
def _make_symbol_function(handle, name, func_name):
    """"""
    code, doc_str = _generate_symbol_function_code(handle, name, func_name)

    local = {}
    exec(code, None, local)  # pylint: disable=exec-used
    symbol_function = local[func_name]
    symbol_function.__name__ = func_name
    symbol_function.__doc__ = doc_str
    symbol_function.__module__ = 'mxnet.symbol'
    return symbol_function
552486
def free_symbols(self):
        """"""
        return set([
            sym for sym in self.term.free_symbols
            if sym not in self.bound_symbols])
1367074
def _lookup_symbols(self, symbols_filename):
        """"""
        symbol_lookup = GenewaysSymbols(symbols_filename)
        for action in self.actions:
            action.up_symbol = symbol_lookup.id_to_symbol(action.up)
            action.dn_symbol = symbol_lookup.id_to_symbol(action.dn)
904776
private Map<String, ByteBuffer> tupleToKeyMap(Tuple t) throws IOException
    {
        Map<String, ByteBuffer> keys = new HashMap<String, ByteBuffer>();
        for (int i = 0; i < t.size(); i++)
        {
            if (t.getType(i) == DataType.TUPLE)
            {
                Tuple inner = (Tuple) t.get(i);
                if (inner.size() == 2)
                {
                    Object name = inner.get(0);
                    if (name != null)
                    {
                        keys.put(name.toString(), objToBB(inner.get(1)));
                    }
                    else
                        throw new IOException("Key name was empty");
                }
                else
                    throw new IOException("Keys were not in name and value pairs");
            }
            else
            {
                throw new IOException("keys was not a tuple");
            }
        }
        return keys;
    }
472460
def iter_symbols(code):
    """"""
    for name in code.co_names:
        yield name
    for const in code.co_consts:
        if isinstance(const, six.string_types):
            yield const
        elif isinstance(const, CodeType):
            for name in iter_symbols(const):
                yield name
414471
def lookup_character_keycode(self, character):
        
        keysym = self.string_to_keysym.get(character, 0)
        if keysym == 0:
            keysym = self.string_to_keysym.get(KEYSYMS[character], 0)
        return self.display.keysym_to_keycode(keysym)
79029
def keycode_to_keysym(self, keycode, index):
        """"""
        try:
            return self._keymap_codes[keycode][index]
        except IndexError:
            return X.NoSymbol
963485
def get_expected_tokens(self, parser, interval_set):
        # type: (QuilParser, IntervalSet) -> Iterator
        
        for tok in interval_set:
            literal_name = parser.literalNames[tok]
            symbolic_name = parser.symbolicNames[tok]

            if literal_name != '<INVALID>':
                yield literal_name
            else:
                yield symbolic_name
985808
def process_python_symbol_data(oedata):
    """"""
    symbol_list = []
    for key in oedata:
        val = oedata[key]
        if val and key != 'found_cell_separators':
            if val.is_class_or_function():
                symbol_list.append((key, val.def_name, val.fold_level,
                                    val.get_token()))
    return sorted(symbol_list)
1335487
def multi_char_literal(chars):
    
    num = 0
    for index, char in enumerate(chars):
        shift = (len(chars) - index - 1) * 8
        num |= ord(char) << shift
    return num
1310116
def get_symbols(self):
        
        return [s if isinstance(s, Symbol) else s.args[0] for s in self.get_literals()]
1333384
public function mapSymbols()
    {
        foreach ($this->input as $key => $input) {
            foreach ($this->symbols as $skey => $svalue) {
                if (substr($key, 0, 1) == $svalue) {

                    $keyWithoutSymbol = str_replace($svalue, '', $key);

                    if (is_string($input)) {
                        $this->setElementBy($skey, $keyWithoutSymbol, $input);
                    }
                    if (is_array($input)) {
                        $this->setElementBy($skey, $keyWithoutSymbol, $input);
                    }
                    if (is_object($input)) {
                        $this->setElementBy($skey, $keyWithoutSymbol, $input);
                    }
                }
            }
        }
    }