C++ PyDoc_STR函数代码示例

                          AEDesc_Convert, &contextName,
                          &parentContext))
        return NULL;
    _err = OSAMakeContext(_self->ob_itself,
                          &contextName,
                          parentContext,
                          &resultingContextID);
    if (_err != noErr) return PyMac_Error(_err);
    _res = Py_BuildValue("l",
                         resultingContextID);
    return _res;
}

static PyMethodDef OSAObj_methods[] = {
    {"OSALoad", (PyCFunction)OSAObj_OSALoad, 1,
     PyDoc_STR("(AEDesc scriptData, long modeFlags) -> (OSAID resultingScriptID)")},
    {"OSAStore", (PyCFunction)OSAObj_OSAStore, 1,
     PyDoc_STR("(OSAID scriptID, DescType desiredType, long modeFlags) -> (AEDesc resultingScriptData)")},
    {"OSAExecute", (PyCFunction)OSAObj_OSAExecute, 1,
     PyDoc_STR("(OSAID compiledScriptID, OSAID contextID, long modeFlags) -> (OSAID resultingScriptValueID)")},
    {"OSADisplay", (PyCFunction)OSAObj_OSADisplay, 1,
     PyDoc_STR("(OSAID scriptValueID, DescType desiredType, long modeFlags) -> (AEDesc resultingText)")},
    {"OSAScriptError", (PyCFunction)OSAObj_OSAScriptError, 1,
     PyDoc_STR("(OSType selector, DescType desiredType) -> (AEDesc resultingErrorDescription)")},
    {"OSADispose", (PyCFunction)OSAObj_OSADispose, 1,
     PyDoc_STR("(OSAID scriptID) -> None")},
    {"OSASetScriptInfo", (PyCFunction)OSAObj_OSASetScriptInfo, 1,
     PyDoc_STR("(OSAID scriptID, OSType selector, long value) -> None")},
    {"OSAGetScriptInfo", (PyCFunction)OSAObj_OSAGetScriptInfo, 1,
     PyDoc_STR("(OSAID scriptID, OSType selector) -> (long result)")},
    {"OSAScriptingComponentName", (PyCFunction)OSAObj_OSAScriptingComponentName, 1,

	if (!PyArg_ParseTuple(_args, "hl",
	                      &vRefNum,
	                      &dirID))
		return NULL;
	_err = IdentifyFolder(vRefNum,
	                      dirID,
	                      &foldType);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     PyMac_BuildOSType, foldType);
	return _res;
}

static PyMethodDef Folder_methods[] = {
	{"FindFolder", (PyCFunction)Folder_FindFolder, 1,
	 PyDoc_STR("(short vRefNum, OSType folderType, Boolean createFolder) -> (short foundVRefNum, long foundDirID)")},
	{"ReleaseFolder", (PyCFunction)Folder_ReleaseFolder, 1,
	 PyDoc_STR("(short vRefNum, OSType folderType) -> None")},
	{"FSFindFolder", (PyCFunction)Folder_FSFindFolder, 1,
	 PyDoc_STR("(short vRefNum, OSType folderType, Boolean createFolder) -> (FSRef foundRef)")},
	{"AddFolderDescriptor", (PyCFunction)Folder_AddFolderDescriptor, 1,
	 PyDoc_STR("(FolderType foldType, FolderDescFlags flags, FolderClass foldClass, FolderLocation foldLocation, OSType badgeSignature, OSType badgeType, Str255 name, Boolean replaceFlag) -> None")},
	{"GetFolderTypes", (PyCFunction)Folder_GetFolderTypes, 1,
	 PyDoc_STR("(UInt32 requestedTypeCount) -> (UInt32 totalTypeCount, FolderType theTypes)")},
	{"RemoveFolderDescriptor", (PyCFunction)Folder_RemoveFolderDescriptor, 1,
	 PyDoc_STR("(FolderType foldType) -> None")},
#ifndef __LP64__
	{"GetFolderName", (PyCFunction)Folder_GetFolderName, 1,
	 PyDoc_STR("(short vRefNum, OSType foldType, Str255 name) -> (short foundVRefNum)")},
	{"AddFolderRouting", (PyCFunction)Folder_AddFolderRouting, 1,
	 PyDoc_STR("(OSType fileType, FolderType routeFromFolder, FolderType routeToFolder, RoutingFlags flags, Boolean replaceFlag) -> None")},

                          OptResObj_Convert, &mouseregion))
        return NULL;
    _rv = WaitNextEvent(eventMask,
                        &theEvent,
                        sleep,
                        (RgnHandle)mouseregion);
    _res = Py_BuildValue("bO&",
                         _rv,
                         PyMac_BuildEventRecord, &theEvent);
    return _res;

}

