订阅关于Ocean Death的评论:
链接打不开?
请点击右上角
选择"在浏览器中打开"trackbacks-0
今天郁闷了半天，Popen创建之后总是不自动开始运行。
pargs = ["python.exe", "test.py"]
process = subprocess.Popen(pargs)
后来发现调用process.wait()可以运行，但是我这里要求不阻塞本进程，同步执行两个进程。看了半天subprocess.py还是一头雾水，干脆试一下加了下面这句
pargs = ["python.exe", "test.py"]
process = subprocess.Popen(pargs)
pid = process.pid
居然就可以了。。。汗-_-!!!
阅读(...) 评论()>> ocv.py - ...
点击查看更多 ▼
点击收缩隐藏 ▲
ocv.py - ...
源码下载: &
# -*- coding: utf-8 -*-
ocv domain, a modified copy of sphinx.domains.cpp + shpinx.domains.python.
The original copyright is below
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The OpenCV C/C++/Python/Java/... language domain.
:copyright: Copyright
by the Sphinx team, see AUTHORS.
:license: BSD, see LICENSE for details.
from copy import deepcopy
from docutils import nodes
from docutils.parsers.rst import directives
from sphinx import addnodes
from sphinx.roles import XRefRole
from sphinx.locale import l_, _
from sphinx.domains import Domain, ObjType
from sphinx.directives import ObjectDescription
from sphinx.util.nodes import make_refnode
from pat import Directive
from sphinx.util.docfields import Field, GroupedField, TypedField
########################### Python Part ###########################
# REs for Python signatures
py_sig_re = re.compile(
r'''^ ([\w.]*\.)?
# class name(s)
# thing name
(?: \((.*)\)
# optional: arguments
(?:\s* -& \s* (.*))?
return annotation
# and nothing more
''', re.VERBOSE)
def _pseudo_parse_arglist(signode, arglist):
&&&&Parse& a list of arguments separated by commas.
Arguments can have &optional& annotations given by enclosing them in
Currently, this will split at any comma, even if it's inside a
string literal (e.g. default argument value).
paramlist = addnodes.desc_parameterlist()
stack = [paramlist]
for argument in arglist.split(','):
argument = argument.strip()
ends_open = ends_close = 0
while argument.startswith('['):
stack.append(addnodes.desc_optional())
stack[-2] += stack[-1]
argument = argument[1:].strip()
while argument.startswith(']'):
stack.pop()
argument = argument[1:].strip()
while argument.endswith(']'):
ends_close += 1
argument = argument[:-1].strip()
while argument.endswith('['):
ends_open += 1
argument = argument[:-1].strip()
if argument:
stack[-1] += addnodes.desc_parameter(argument, argument, noemph=True)
while ends_open:
stack.append(addnodes.desc_optional())
stack[-2] += stack[-1]
ends_open -= 1
while ends_close:
stack.pop()
ends_close -= 1
if len(stack) != 1:
raise IndexError
except IndexError:
# if there are too few or too many elements on the stack, just give up
# and treat the whole argument list as one argument, discarding the
# already partially populated paramlist node
signode += addnodes.desc_parameterlist()
signode[-1] += addnodes.desc_parameter(arglist, arglist)
signode += paramlist
class OCVPyObject(ObjectDescription):
Description of a general Python object.
option_spec = {
'noindex': directives.flag,
'module': directives.unchanged,
doc_field_types = [
TypedField('parameter', label=l_('Parameters'),
names=('param', 'parameter', 'arg', 'argument',
'keyword', 'kwarg', 'kwparam'),
typerolename='obj', typenames=('paramtype', 'type'),
can_collapse=True),
TypedField('variable', label=l_('Variables'), rolename='obj',
names=('var', 'ivar', 'cvar'),
typerolename='obj', typenames=('vartype',),
can_collapse=True),
GroupedField('exceptions', label=l_('Raises'), rolename='exc',
names=('raises', 'raise', 'exception', 'except'),
can_collapse=True),
Field('returnvalue', label=l_('Returns'), has_arg=False,
names=('returns', 'return')),
Field('returntype', label=l_('Return type'), has_arg=False,
names=('rtype',)),
def get_signature_prefix(self, sig):
May return a prefix to put before the object name in the signature.
def needs_arglist(self):
May return true if an empty argument list is to be generated even if
the document contains none.
return False
def handle_signature(self, sig, signode):
Transform a Python signature into RST nodes.
Returns (fully qualified name of the thing, classname if any).
If inside a class, the current class name is handled intelligently:
* it is stripped from the displayed name if present
* it is added to the full name (return value) if not present
signode += nodes.strong(&Python:&, &Python:&)
signode += addnodes.desc_name(& &, & &)
m = py_sig_re.match(sig)
if m is None:
raise ValueError
name_prefix, name, arglist, retann = m.groups()
# determine module and class name (if applicable), as well as full name
modname = self.options.get(
'module', self.env.temp_data.get('py:module'))
classname = self.env.temp_data.get('py:class')
if classname:
add_module = False
if name_prefix and name_prefix.startswith(classname):
fullname = name_prefix + name
# class name is given again in the signature
name_prefix = name_prefix[len(classname):].lstrip('.')
elif name_prefix:
# class name is given in the signature, but different
# (shouldn't happen)
fullname = classname + '.' + name_prefix + name
# class name is not given in the signature
fullname = classname + '.' + name
add_module = True
if name_prefix:
classname = name_prefix.rstrip('.')
fullname = name_prefix + name
classname = ''
fullname = name
signode['module'] = modname
signode['class'] = classname
signode['fullname'] = fullname
sig_prefix = self.get_signature_prefix(sig)
if sig_prefix:
signode += addnodes.desc_annotation(sig_prefix, sig_prefix)
if name_prefix:
signode += addnodes.desc_addname(name_prefix, name_prefix)
# exceptions are a special case, since they are documented in the
# 'exceptions' module.
elif add_module and self.env.config.add_module_names:
modname = self.options.get(
'module', self.env.temp_data.get('py:module'))
if modname and modname != 'exceptions':
nodetext = modname + '.'
signode += addnodes.desc_addname(nodetext, nodetext)
signode += addnodes.desc_name(name, name)
if not arglist:
if self.needs_arglist():
# for callables, add an empty parameter list
signode += addnodes.desc_parameterlist()
if retann:
signode += addnodes.desc_returns(retann, retann)
return fullname, name_prefix
_pseudo_parse_arglist(signode, arglist)
if retann:
signode += addnodes.desc_returns(retann, retann)
return fullname, name_prefix
def get_index_text(self, modname, name):
Return the text for the index entry of the object.
raise NotImplementedError('must be implemented in subclasses')
def add_target_and_index(self, name_cls, sig, signode):
modname = self.options.get(
'module', self.env.temp_data.get('py:module'))
fullname = (modname and modname + '.' or '') + name_cls[0]
# note target
if fullname not in self.state.document.ids:
signode['names'].append(fullname)
signode['ids'].append(fullname)
signode['first'] = (not self.names)
self.state.document.note_explicit_target(signode)
objects = self.env.domaindata['ocv']['objects']
if fullname in objects:
self.env.warn(
self.env.docname,
'duplicate object description of %s, ' % fullname +
'other instance in ' +
self.env.doc2path(objects[fullname][0]) +
', use :noindex: for one of them',
self.lineno)
objects.setdefault(fullname, (self.env.docname, self.objtype, name_cls[0]))
indextext = self.get_index_text(modname, name_cls)
if indextext:
self.indexnode['entries'].append(('single', indextext,
fullname, fullname))
def before_content(self):
# needed for automatic qualification of members (reset in subclasses)
self.clsname_set = False
def after_content(self):
if self.clsname_set:
self.env.temp_data['py:class'] = None
class OCVPyModulelevel(OCVPyObject):
Description of an object on module level (functions, data).
directive_prefix = 'py'
def needs_arglist(self):
return self.objtype == self.__class__.directive_prefix + 'function'
def get_index_text(self, modname, name_cls):
if self.objtype == self.__class__.directive_prefix + 'function':
if not modname:
fname = name_cls[0]
if not fname.startswith(&cv&) and not fname.startswith(&cv2&):
return _('%s() (Python function)') % fname
pos = fname.find(&.&)
modname = fname[:pos]
fname = fname[pos+1:]
return _('%s() (Python function in %s)') % (fname, modname)
return _('%s() (Python function in %s)') % (name_cls[0], modname)
elif self.objtype == 'pydata':
if not modname:
return _('%s (Python variable)') % name_cls[0]
return _('%s (in module %s)') % (name_cls[0], modname)
class OCVPyOldModulelevel(OCVPyModulelevel):
directive_prefix = 'pyold'
class OCVPyXRefRole(XRefRole):
def process_link(self, env, refnode, has_explicit_title, title, target):
refnode['ocv:module'] = env.temp_data.get('ocv:module')
refnode['ocv:class'] = env.temp_data.get('ocv:class')
if not has_explicit_title:
title = title.lstrip('.')
# only has a meaning for the target
target = target.lstrip('~') # only has a meaning for the title
# if the first character is a tilde, don't display the module/class
# parts of the contents
if title[0:1] == '~':
title = title[1:]
dot = title.rfind('.')
if dot != -1:
title = title[dot+1:]
# if the first character is a dot, search more specific namespaces first
# else search builtins first
if target[0:1] == '.':
target = target[1:]
refnode['refspecific'] = True
return title, target
########################### C/C++/Java Part ###########################
_identifier_re = re.compile(r'(~?\b[a-zA-Z_][a-zA-Z0-9_]*)\b')
_whitespace_re = re.compile(r'\s+(?u)')
_string_re = re.compile(r&[LuU8]?('([^'\\]*(?:\\.[^'\\]*)*)'&
r'|&([^&\\]*(?:\\.[^&\\]*)*)&)', re.S)
_visibility_re = re.compile(r'\b(public|private|protected)\b')
_operator_re = re.compile(r'''(?x)
[!&&=/*%+|&^-]=?
~ | && | \| | \|\|
-&\*? | \,
_id_shortwords = {
'signed char':
'unsigned char':
'signed int':
'unsigned int':
'signed long':
'unsigned long':
'std::string':
'std::ostream':
'std::istream':
'std::iostream':
'std::vector':
'std::map':
'operator[]':
'subscript-operator',
'operator()':
'call-operator',
'operator!':
'not-operator',
'operator&':
'lt-operator',
'operator&=':
'lte-operator',
'operator&':
'gt-operator',
'operator&=':
'gte-operator',
'operator=':
'assign-operator',
'operator/':
'div-operator',
'operator*':
'mul-operator',
'operator%':
'mod-operator',
'operator+':
'add-operator',
'operator-':
'sub-operator',
'operator|':
'or-operator',
'operator&':
'and-operator',
'operator^':
'xor-operator',
'operator&&':
'sand-operator',
'operator||':
'sor-operator',
'operator==':
'eq-operator',
'operator!=':
'neq-operator',
'operator&&':
'lshift-operator',
'operator&&':
'rshift-operator',
'operator-=':
'sub-assign-operator',
'operator+=':
'add-assign-operator',
'operator*-':
'mul-assign-operator',
'operator/=':
'div-assign-operator',
'operator%=':
'mod-assign-operator',
'operator&=':
'and-assign-operator',
'operator|=':
'or-assign-operator',
'operator&&=':
'lshift-assign-operator',
'operator&&=':
'rshift-assign-operator',
'operator^=':
'xor-assign-operator',
'operator,':
'comma-operator',
'operator-&':
'pointer-operator',
'operator-&*':
'pointer-by-pointer-operator',
'operator~':
'inv-operator',
'operator++':
'inc-operator',
'operator--':
'dec-operator',
'operator new':
'new-operator',
'operator new[]':
'new-array-operator',
'operator delete':
'delete-operator',
'operator delete[]':
'delete-array-operator'
class DefinitionError(Exception):
def __init__(self, description):
self.description = description
def __unicode__(self):
return self.description
def __str__(self):
return unicode(self.encode('utf-8'))
class DefExpr(object):
def __unicode__(self):
raise NotImplementedError()
def __eq__(self, other):
if type(self) is not type(other):
return False
for key, value in self.__dict__.iteritems():
if value != getattr(other, value):
return False
except AttributeError:
return False
return True
def __ne__(self, other):
return not self.__eq__(other)
def clone(self):
&&&Close a definition expression node&&&
return deepcopy(self)
def get_id(self):
&&&Returns the id for the node&&&
return u''
def get_name(self):
&&&Returns the name.
Returns either `None` or a node with
a name you might call :meth:`split_owner` on.
return None
def split_owner(self):
&&&Nodes returned by :meth:`get_name` can split off their
owning parent.
This function returns the owner and the
name as a tuple of two items.
If a node does not support
it, it returns None as owner and self as name.
return None, self
def prefix(self, prefix):
&&&Prefixes a name node (a node returned by :meth:`get_name`).&&&
raise NotImplementedError()
def __str__(self):
return unicode(self).encode('utf-8')
def __repr__(self):
return '&%s %s&' % (self.__class__.__name__, self)
class PrimaryDefExpr(DefExpr):
def get_name(self):
return self
def prefix(self, prefix):
if isinstance(prefix, PathDefExpr):
prefix = prefix.clone()
prefix.path.append(self)
return prefix
return PathDefExpr([prefix, self])
class NameDefExpr(PrimaryDefExpr):
def __init__(self, name):
self.name = name
def get_id(self):
name = _id_shortwords.get(self.name)
if name is not None:
return name
return self.name.replace(u' ', u'-')
def __unicode__(self):
return unicode(self.name)
class PathDefExpr(PrimaryDefExpr):
def __init__(self, parts):
self.path = parts
def get_id(self):
rv = u'::'.join(x.get_id() for x in self.path)
return _id_shortwords.get(rv, rv)
def split_owner(self):
if len(self.path) & 1:
return PathDefExpr(self.path[:-1]), self.path[-1]
return None, self
def prefix(self, prefix):
if isinstance(prefix, PathDefExpr):
prefix = prefix.clone()
prefix.path.extend(self.path)
return prefix
return PathDefExpr([prefix] + self.path)
def __unicode__(self):
return u'::'.join(map(unicode, self.path))
class TemplateDefExpr(PrimaryDefExpr):
def __init__(self, typename, args):
self.typename = typename
self.args = args
def split_owner(self):
owner, typename = self.typename.split_owner()
return owner, TemplateDefExpr(typename, self.args)
def get_id(self):
return u'%s:%s:' % (self.typename.get_id(),
u'.'.join(x.get_id() for x in self.args))
def __unicode__(self):
return u'%s&%s&' % (self.typename, u', '.join(map(unicode, self.args)))
class WrappingDefExpr(DefExpr):
def __init__(self, typename):
self.typename = typename
def get_name(self):
return self.typename.get_name()
class ModifierDefExpr(WrappingDefExpr):
def __init__(self, typename, modifiers):
WrappingDefExpr.__init__(self, typename)
self.modifiers = modifiers
def get_id(self):
pieces = [_id_shortwords.get(unicode(x), unicode(x))
for x in self.modifiers]
pieces.append(self.typename.get_id())
return u'-'.join(pieces)
def __unicode__(self):
return u' '.join(map(unicode, list(self.modifiers) + [self.typename]))
class PtrDefExpr(WrappingDefExpr):
def get_id(self):
return self.typename.get_id() + u'P'
def __unicode__(self):
return u'%s*' % self.typename
class RefDefExpr(WrappingDefExpr):
def get_id(self):
return self.typename.get_id() + u'R'
def __unicode__(self):
return u'%s&' % self.typename
class ConstDefExpr(WrappingDefExpr):
def __init__(self, typename, prefix=False):
WrappingDefExpr.__init__(self, typename)
self.prefix = prefix
def get_id(self):
return self.typename.get_id() + u'C'
def __unicode__(self):
return (self.prefix and u'const %s' or u'%s const') % self.typename
class ConstTemplateDefExpr(WrappingDefExpr):
def __init__(self, typename, prefix=False):
WrappingDefExpr.__init__(self, typename)
self.prefix = prefix
def get_id(self):
return self.typename.get_id() + u'C'
def __unicode__(self):
return (self.prefix and u'const %s' or u'%s const') % self.typename
class CastOpDefExpr(PrimaryDefExpr):
def __init__(self, typename):
self.typename = typename
def get_id(self):
return u'castto-%s-operator' % self.typename.get_id()
def __unicode__(self):
return u'operator %s' % self.typename
class ArgumentDefExpr(DefExpr):
def __init__(self, type, name, default=None):
self.name = name
self.type = type
self.default = default
def get_name(self):
return self.name.get_name()
def get_id(self):
if self.type is None:
return 'X'
return self.type.get_id()
def __unicode__(self):
return (u'%s %s' % (self.type or u'', self.name or u'')).strip() + \
(self.default is not None and u'=%s' % self.default or u'')
class NamedDefExpr(DefExpr):
def __init__(self, name, visibility, static):
self.name = name
self.visibility = visibility
self.static = static
def get_name(self):
return self.name.get_name()
def get_modifiers(self):
if self.visibility != 'public':
rv.append(self.visibility)
if self.static:
rv.append(u'static')
class TypeObjDefExpr(NamedDefExpr):
def __init__(self, name, visibility, static, typename):
NamedDefExpr.__init__(self, name, visibility, static)
self.typename = typename
def get_id(self):
if self.typename is None:
return self.name.get_id()
return u'%s__%s' % (self.name.get_id(), self.typename.get_id())
def __unicode__(self):
buf = self.get_modifiers()
if self.typename is None:
buf.append(unicode(self.name))
buf.extend(map(unicode, (self.typename, self.name)))
return u' '.join(buf)
class MemberObjDefExpr(NamedDefExpr):
def __init__(self, name, visibility, static, typename, value):
NamedDefExpr.__init__(self, name, visibility, static)
self.typename = typename
self.value = value
def get_id(self):
return u'%s__%s' % (self.name.get_id(), self.typename.get_id())
def __unicode__(self):
buf = self.get_modifiers()
buf.append(u'%s %s' % (self.typename, self.name))
if self.value is not None:
buf.append(u'= %s' % self.value)
return u' '.join(buf)
class FuncDefExpr(NamedDefExpr):
def __init__(self, name, visibility, static, explicit, rv,
signature, const, pure_virtual):
NamedDefExpr.__init__(self, name, visibility, static)
self.rv = rv
self.signature = signature
self.explicit = explicit
self.const = const
self.pure_virtual = pure_virtual
def get_id(self):
return u'%s%s%s' % (
self.name.get_id(),
self.signature and u'__' +
u'.'.join(x.get_id() for x in self.signature) or u'',
self.const and u'C' or u''
def __unicode__(self):
buf = self.get_modifiers()
if self.explicit:
buf.append(u'explicit')
if self.rv is not None:
buf.append(unicode(self.rv))
buf.append(u'%s(%s)' % (self.name, u', '.join(
map(unicode, self.signature))))
if self.const:
buf.append(u'const')
if self.pure_virtual:
buf.append(u'= 0')
return u' '.join(buf)
class ClassDefExpr(NamedDefExpr):
def __init__(self, name, visibility, static):
NamedDefExpr.__init__(self, name, visibility, static)
def get_id(self):
return self.name.get_id()
def __unicode__(self):
buf = self.get_modifiers()
buf.append(unicode(self.name))
return u' '.join(buf)
class DefinitionParser(object):
# mapping of valid type modifiers.
if the set is None it means
# the modifier can prefix all types, otherwise only the types
# (actually more keywords) in the set.
Also check
# _guess_typename when changing this.
_modifiers = {
'volatile':
'register':
'mutable':
'typename':
'unsigned':
set(('char', 'short', 'int', 'long')),
set(('char', 'short', 'int', 'long')),
set(('int',)),
set(('int', 'long', 'double'))
def __init__(self, definition):
self.definition = definition.strip()
self.pos = 0
self.end = len(self.definition)
self.last_match = None
self._previous_state = (0, None)
def fail(self, msg):
raise DefinitionError('Invalid definition: %s [error at %d]\n
(msg, self.pos, self.definition))
def match(self, regex):
match = regex.match(self.definition, self.pos)
if match is not None:
self._previous_state = (self.pos, self.last_match)
self.pos = match.end()
self.last_match = match
return True
return False
def backout(self):
self.pos, self.last_match = self._previous_state
def skip_string(self, string):
strlen = len(string)
if self.definition[self.pos:self.pos + strlen] == string:
self.pos += strlen
return True
return False
def skip_word(self, word):
return self.pile(r'\b%s\b' % re.escape(word)))
def skip_ws(self):
return self.match(_whitespace_re)
def eof(self):
return self.pos &= self.end
def current_char(self):
return self.definition[self.pos]
except IndexError:
return 'EOF'
def matched_text(self):
if self.last_match is not None:
return self.last_match.group()
def _parse_operator(self):
self.skip_ws()
# thank god, a regular operator definition
if self.match(_operator_re):
return NameDefExpr('operator' +
_whitespace_re.sub('', self.matched_text))
# new/delete operator?
for allocop in 'new', 'delete':
if not self.skip_word(allocop):
self.skip_ws()
if self.skip_string('['):
self.skip_ws()
if not self.skip_string(']'):
self.fail('expected &]& for ' + allocop)
allocop += '[]'
return NameDefExpr('operator ' + allocop)
# oh well, looks like a cast operator definition.
# In that case, eat another type.
type = self._parse_type()
return CastOpDefExpr(type)
def _parse_name(self):
if not self.match(_identifier_re):
self.fail('expected name')
identifier = self.matched_text
# strictly speaking, operators are not regular identifiers
# but because operator is a keyword, it might not be used
# for variable names anyways, so we can safely parse the
# operator here as identifier
if identifier == 'operator':
return self._parse_operator()
return NameDefExpr(identifier)
def _guess_typename(self, path):
if not path:
return [], 'int'
# for the long type, we don't want the int in there
if 'long' in path:
path = [x for x in path if x != 'int']
# remove one long
path.remove('long')
return path, 'long'
if path[-1] in ('int', 'char'):
return path[:-1], path[-1]
return path, 'int'
def _attach_crefptr(self, expr, is_const=False):
if is_const:
expr = ConstDefExpr(expr, prefix=True)
self.skip_ws()
if self.skip_word('const'):
expr = ConstDefExpr(expr)
elif self.skip_string('*'):
expr = PtrDefExpr(expr)
elif self.skip_string('&'):
expr = RefDefExpr(expr)
return expr
def _peek_const(self, path):
path.remove('const')
return True
except ValueError:
return False
def _parse_builtin(self, modifier):
path = [modifier]
following = self._modifiers[modifier]
self.skip_ws()
if not self.match(_identifier_re):
identifier = self.matched_text
if identifier in following:
path.append(identifier)
following = self._modifiers[modifier]
assert following
self.backout()
is_const = self._peek_const(path)
modifiers, typename = self._guess_typename(path)
rv = ModifierDefExpr(NameDefExpr(typename), modifiers)
return self._attach_crefptr(rv, is_const)
def _parse_type_expr(self):
typename = self._parse_name()
if typename and self.skip_string('['):
typename.name += '['
if self.pile(r'\d*')):
typename.name += self.last_match.group(0)
typename.name += ']'
if not self.skip_string(']'):
self.fail('expected type')
self.skip_ws()
if not self.skip_string('&'):
return typename
self.skip_ws()
if self.skip_string('&'):
if not self.skip_string(','):
self.fail('&,& or &&& in template expected')
self.skip_ws()
args.append(self._parse_type(True))
return TemplateDefExpr(typename, args)
def _parse_type(self, in_template=False):
self.skip_ws()
result = []
modifiers = []
if self.pile(r'template\w*&([^&]*)&')):
args = self.last_match.group(1).split(',')
args = [a.strip() for a in args]
modifiers.append(TemplateDefExpr('template', args))
# if there is a leading :: or not, we don't care because we
# treat them exactly the same.
Buf *if* there is one, we
# don't have to check for type modifiers
if not self.skip_string('::'):
self.skip_ws()
while self.match(_identifier_re):
modifier = self.matched_text
if modifier in self._modifiers:
following = self._modifiers[modifier]
# if the set is not none, there is a limited set
# of types that might follow.
It is technically
# impossible for a template to follow, so what
# we do is go to a different function that just
# eats types
if following is not None:
return self._parse_builtin(modifier)
modifiers.append(modifier)
self.backout()
self.skip_ws()
if (in_template and self.current_char in ',&') or \
(result and not self.skip_string('::')) or \
result.append(self._parse_type_expr())
if not result:
self.fail('expected type')
if len(result) == 1:
rv = result[0]
rv = PathDefExpr(result)
is_const = self._peek_const(modifiers)
if is_const:
rv = ConstDefExpr(rv, prefix=True)
if modifiers:
rv = ModifierDefExpr(rv, modifiers)
return self._attach_crefptr(rv, False)
def _parse_default_expr(self):
self.skip_ws()
if self.match(_string_re):
return self.matched_text
paren_stack_depth = 0
max_pos = len(self.definition)
rv_start = self.pos
idx0 = self.definition.find('(', self.pos)
idx1 = self.definition.find(',', self.pos)
idx2 = self.definition.find(')', self.pos)
if idx0 & 0:
idx0 = max_pos
if idx1 & 0:
idx1 = max_pos
if idx2 & 0:
idx2 = max_pos
idx = min(idx0, idx1, idx2)
if idx &= max_pos:
self.fail('unexpected end in default expression')
if idx == idx0:
paren_stack_depth += 1
elif idx == idx2:
paren_stack_depth -= 1
if paren_stack_depth & 0:
elif paren_stack_depth == 0:
self.pos = idx+1
rv = self.definition[rv_start:idx]
self.pos = idx
def _parse_signature(self):
self.skip_ws()
if not self.skip_string('('):
self.fail('expected parentheses for function')
self.skip_ws()
if self.eof:
self.fail('missing closing parentheses')
if self.skip_string(')'):
if not self.skip_string(','):
self.fail('expected comma between arguments')
self.skip_ws()
argtype = self._parse_type()
argname = default = None
self.skip_ws()
if self.skip_string('='):
self.pos += 1
default = self._parse_default_expr()
elif self.current_char not in ',)':
argname = self._parse_name()
self.skip_ws()
if self.skip_string('='):
default = self._parse_default_expr()
args.append(ArgumentDefExpr(argtype, argname, default))
self.skip_ws()
const = self.skip_word('const')
self.skip_ws()
if self.skip_string('='):
self.skip_ws()
if not (self.skip_string('0') or \
self.skip_word('NULL') or \
self.skip_word('nullptr')):
self.fail('pure virtual functions must be defined with '
'either 0, NULL or nullptr, other macros are '
'not allowed')
pure_virtual = True
pure_virtual = False
return args, const, pure_virtual
def _parse_visibility_static(self):
visibility =
if self.match(_visibility_re):
visibility = self.matched_text
static = self.skip_word('static')
return visibility, static
def parse_type(self):
return self._parse_type()
def parse_type_object(self):
visibility, static = self._parse_visibility_static()
typename = self._parse_type()
self.skip_ws()
if not self.eof:
name = self._parse_type()
name = typename
typename = None
return TypeObjDefExpr(name, visibility, static, typename)
def parse_member_object(self):
visibility, static = self._parse_visibility_static()
typename = self._parse_type()
name = self._parse_type()
self.skip_ws()
if self.skip_string('='):
value = self.read_rest().strip()
value = None
return MemberObjDefExpr(name, visibility, static, typename, value)
def parse_function(self):
visibility, static = self._parse_visibility_static()
if self.skip_word('explicit'):
explicit = True
self.skip_ws()
explicit = False
rv = self._parse_type()
self.skip_ws()
# some things just don't have return values
if self.current_char == '(':
name = self._parse_type()
return FuncDefExpr(name, visibility, static, explicit, rv,
*self._parse_signature())
def parse_class(self):
visibility, static = self._parse_visibility_static()
return ClassDefExpr(self._parse_type(), visibility, static)
def read_rest(self):
rv = self.definition[self.pos:]
self.pos = self.end
def assert_end(self):
self.skip_ws()
if not self.eof:
self.fail('expected end of definition, got %r' %
self.definition[self.pos:])
class OCVObject(ObjectDescription):
&&&Description of a C++ language object.&&&
langname = &C++&
ismember = False
doc_field_types = [
TypedField('parameter', label=l_('Parameters'),
names=('param', 'parameter', 'arg', 'argument'),
typerolename='type', typenames=('type',)),
Field('returnvalue', label=l_('Returns'), has_arg=False,
names=('returns', 'return')),
Field('returntype', label=l_('Return type'), has_arg=False,
names=('rtype',)),
def attach_name(self, node, name):
owner, name = name.split_owner()
varname = unicode(name)
if owner is not None:
owner = unicode(owner) + '::'
node += addnodes.desc_addname(owner, owner)
node += addnodes.desc_name(varname, varname)
def attach_type(self, node, type):
# XXX: link to c?
text = unicode(type)
pnode = addnodes.pending_xref(
'', refdomain='ocv', reftype='type',
reftarget=text, modname=None, classname=None)
pnode['ocv:parent'] = self.env.temp_data.get('ocv:parent')
pnode += nodes.Text(text)
node += pnode
def attach_modifiers(self, node, obj):
if not self.__class__.ismember:
lname = self.__class__.langname
node += nodes.strong(lname + &:&, lname + &:&)
node += addnodes.desc_name(& &, & &)
if obj.visibility != 'public':
node += addnodes.desc_annotation(obj.visibility,
obj.visibility)
node += nodes.Text(' ')
if obj.static:
node += addnodes.desc_annotation('static', 'static')
node += nodes.Text(' ')
def add_target_and_index(self, sigobj, sig, signode):
theid = sig#obj.get_id()
theid = re.sub(r& +&, & &, theid)
theid = re.sub(r&=[^,()]+\([^)]*?\)[^,)]*(,|\))&, &\\1&, theid)
theid = re.sub(r&=\w*[^,)(]+(,|\))&, &\\1&, theid)
theid = theid.replace(&( &, &(&).replace(& )&, &)&)
name = unicode(sigobj.name)
if theid not in self.state.document.ids:
signode['names'].append(theid)
signode['ids'].append(theid)
signode['first'] = (not self.names)
self.state.document.note_explicit_target(signode)
#self.env.domaindata['ocv']['objects'].setdefault(name,
#(self.env.docname, self.objtype, theid))
self.env.domaindata['ocv']['objects'].setdefault(theid,
(self.env.docname, self.objtype, theid))
self.env.domaindata['ocv']['objects2'].setdefault(name,
(self.env.docname, self.objtype, theid))
indextext = self.get_index_text(name)
if indextext:
self.indexnode['entries'].append(('single', indextext, theid, name))
def before_content(self):
lastname = self.names and self.names[-1]
if lastname and not self.env.temp_data.get('ocv:parent'):
assert isinstance(lastname, NamedDefExpr)
self.env.temp_data['ocv:parent'] = lastname.name
self.parentname_set = True
self.parentname_set = False
def after_content(self):
if self.parentname_set:
self.env.temp_data['ocv:parent'] = None
def parse_definition(self, parser):
raise NotImplementedError()
def describe_signature(self, signode, arg):
raise NotImplementedError()
def handle_signature(self, sig, signode):
parser = DefinitionParser(sig)
rv = self.parse_definition(parser)
parser.assert_end()
except DefinitionError, e:
self.env.warn(self.env.docname,
e.description, self.lineno)
raise ValueError
self.describe_signature(signode, rv)
parent = self.env.temp_data.get('ocv:parent')
if parent is not None:
rv = rv.clone()
rv.name = rv.name.prefix(parent)
class OCVClassObject(OCVObject):
object_annotation = &class &
object_long_name = &class&
def attach_modifiers(self, node, obj):
if obj.visibility != 'public':
node += addnodes.desc_annotation(obj.visibility,
obj.visibility)
node += nodes.Text(' ')
if obj.static:
node += addnodes.desc_annotation('static', 'static')
node += nodes.Text(' ')
def get_index_text(self, name):
return _('%s (C++ %s)') % (name, self.__class__.object_long_name)
def parse_definition(self, parser):
return parser.parse_class()
def describe_signature(self, signode, cls):
self.attach_modifiers(signode, cls)
signode += addnodes.desc_annotation(self.__class__.object_annotation, self.__class__.object_annotation)
self.attach_name(signode, cls.name)
class OCVStructObject(OCVClassObject):
object_annotation = &struct &
object_long_name = &structure&
class OCVTypeObject(OCVObject):
def get_index_text(self, name):
if self.objtype == 'type':
return _('%s (C++ type)') % name
def parse_definition(self, parser):
return parser.parse_type_object()
def describe_signature(self, signode, obj):
self.attach_modifiers(signode, obj)
signode += addnodes.desc_annotation('type ', 'type ')
if obj.typename is not None:
self.attach_type(signode, obj.typename)
signode += nodes.Text(' ')
self.attach_name(signode, obj.name)
class OCVMemberObject(OCVObject):
ismember = True
def get_index_text(self, name):
if self.objtype == 'member':
return _('%s (C++ member)') % name
def parse_definition(self, parser):
return parser.parse_member_object()
def describe_signature(self, signode, obj):
self.attach_modifiers(signode, obj)
self.attach_type(signode, obj.typename)
signode += nodes.Text(' ')
self.attach_name(signode, obj.name)
if obj.value is not None:
signode += nodes.Text(u' = ' + obj.value)
class OCVFunctionObject(OCVObject):
def attach_function(self, node, func):
owner, name = func.name.split_owner()
if owner is not None:
owner = unicode(owner) + '::'
node += addnodes.desc_addname(owner, owner)
# cast operator is special.
in this case the return value
# is reversed.
if isinstance(name, CastOpDefExpr):
node += addnodes.desc_name('operator', 'operator')
node += nodes.Text(u' ')
self.attach_type(node, name.typename)
funcname = unicode(name)
node += addnodes.desc_name(funcname, funcname)
paramlist = addnodes.desc_parameterlist()
for arg in func.signature:
param = addnodes.desc_parameter('', '', noemph=True)
if arg.type is not None:
self.attach_type(param, arg.type)
param += nodes.Text(u' ')
#param += nodes.emphasis(unicode(arg.name), unicode(arg.name))
param += nodes.strong(unicode(arg.name), unicode(arg.name))
if arg.default is not None:
def_ = u'=' + unicode(arg.default)
#param += nodes.emphasis(def_, def_)
param += nodes.Text(def_)
paramlist += param
node += paramlist
if func.const:
node += addnodes.desc_addname(' const', ' const')
if func.pure_virtual:
node += addnodes.desc_addname(' = 0', ' = 0')
def get_index_text(self, name):
lname = self.__class__.langname
if lname == &C& and name.startswith(&cv&):
name = name[2:]
return _('%s (%s function)') % (name, lname)
def parse_definition(self, parser):
return parser.parse_function()
def describe_signature(self, signode, func):
self.attach_modifiers(signode, func)
if func.explicit:
signode += addnodes.desc_annotation('explicit', 'explicit')
signode += nodes.Text(' ')
# return value is None for things with a reverse return value
# such as casting operator definitions or constructors
# and destructors.
if func.rv is not None:
self.attach_type(signode, func.rv)
signode += nodes.Text(u' ')
self.attach_function(signode, func)
class OCVCurrentNamespace(Directive):
&&&This directive is just to tell Sphinx that we're documenting
stuff in namespace foo.
has_content = False
required_arguments = 1
optional_arguments = 0
final_argument_whitespace = True
option_spec = {
def run(self):
env = self.state.document.settings.env
if self.arguments[0].strip() in ('NULL', '0', 'nullptr'):
env.temp_data['ocv:prefix'] = None
parser = DefinitionParser(self.arguments[0])
prefix = parser.parse_type()
parser.assert_end()
except DefinitionError, e:
self.env.warn(self.env.docname,
e.description, self.lineno)
env.temp_data['ocv:prefix'] = prefix
class OCVXRefRole(XRefRole):
def process_link(self, env, refnode, has_explicit_title, title, target):
refnode['ocv:parent'] = env.temp_data.get('ocv:parent')
if not has_explicit_title:
target = target.lstrip('~') # only has a meaning for the title
# if the first character is a tilde, don't display the module/class
# parts of the contents
if title[:1] == '~':
title = title[1:]
dcolon = title.rfind('::')
if dcolon != -1:
title = title[dcolon + 2:]
return title, target
class OCVCFunctionObject(OCVFunctionObject):
langname = &C&
class OCVJavaFunctionObject(OCVFunctionObject):
langname = &Java&
class OCVDomain(Domain):
&&&OpenCV C++ language domain.&&&
name = 'ocv'
label = 'C++'
object_types = {
ObjType(l_('class'),
ObjType(l_('struct'),
'struct'),
'function': ObjType(l_('function'), 'func', 'funcx'),
'cfunction': ObjType(l_('cfunction'), 'cfunc', 'cfuncx'),
'jfunction': ObjType(l_('jfunction'), 'jfunc', 'jfuncx'),
'pyfunction': ObjType(l_('pyfunction'), 'pyfunc'),
'pyoldfunction': ObjType(l_('pyoldfunction'), 'pyoldfunc'),
ObjType(l_('member'),
'member'),
ObjType(l_('type'),
directives = {
OCVClassObject,
OCVStructObject,
'function':
OCVFunctionObject,
'cfunction':
OCVCFunctionObject,
'jfunction':
OCVJavaFunctionObject,
'pyfunction':
OCVPyModulelevel,
'pyoldfunction':
OCVPyOldModulelevel,
OCVMemberObject,
OCVTypeObject,
'namespace':
OCVCurrentNamespace
OCVXRefRole(),
OCVXRefRole(),
OCVXRefRole(fix_parens=True),
OCVXRefRole(),
OCVXRefRole(fix_parens=True),
'cfuncx' :
OCVXRefRole(),
OCVXRefRole(fix_parens=True),
'jfuncx' :
OCVXRefRole(),
'pyfunc' :
OCVPyXRefRole(),
'pyoldfunc' :
OCVPyXRefRole(),
'member': OCVXRefRole(),
OCVXRefRole()
initial_data = {
'objects': {
# fullname -& docname, objtype
def __init__(self, env):
Domain.__init__(self, env)
self.data['objects2'] = {
def clear_doc(self, docname):
for fullname, (fn, _, _) in self.data['objects'].items():
if fn == docname:
del self.data['objects'][fullname]
def resolve_xref(self, env, fromdocname, builder,
typ, target, node, contnode):
def _create_refnode(expr):
name = unicode(expr)
if &type& in self.objtypes_for_role(typ):
return None
if &cfunction& in self.objtypes_for_role(typ):
if not name.startswith(u'cv'):
name = u'cv' + name
dict = self.data['objects']
if name not in dict:
dict = self.data['objects2']
if name not in dict:
refdoc = node.get('refdoc', fromdocname)
env.warn(refdoc, 'unresolved reference: %r - %r' % (target, typ), node.line)
return None
obj = dict[name]
if obj[1] not in self.objtypes_for_role(typ):
return None
title = obj[2]
if &class& in self.objtypes_for_role(typ):
title = u&class & + title
elif &struct& in self.objtypes_for_role(typ):
title = u&struct & + title
return make_refnode(builder, fromdocname, obj[0], obj[2],
contnode, title)
parser = DefinitionParser(target)
expr = parser.parse_type().get_name()
parser.skip_ws()
if not parser.eof or expr is None:
raise DefinitionError('')
except DefinitionError:
refdoc = node.get('refdoc', fromdocname)
env.warn(refdoc, 'unparseable C++ definition: %r' % target,
node.line)
return None
parent = node['ocv:parent']
rv = _create_refnode(expr)
if rv is not None or parent is None:
parent = parent.get_name()
rv = _create_refnode(expr.prefix(parent))
if rv is not None:
parent, name = parent.split_owner()
return _create_refnode(expr.prefix(parent))
def get_objects(self):
for refname, (docname, type, theid) in self.data['objects'].iteritems():
yield (refname, refname, type, docname, refname, 1)
def get_type_name(self, type, primary=False):
Return full name for given ObjType.
if primary:
return type.lname
_('C++ class'),
_('C/C++ struct'),
'function':
_('C++ function'),
'cfunction':
_('C function'),
'jfunction':
_('Java method'),
'pyfunction':
_('Python function'),
'pyoldfunction': _('Legacy Python function'),
_('C++ member'),
_('C/C++ type'),
'namespace':
_('C++ namespace'),
}.get(type.lname, _('%s %s') % (self.label, type.lname))
def setup(app):
app.add_domain(OCVDomain)
源码下载: &
源码文件列表
温馨提示： 点击源码文件名可预览文件内容哦 ^_^
名称大小日期
&.gitignore6.00 B 14:09
&AUTHORS.md181.00 B 14:09
&2.56 kB 14:09
&3.24 kB 14:09
&5.46 kB 14:09
&.buildinfo230.00 B 14:09
&clooney.png91.45 kB 14:09
&colorscale_autumn.jpg1.32 kB 14:09
&colorscale_bone.jpg1.29 kB 14:09
&colorscale_cool.jpg1.29 kB 14:09
&colorscale_hot.jpg1.37 kB 14:09
&colorscale_hsv.jpg1.65 kB 14:09
&colorscale_jet.jpg1.54 kB 14:09
&colorscale_mkpj1.jpg1.53 kB 14:09
&colorscale_mkpj2.jpg1.48 kB 14:09
&colorscale_ocean.jpg1.40 kB 14:09
&colorscale_pink.jpg1.36 kB 14:09
&colorscale_rainbow.jpg1.49 kB 14:09
&colorscale_spring.jpg1.22 kB 14:09
&colorscale_summer.jpg1.31 kB 14:09
&colorscale_winter.jpg1.21 kB 14:09
&eigenfaces_at.png128.33 kB 14:09
&fisherface_0.png34.64 kB 14:09
&fisherfaces_yale_a.png224.13 kB 14:09
&lena.jpg89.66 kB 14:09
&lena_autumn.jpg87.66 kB 14:09
&lena_bone.jpg93.93 kB 14:09
&lena_cool.jpg70.40 kB 14:09
&lena_hot.jpg118.91 kB 14:09
&lena_hsv.jpg158.30 kB 14:09
&lena_imshow_jet.jpg224.67 kB 14:09
&lena_jet.jpg149.53 kB 14:09
&lena_mkpj1.jpg131.20 kB 14:09
&lena_mkpj2.jpg116.75 kB 14:09
&lena_ocean.jpg95.75 kB 14:09
&lena_pink.jpg90.79 kB 14:09
&lena_rainbow.jpg144.69 kB 14:09
&lena_spring.jpg89.20 kB 14:09
&lena_summer.jpg85.84 kB 14:09
&lena_winter.jpg88.88 kB 14:09
&06d1fc0c65d69bafbb567bc.png586.00 B 14:09
&23122d6beb2bac592db304b3bbda7b0f28ae1451.png527.00 B 14:09
&26eebacf8fe96b2aa5e6.png158.00 B 14:09
&2c2f0f999b4f370cfdc4a3762deb.png423.00 B 14:09
&2d8c833edcd7bd2fb9de1a12ad7e674.png184.00 B 14:09
&35be26e2d47841ccd1f186ec1bf4ba.png318.00 B 14:09
&40aaba40c8de27cbabb7bca7ab7fc3dc4b1c47b1.png204.00 B 14:09
&50bb4f1a115c4ecb8faf.png310.00 B 14:09
&f45eea10.png545.00 B 14:09
&e0aadc7b8cd15d5858.png341.00 B 14:09
&8c304bbcc0f61f64f.png186.00 B 14:09
&b6b57d22bfd7d59cb0.png289.00 B 14:09
&a03a8d0a72d8ef7ea.png369.00 B 14:09
&ad28c83c99a8fd0dd2e2e594c9d02eea.png189.00 B 14:09
&bfcaf567.png352.00 B 14:09
&c008cbe0d83c94d22cf5194f9ade05a.png560.00 B 14:09
&cfdef60ac28d7e9ff5f6f807e7966.png589.00 B 14:09
&d90aec1b84cbaf3a3b5f4ccd17894b.png185.00 B 14:09
&d9f465a64e2dddf7dbd22.png926.00 B 14:09
&db15d2de2dcd2bdcbd0f.png439.00 B 14:09
&e4d596b8ec2caab536df81b88711.png490.00 B 14:09
&stored_loaded_eigenfaces_at.png128.43 kB 14:09
&401.00 B 14:09
&6.09 kB 14:09
&4.68 kB 14:09
&4.85 kB 14:09
&5.72 kB 14:09
&2.93 kB 14:09
&4.82 kB 14:09
&3.48 kB 14:09
&3.58 kB 14:09
&6.78 kB 14:09
&3.16 kB 14:09
&4.40 kB 14:09
&483.00 B 14:09
&1.31 kB 14:09
&1.09 kB 14:09
&431.00 B 14:09
&3.05 kB 14:09
&4.44 kB 14:09
&26.00 B 14:09
&3.35 kB 14:09
&68.00 B 14:09
&491.00 B 14:09
&ajax-loader.gif673.00 B 14:09
&8.26 kB 14:09
&comment-bright.png3.42 kB 14:09
&comment-close.png3.49 kB 14:09
&comment.png3.36 kB 14:09
&3.95 kB 14:09
&6.68 kB 14:09
&down-pressed.png368.00 B 14:09
&down.png363.00 B 14:09
&file.png392.00 B 14:09
&70.48 kB 14:09
&minus.png199.00 B 14:09
&plus.png199.00 B 14:09
&3.84 kB 14:09
&15.67 kB 14:09
&4.63 kB 14:09
&8.37 kB 14:09
&up-pressed.png372.00 B 14:09
&up.png363.00 B 14:09
&24.65 kB 14:09
&10.54 kB 14:09
&21.77 kB 14:09
&19.15 kB 14:09
&21.14 kB 14:09
&21.69 kB 14:09
&15.97 kB 14:09
&17.61 kB 14:09
&17.86 kB 14:09
&18.08 kB 14:09
&21.96 kB 14:09
&15.87 kB 14:09
&19.66 kB 14:09
&7.89 kB 14:09
&6.33 kB 14:09
&6.55 kB 14:09
&12.09 kB 14:09
&6.36 kB 14:09
&objects.inv880.00 B 14:09
&3.04 kB 14:09
&18.29 kB 14:09
&6.61 kB 14:09
&19.00 kB 14:09
&3.02 kB 14:09
&6.82 kB 14:09
&3.10 kB 14:09
&7.44 kB 14:09
&4.99 kB 14:09
&colormaps.rst4.83 kB 14:09
&7.60 kB 14:09
&16.65 kB 14:09
&facerec_api.rst16.18 kB 14:09
&facerec_changelog.rst2.91 kB 14:09
&facerec_tutorial.rst37.14 kB 14:09
&at_database_small_sample_size.png32.88 kB 14:09
&colorscale_autumn.jpg1.32 kB 14:09
&colorscale_bone.jpg1.29 kB 14:09
&colorscale_cool.jpg1.29 kB 14:09
&colorscale_hot.jpg1.37 kB 14:09
&colorscale_hsv.jpg1.65 kB 14:09
&colorscale_jet.jpg1.54 kB 14:09
&colorscale_mkpj1.jpg1.53 kB 14:09
&colorscale_mkpj2.jpg1.48 kB 14:09
&colorscale_ocean.jpg1.40 kB 14:09
&colorscale_pink.jpg1.36 kB 14:09
&colorscale_rainbow.jpg1.49 kB 14:09
&colorscale_spring.jpg1.22 kB 14:09
&colorscale_summer.jpg1.31 kB 14:09
&colorscale_winter.jpg1.21 kB 14:09
&eigenface_reconstruction_opencv.png171.08 kB 14:09
&eigenfaces_opencv.png107.62 kB 14:09
&fisherface_reconstruction_opencv.png111.08 kB 14:09
&fisherfaces_opencv.png281.08 kB 14:09
&lbp.png15.33 kB 14:09
&lbp_yale.jpg83.14 kB 14:09
&patterns.png17.75 kB 14:09
&facerec_video.png289.76 kB 14:09
&arnie_10_10_200_200.jpg5.39 kB 14:09
&arnie_20_20_200_200.jpg6.18 kB 14:09
&arnie_20_20_70_70.jpg1.77 kB 14:09
&arnie_30_30_200_200.jpg7.15 kB 14:09
&clooney_set.png91.45 kB 14:09
&fisherface_0.png35.98 kB 14:09
&fisherface_reconstruction_0.png10.27 kB 14:09
&mean.png9.95 kB 14:09
&index.rst1.58 kB 14:09
&50.52 kB 14:09
&941.00 B 14:09
&3.89 kB 14:09
&6.40 kB 14:09
&7.38 kB 14:09
&7.34 kB 14:09
&6.19 kB 14:09
&7.63 kB 14:09
&6.67 kB 14:09
&facerec_gender_classification.rst10.69 kB 14:09
&facerec_save_load.rst1.78 kB 14:09
&facerec_video_recognition.rst9.60 kB 14:09
&23.38 kB 14:09
&3.51 kB 14:09
&4.42 kB 14:09
&2.78 kB 14:09
&3.47 kB 14:09
&3.15 kB 14:09
&6.41 kB 14:09
&7.42 kB 14:09
&7.35 kB 14:09
&6.21 kB 14:09
&6.68 kB 14:09
&46.38 kB 14:09
&1.05 kB 14:09
&29.03 kB 14:09
&9.97 kB 14:09
&8.79 kB 14:09
&5.75 kB 14:09
&9.16 kB 14:09
&11.31 kB 14:09
&2.23 kB 14:09
&12.33 kB 14:09
&4.24 kB 14:09
&2.56 kB 14:09
&88.00 B 14:09
&1.08 kB 14:09
Sponsored links
23 篇源代码 21 篇源代码 18 篇源代码 13 篇源代码 9 篇源代码
285 篇源代码 173 篇源代码 48 篇源代码 42 篇源代码 36 篇源代码
登录 CodeForge
还没有CodeForge账号？
Switch to the English version?
CF仔没有找到您要的代码，请去留下您的问题吧，可能会有大神帮助你哦！
该用户暂时未开通博客
请按 Ctrl+D 键添加到收藏夹。