static PyMethodDef Evt_methods[] = {
    {"GetMouse", (PyCFunction)Evt_GetMouse, 1,
     PyDoc_STR("() -> (Point mouseLoc)")},
    {"Button", (PyCFunction)Evt_Button, 1,
     PyDoc_STR("() -> (Boolean _rv)")},
    {"StillDown", (PyCFunction)Evt_StillDown, 1,
     PyDoc_STR("() -> (Boolean _rv)")},
    {"WaitMouseUp", (PyCFunction)Evt_WaitMouseUp, 1,
     PyDoc_STR("() -> (Boolean _rv)")},
    {"GetCaretTime", (PyCFunction)Evt_GetCaretTime, 1,
     PyDoc_STR("() -> (UInt32 _rv)")},
    {"GetKeys", (PyCFunction)Evt_GetKeys, 1,
     PyDoc_STR("() -> (KeyMap theKeys)")},
    {"GetDblTime", (PyCFunction)Evt_GetDblTime, 1,
     PyDoc_STR("() -> (UInt32 _rv)")},
    {"SetEventMask", (PyCFunction)Evt_SetEventMask, 1,
     PyDoc_STR("(EventMask value) -> None")},
    {"GetNextEvent", (PyCFunction)Evt_GetNextEvent, 1,

 *  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
 *  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser Public License
 *  along with the ZBar Bar Code Reader; if not, write to the Free
 *  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
 *  Boston, MA  02110-1301  USA
 *
 *  http://sourceforge.net/projects/zbar
 *------------------------------------------------------------------------*/

#include "zbarmodule.h"

static char symbolset_doc[] = PyDoc_STR(
    "symbol result container.\n"
    "\n"
    "collection of symbols.");

static int
symbolset_clear (zbarSymbolSet *self)
{
    if(self->zsyms) {
        zbar_symbol_set_t *zsyms = (zbar_symbol_set_t*)self->zsyms;
        self->zsyms = NULL;
        zbar_symbol_set_ref(zsyms, -1);
    }
    return(0);
}

static void
symbolset_dealloc (zbarSymbolSet *self)

    Py_INCREF(Py_None);
    return Py_None;
}

void converters_init(PyObject* dict)
{
    converters = PyDict_New();
    if (!converters) {
        return;
    }

    PyDict_SetItemString(dict, "converters", converters);
}

static PyMethodDef module_methods[] = {
    {"connect",  (PyCFunction)module_connect,  METH_VARARGS|METH_KEYWORDS, PyDoc_STR("Creates a connection.")},
    {"complete_statement",  (PyCFunction)module_complete,  METH_VARARGS|METH_KEYWORDS, PyDoc_STR("Checks if a string contains a complete SQL statement. Non-standard.")},
#ifdef HAVE_SHARED_CACHE
    {"enable_shared_cache",  (PyCFunction)module_enable_shared_cache,  METH_VARARGS|METH_KEYWORDS, PyDoc_STR("Enable or disable shared cache mode for the calling thread. Experimental/Non-standard.")},
#endif
    {"register_adapter", (PyCFunction)module_register_adapter, METH_VARARGS, PyDoc_STR("Registers an adapter with pysqlite's adapter registry. Non-standard.")},
    {"register_converter", (PyCFunction)module_register_converter, METH_VARARGS, PyDoc_STR("Registers a converter with pysqlite. Non-standard.")},
    {"adapt",  (PyCFunction)psyco_microprotocols_adapt, METH_VARARGS, psyco_microprotocols_adapt_doc},
    {"enable_callback_tracebacks",  (PyCFunction)enable_callback_tracebacks, METH_VARARGS, PyDoc_STR("Enable or disable callback functions throwing errors to stderr.")},
    {NULL, NULL}
};

struct _IntConstantPair {
    char* constant_name;
    int constant_value;
};

static int
__Pyx_Generator_set_qualname(__pyx_GeneratorObject *self, PyObject *value)
{
    PyObject *tmp;

#if PY_MAJOR_VERSION >= 3
    if (unlikely(value == NULL || !PyUnicode_Check(value))) {
#else
    if (unlikely(value == NULL || !PyString_Check(value))) {
#endif
        PyErr_SetString(PyExc_TypeError,
                        "__qualname__ must be set to a string object");
        return -1;
    }
    tmp = self->gi_qualname;
    Py_INCREF(value);
    self->gi_qualname = value;
    Py_XDECREF(tmp);
    return 0;
}

static PyGetSetDef __pyx_Generator_getsets[] = {
    {(char *) "__name__", (getter)__Pyx_Generator_get_name, (setter)__Pyx_Generator_set_name,
     (char*) PyDoc_STR("name of the generator"), 0},
    {(char *) "__qualname__", (getter)__Pyx_Generator_get_qualname, (setter)__Pyx_Generator_set_qualname,
     (char*) PyDoc_STR("qualified name of the generator"), 0},
    {0, 0, 0, 0, 0}
};

static PyMemberDef __pyx_Generator_memberlist[] = {
    {(char *) "gi_running", T_BOOL, offsetof(__pyx_GeneratorObject, is_running), READONLY, NULL},
    {0, 0, 0, 0, 0}
};

static PyMethodDef __pyx_Generator_methods[] = {
    {"send", (PyCFunction) __Pyx_Generator_Send, METH_O, 0},
    {"throw", (PyCFunction) __Pyx_Generator_Throw, METH_VARARGS, 0},
    {"close", (PyCFunction) __Pyx_Generator_Close, METH_NOARGS, 0},
    {0, 0, 0, 0}
};

static PyTypeObject __pyx_GeneratorType_type = {
    PyVarObject_HEAD_INIT(0, 0)
    "generator",                        /*tp_name*/
    sizeof(__pyx_GeneratorObject),      /*tp_basicsize*/
    0,                                  /*tp_itemsize*/
    (destructor) __Pyx_Generator_dealloc,/*tp_dealloc*/
    0,                                  /*tp_print*/
    0,                                  /*tp_getattr*/
    0,                                  /*tp_setattr*/
#if PY_MAJOR_VERSION < 3
    0,                                  /*tp_compare*/
#else
    0,                                  /*reserved*/
#endif
    0,                                  /*tp_repr*/
    0,                                  /*tp_as_number*/
    0,                                  /*tp_as_sequence*/
    0,                                  /*tp_as_mapping*/
    0,                                  /*tp_hash*/
    0,                                  /*tp_call*/
    0,                                  /*tp_str*/
    0,                                  /*tp_getattro*/
    0,                                  /*tp_setattro*/
    0,                                  /*tp_as_buffer*/
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
    0,                                  /*tp_doc*/
    (traverseproc) __Pyx_Generator_traverse,   /*tp_traverse*/
    0,                                  /*tp_clear*/
    0,                                  /*tp_richcompare*/
    offsetof(__pyx_GeneratorObject, gi_weakreflist), /*tp_weaklistoffset*/
    0,                                  /*tp_iter*/
    (iternextfunc) __Pyx_Generator_Next, /*tp_iternext*/
    __pyx_Generator_methods,            /*tp_methods*/
    __pyx_Generator_memberlist,         /*tp_members*/
    __pyx_Generator_getsets,            /*tp_getset*/
    0,                                  /*tp_base*/
    0,                                  /*tp_dict*/
    0,                                  /*tp_descr_get*/
    0,                                  /*tp_descr_set*/
    0,                                  /*tp_dictoffset*/
    0,                                  /*tp_init*/
    0,                                  /*tp_alloc*/
    0,                                  /*tp_new*/
    0,                                  /*tp_free*/
    0,                                  /*tp_is_gc*/
    0,                                  /*tp_bases*/
    0,                                  /*tp_mro*/
    0,                                  /*tp_cache*/
    0,                                  /*tp_subclasses*/
    0,                                  /*tp_weaklist*/
#if PY_VERSION_HEX >= 0x030400a1
    0,                                  /*tp_del*/
#else
    __Pyx_Generator_del,                /*tp_del*/
#endif
    0,                                  /*tp_version_tag*/
#if PY_VERSION_HEX >= 0x030400a1
    __Pyx_Generator_del,                /*tp_finalize*/
#endif
//.........这里部分代码省略.........

		    args, kwds, "O!:eval_string", kwlist,
		    &PyString_Type, &string_arg))
		return NULL;

	PyObject *result = scm_with_guile(
		(void *(*)(void *))eval_string_wrapper, string_arg);
	if (result == NULL && !PyErr_Occurred())
		PyErr_SetNone(guile_error);
	return result;
}

static PyMethodDef methods[] = {
	{ "lookup",
	  (PyCFunction)lookup, METH_KEYWORDS,
	  PyDoc_STR("lookup(name)\n\n"
		    "Return the variable bound to the symbol indicated by "
		    "name.  If there\nis no such binding or the symbol is not "
		    "bound to a variable, signal\nan error.") },
	{ "define",
	  (PyCFunction)define, METH_KEYWORDS,
	  PyDoc_STR("define(name, value)\n\n"
		    "Create a top level variable.  If the named variable "
		    "already exists,\njust change its value.") },
	{ "load",
	  (PyCFunction)load, METH_KEYWORDS,
	  PyDoc_STR("load(name)\n\n"
		    "Load a file and evaluate its contents "
		    "in the top-level environment.") },
	{ "eval_string",
	  (PyCFunction)eval_string, METH_KEYWORDS,
	  PyDoc_STR("eval_string(string)\n\n"
		    "Parse string as Scheme, and evaluate the expressions it "

        else {
            const char *name = PyModule_GetName(self);
            if (name)
                PyErr_Format(PyExc_TypeError,
                             "%.200s.__dict__ is not a dictionary",
                             name);
        }
    }

    Py_XDECREF(dict);
    return result;
}

static PyMethodDef module_methods[] = {
    {"__dir__", module_dir, METH_NOARGS,
     PyDoc_STR("__dir__() -> list\nspecialized dir() implementation")},
    {0}
};


PyDoc_STRVAR(module_doc,
"module(name[, doc])\n\
\n\
Create a module object.\n\
The name must be a string; the optional doc argument can have any type.");

PyTypeObject PyModule_Type = {
    PyVarObject_HEAD_INIT(&PyType_Type, 0)
    "module",                                   /* tp_name */
    sizeof(PyModuleObject),                     /* tp_size */
    0,                                          /* tp_itemsize */

	self->data.angle0 = angle0_arg;
	self->data.pitch0 = pitch0_arg;
	self->data.angle1 = angle1_arg;
	self->data.pitch1 = pitch1_arg;

	return 0;
}

static void FillAttr_dealloc(FillAttr *self)
{
	self->ob_type->tp_free((PyObject *)self);
}

static PyMemberDef FillAttr_members[] = {
	{ "type", T_INT, offsetof(FillAttr, data.type), 0,
	  PyDoc_STR("") },
	{ "width", T_DOUBLE, offsetof(FillAttr, data.width), 0,
	  PyDoc_STR("") },
	{ "angle0", T_INT, offsetof(FillAttr, data.angle0), 0,
	  PyDoc_STR("") },
	{ "pitch0", T_DOUBLE, offsetof(FillAttr, data.pitch0), 0,
	  PyDoc_STR("") },
	{ "angle1", T_INT, offsetof(FillAttr, data.angle1), 0,
	  PyDoc_STR("") },
	{ "pitch1", T_DOUBLE, offsetof(FillAttr, data.pitch1), 0,
	  PyDoc_STR("") },
	{ NULL }  /* Sentinel */
};

PyTypeObject FillAttrType = {
	PyObject_HEAD_INIT(NULL)

error:
  if(ops != &_tnetstring_ops_bytes) {
      free(ops);
      Py_DECREF(encoding);
  }
  Py_DECREF(object);
  return NULL;
}


static PyMethodDef _tnetstring_methods[] = {
    {"load",
     (PyCFunction)_tnetstring_load,
     METH_VARARGS,
     PyDoc_STR("load(file,encoding=None) -> object\n"
               "This function reads a tnetstring from a file and parses it\n"
               "into a python object.")},

    {"loads",
     (PyCFunction)_tnetstring_loads,
     METH_VARARGS,
     PyDoc_STR("loads(string,encoding=None) -> object\n"
               "This function parses a tnetstring into a python object.")},

    {"pop",
     (PyCFunction)_tnetstring_pop,
     METH_VARARGS,
     PyDoc_STR("pop(string,encoding=None) -> (object, remain)\n"
               "This function parses a tnetstring into a python object.\n"
               "It returns a tuple giving the parsed object and a string\n"
               "containing any unparsed data.")},

static PyObject *
LRU_get_size(LRU *self)
{
    return Py_BuildValue("i", self->size);
}

static PyObject *
LRU_get_stats(LRU *self)
{
    return Py_BuildValue("nn", self->hits, self->misses);
}

static PyMethodDef LRU_methods[] = {
    {"keys", (PyCFunction)LRU_keys, METH_NOARGS,
                    PyDoc_STR("L.keys() -> list of L's keys in MRU order")},
    {"values", (PyCFunction)LRU_values, METH_NOARGS,
                    PyDoc_STR("L.values() -> list of L's values in MRU order")},
    {"items", (PyCFunction)LRU_items, METH_NOARGS,
                    PyDoc_STR("L.items() -> list of L's items (key,value) in MRU order")},
    {"has_key",	(PyCFunction)LRU_contains, METH_VARARGS,
                    PyDoc_STR("L.has_key(key) -> Check if key is there in L")},
    {"get",	(PyCFunction)LRU_get, METH_VARARGS,
                    PyDoc_STR("L.get(key, instead) -> If L has key return its value, otherwise instead")},
    {"set_size", (PyCFunction)LRU_set_size, METH_VARARGS,
                    PyDoc_STR("L.set_size() -> set size of LRU")},
    {"get_size", (PyCFunction)LRU_get_size, METH_NOARGS,
                    PyDoc_STR("L.get_size() -> get size of LRU")},
    {"clear", (PyCFunction)LRU_clear, METH_NOARGS,
                    PyDoc_STR("L.clear() -> clear LRU")},
    {"get_stats", (PyCFunction)LRU_get_stats, METH_NOARGS,

     * other than a string object. */
    if (value == NULL || !PyUnicode_Check(value)) {
        PyErr_SetString(PyExc_TypeError,
                        "__qualname__ must be set to a string object");
        return -1;
    }
    tmp = op->gi_qualname;
    Py_INCREF(value);
    op->gi_qualname = value;
    Py_DECREF(tmp);
    return 0;
}

static PyGetSetDef gen_getsetlist[] = {
    {"__name__", (getter)gen_get_name, (setter)gen_set_name,
     PyDoc_STR("name of the generator")},
    {"__qualname__", (getter)gen_get_qualname, (setter)gen_set_qualname,
     PyDoc_STR("qualified name of the generator")},
    {NULL} /* Sentinel */
};

static PyMemberDef gen_memberlist[] = {
    {"gi_frame",     T_OBJECT, offsetof(PyGenObject, gi_frame),    READONLY},
    {"gi_running",   T_BOOL,   offsetof(PyGenObject, gi_running),  READONLY},
    {"gi_code",      T_OBJECT, offsetof(PyGenObject, gi_code),     READONLY},
    {NULL}      /* Sentinel */
};

static PyMethodDef gen_methods[] = {
    {"send",(PyCFunction)_PyGen_Send, METH_O, send_doc},
    {"throw",(PyCFunction)gen_throw, METH_VARARGS, throw_doc},

#ifndef ComponentSetTarget
	PyMac_PRECHECK(ComponentSetTarget);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      CmpInstObj_Convert, &target))
		return NULL;
	_rv = ComponentSetTarget(_self->ob_itself,
	                         target);
	_res = Py_BuildValue("l",
	                     _rv);
	return _res;
}

static PyMethodDef CmpInstObj_methods[] = {
	{"CloseComponent", (PyCFunction)CmpInstObj_CloseComponent, 1,
	 PyDoc_STR("() -> None")},
	{"GetComponentInstanceError", (PyCFunction)CmpInstObj_GetComponentInstanceError, 1,
	 PyDoc_STR("() -> None")},
	{"SetComponentInstanceError", (PyCFunction)CmpInstObj_SetComponentInstanceError, 1,
	 PyDoc_STR("(OSErr theError) -> None")},
	{"GetComponentInstanceStorage", (PyCFunction)CmpInstObj_GetComponentInstanceStorage, 1,
	 PyDoc_STR("() -> (Handle _rv)")},
	{"SetComponentInstanceStorage", (PyCFunction)CmpInstObj_SetComponentInstanceStorage, 1,
	 PyDoc_STR("(Handle theStorage) -> None")},
	{"ComponentFunctionImplemented", (PyCFunction)CmpInstObj_ComponentFunctionImplemented, 1,
	 PyDoc_STR("(short ftnNumber) -> (long _rv)")},
	{"GetComponentVersion", (PyCFunction)CmpInstObj_GetComponentVersion, 1,
	 PyDoc_STR("() -> (long _rv)")},
	{"ComponentSetTarget", (PyCFunction)CmpInstObj_ComponentSetTarget, 1,
	 PyDoc_STR("(ComponentInstance target) -> (long _rv)")},
	{NULL, NULL, 0}

  if (!(result = PyString_FromStringAndSize(NULL,size)))
    return NULL;

  /* Second pass: actually decode this time. */

  out = PyString_AsString(result);
  size = percent_decode(in, inlen, out);

  return result;
}


static PyMethodDef Codec_methods[] = {
  {"encode",  (PyCFunction)Codec_encode,  METH_VARARGS,
    PyDoc_STR("encode(str) -> str")},
  {"decode",  (PyCFunction)Codec_decode,  METH_VARARGS,
    PyDoc_STR("decode(str) -> str")},
  {NULL,    NULL}    /* sentinel */
};


PyTypeObject CodecType = {
  /* The ob_type field must be initialized in the module init function
   * to be portable to Windows without using C++. */
  PyObject_HEAD_INIT(NULL)
  0,                            /*ob_size*/
  "percentcoding.cext.Codec",   /*tp_name*/
  sizeof(Codec),                /*tp_basicsize*/
  0,                            /*tp_itemsize*/
  /* methods */

            Py_DECREF(res);
            return PyObject_RichCompare(self->data, other->data, opid);
        }
    }
    Py_RETURN_NOTIMPLEMENTED;
}

PyMappingMethods pysqlite_row_as_mapping = {
    /* mp_length        */ (lenfunc)pysqlite_row_length,
    /* mp_subscript     */ (binaryfunc)pysqlite_row_subscript,
    /* mp_ass_subscript */ (objobjargproc)0,
};

static PyMethodDef pysqlite_row_methods[] = {
    {"keys", (PyCFunction)pysqlite_row_keys, METH_NOARGS,
        PyDoc_STR("Returns the keys of the row.")},
    {NULL, NULL}
};


PyTypeObject pysqlite_RowType = {
        PyVarObject_HEAD_INIT(NULL, 0)
        MODULE_NAME ".Row",                             /* tp_name */
        sizeof(pysqlite_Row),                           /* tp_basicsize */
        0,                                              /* tp_itemsize */
        (destructor)pysqlite_row_dealloc,               /* tp_dealloc */
        (printfunc)pysqlite_row_print,                  /* tp_print */
        0,                                              /* tp_getattr */
        0,                                              /* tp_setattr */
        0,                                              /* tp_reserved */
        0,                                              /* tp_repr */