Changeset 5


Ignore:
Timestamp:
07/16/05 16:22:27 (9 years ago)
Author:
xi
Message:

_syckmodule.c: Rename types and functions.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/ext/_syckmodule.c

    r4 r5  
    55/* Global objects. */ 
    66 
    7 static PyObject *_syck_Error; 
    8  
    9 static PyObject *_syck_ScalarKind; 
    10 static PyObject *_syck_SeqKind; 
    11 static PyObject *_syck_MapKind; 
     7static PyObject *PySyck_Error; 
     8 
     9static PyObject *PySyck_ScalarKind; 
     10static PyObject *PySyck_SeqKind; 
     11static PyObject *PySyck_MapKind; 
    1212 
    1313/* Node type. */ 
     
    1818    PyObject *type_id; 
    1919    PyObject *value; 
    20 } _syck_Node; 
     20} PySyckNodeObject; 
    2121 
    2222static void 
    23 _syck_Node_dealloc(_syck_Node *self) 
     23PySyckNode_dealloc(PySyckNodeObject *self) 
    2424{ 
    2525    Py_XDECREF(self->kind); 
     
    3030 
    3131static PyObject * 
    32 _syck_Node_getattr(_syck_Node *self, char *name) 
     32PySyckNode_getattr(PySyckNodeObject *self, char *name) 
    3333{ 
    3434    PyObject *value; 
     
    4949} 
    5050 
    51 static char _syck_Node_doc[] = 
     51static char PySyckNode_doc[] = 
    5252    "Node object\n" 
    5353    "\n" 
     
    5757    "value -- the value of the node, a string, list or dict object.\n"; 
    5858 
    59 static PyTypeObject _syck_NodeType = { 
     59static PyTypeObject PySyckNode_Type = { 
    6060    PyObject_HEAD_INIT(NULL) 
    6161    0,                                  /* ob_size */ 
    6262    "_syck.Node",                       /* tp_name */ 
    63     sizeof(_syck_Node),                 /* tp_basicsize */ 
     63    sizeof(PySyckNodeObject),           /* tp_basicsize */ 
    6464    0,                                  /* tp_itemsize */ 
    65     (destructor)_syck_Node_dealloc,     /* tp_dealloc */ 
     65    (destructor)PySyckNode_dealloc,     /* tp_dealloc */ 
    6666    0,                                  /* tp_print */ 
    67     (getattrfunc)_syck_Node_getattr,    /* tp_getattr */ 
     67    (getattrfunc)PySyckNode_getattr,    /* tp_getattr */ 
    6868    0,                                  /* tp_setattr */ 
    6969    0,                                  /* tp_compare */ 
     
    7979    0,                                  /* tp_as_buffer */ 
    8080    Py_TPFLAGS_DEFAULT,                 /* tp_flags */ 
    81     _syck_Node_doc,                     /* tp_doc */ 
     81    PySyckNode_doc,                     /* tp_doc */ 
    8282}; 
    8383 
    8484static PyObject * 
    85 _syck_NewNode(PyObject *self, PyObject *args) 
    86 { 
    87     if (!PyArg_ParseTuple(args, ":_syck.Node")) 
    88         return NULL; 
    89  
    90     PyErr_SetString(PyExc_TypeError, "Node object cannot be created explicitly. Use _syck.Parser.parse() instead."); 
    91     return NULL; 
    92 } 
    93  
    94 static char _syck_NewNode_doc[] = 
    95     "Node object cannot be created explicitly. Use _syck.Parser.parse() instead."; 
    96  
    97 static PyObject * 
    98 _syck_NewNode_FromValue(char *type_id, PyObject *value) /* Note: steals the reference to the value. */ 
    99 { 
    100     _syck_Node *self; 
     85PySyckNode_New(char *type_id, PyObject *value) /* Note: steals the reference to the value. */ 
     86{ 
     87    PySyckNodeObject *self; 
    10188    PyObject *kind; 
    10289 
    103     self = PyObject_NEW(_syck_Node, &_syck_NodeType); 
     90    self = PyObject_NEW(PySyckNodeObject, &PySyckNode_Type); 
    10491    if (!self) { 
    10592        Py_XDECREF(value); 
     
    11097 
    11198    if (PyList_Check(value)) 
    112         kind = _syck_SeqKind; 
     99        kind = PySyck_SeqKind; 
    113100    else if (PyDict_Check(value)) 
    114         kind = _syck_MapKind; 
     101        kind = PySyck_MapKind; 
    115102    else 
    116         kind = _syck_ScalarKind; 
     103        kind = PySyck_ScalarKind; 
    117104    Py_INCREF(kind); 
    118105    self->kind = kind; 
     
    133120} 
    134121 
     122static PyObject * 
     123PySyck_Node(PyObject *self, PyObject *args) 
     124{ 
     125    if (!PyArg_ParseTuple(args, ":_syck.Node")) 
     126        return NULL; 
     127 
     128    PyErr_SetString(PyExc_TypeError, "Node object cannot be created explicitly. Use _syck.Parser.parse() instead."); 
     129    return NULL; 
     130} 
     131 
     132static char PySyck_Node_doc[] = 
     133    "Node object cannot be created explicitly. Use _syck.Parser.parse() instead."; 
     134 
    135135/* Parser type. */ 
    136136 
     
    138138    PyObject_HEAD 
    139139    PyObject *source; 
    140     PyObject *resolver; 
     140/*    PyObject *resolver;*/ 
    141141    PyObject *symbols; 
    142     int error_state; 
    143     int mark; 
    144     SyckParser *parser; 
    145 } _syck_Parser; 
    146  
    147 static PyObject * 
    148 _syck_Parser_parse(_syck_Parser *self, PyObject *args) 
     142    SyckParser *syck; 
     143    int error; 
     144} PySyckParserObject; 
     145 
     146static PyObject * 
     147PySyckParser_parse(PySyckParserObject *parser, PyObject *args) 
    149148{ 
    150149    SYMID index; 
     
    154153        return NULL; 
    155154 
    156     if (!self->parser) { 
     155    if (!parser->syck) { 
    157156        PyErr_SetString(PyExc_TypeError, "Parser object is closed"); 
    158157        return NULL; 
    159158    } 
    160159 
    161     self->symbols = PyList_New(0); 
    162     if (!self->symbols) { 
    163         return NULL; 
    164     } 
    165  
    166     index = syck_parse(self->parser); 
    167     if (!self->error_state && !self->parser->eof) { 
    168         value = PyList_GetItem(self->symbols, index-1); 
    169     } 
    170  
    171     Py_DECREF(self->symbols); 
    172  
    173     if (self->error_state) { 
    174         self->error_state = 0; 
    175         return NULL; 
    176     } 
    177  
    178     if (self->parser->eof) { 
     160    parser->symbols = PyList_New(0); 
     161    if (!parser->symbols) { 
     162        return NULL; 
     163    } 
     164 
     165    index = syck_parse(parser->syck); 
     166    if (!parser->error && !parser->syck->eof) { 
     167        value = PyList_GetItem(parser->symbols, index-1); 
     168    } 
     169 
     170    Py_DECREF(parser->symbols); 
     171 
     172    if (parser->error) { 
     173        parser->error = 0; 
     174        return NULL; 
     175    } 
     176 
     177    if (parser->syck->eof) { 
    179178        Py_INCREF(Py_None); 
    180179        return Py_None; 
     
    184183} 
    185184 
    186 static char _syck_Parser_parse_doc[] = 
     185static char PySyckParser_parse_doc[] = 
    187186    "Parses the next document in the YAML stream, return the root Node object or None on EOF."; 
    188187 
    189188static PyObject * 
    190 _syck_Parser_parse_documents(_syck_Parser *self, PyObject *args) 
     189PySyckParser_parse_documents(PySyckParserObject *parser, PyObject *args) 
    191190{ 
    192191    SYMID index; 
    193192    PyObject *value = NULL; 
    194     PyObject *result = NULL; 
     193    PyObject *documents = NULL; 
    195194 
    196195    if (!PyArg_ParseTuple(args, ":parse_document")) 
    197196        return NULL; 
    198197 
    199     if (!self->parser) { 
     198    if (!parser->syck) { 
    200199        PyErr_SetString(PyExc_TypeError, "Parser object is closed"); 
    201200        return NULL; 
    202201    } 
    203202 
    204     result = PyList_New(0); 
    205     if (!result) return NULL; 
     203    documents = PyList_New(0); 
     204    if (!documents) return NULL; 
    206205 
    207206    while (1) { 
    208207 
    209         self->symbols = PyList_New(0); 
    210         if (!self->symbols) { 
    211             Py_DECREF(result); 
     208        parser->symbols = PyList_New(0); 
     209        if (!parser->symbols) { 
     210            Py_DECREF(documents); 
    212211            return NULL; 
    213212        }; 
    214213 
    215         index = syck_parse(self->parser); 
    216  
    217         if (!self->error_state && !self->parser->eof) { 
    218             value = PyList_GetItem(self->symbols, index-1); 
     214        index = syck_parse(parser->syck); 
     215 
     216        if (!parser->error && !parser->syck->eof) { 
     217            value = PyList_GetItem(parser->symbols, index-1); 
    219218            if (!value) { 
    220                 Py_DECREF(self->symbols); 
    221                 Py_DECREF(result); 
     219                Py_DECREF(parser->symbols); 
     220                Py_DECREF(documents); 
    222221                return NULL; 
    223222            } 
    224             if (PyList_Append(result, value) < 0) { 
    225                 Py_DECREF(self->symbols); 
     223            if (PyList_Append(documents, value) < 0) { 
     224                Py_DECREF(parser->symbols); 
    226225                Py_DECREF(value); 
    227                 Py_DECREF(result); 
     226                Py_DECREF(documents); 
    228227                return NULL; 
    229228            } 
     
    231230        } 
    232231 
    233         Py_DECREF(self->symbols); 
    234  
    235         if (self->error_state) { 
    236             self->error_state = 0; 
    237             Py_DECREF(result); 
     232        Py_DECREF(parser->symbols); 
     233 
     234        if (parser->error) { 
     235            parser->error = 0; 
     236            Py_DECREF(documents); 
    238237            return NULL; 
    239238        } 
    240239 
    241         if (self->parser->eof) break; 
    242     } 
    243  
    244     return result; 
    245 } 
    246  
    247 static char _syck_Parser_parse_documents_doc[] = 
     240        if (parser->syck->eof) break; 
     241    } 
     242 
     243    return documents; 
     244} 
     245 
     246static char PySyckParser_parse_documents_doc[] = 
    248247    "Parses the entire YAML stream and returns list of documents."; 
    249248 
    250249static PyObject * 
    251 _syck_Parser_close(_syck_Parser *self, PyObject *args) 
     250PySyckParser_close(PySyckParserObject *parser, PyObject *args) 
    252251{ 
    253252    if (!PyArg_ParseTuple(args, ":close")) 
    254253        return NULL; 
    255254 
    256     Py_XDECREF(self->source); 
    257     self->source = NULL; 
    258  
    259     if (self->parser) { 
    260         syck_free_parser(self->parser); 
    261     } 
    262     self->parser = NULL; 
     255    Py_XDECREF(parser->source); 
     256    parser->source = NULL; 
     257 
     258    if (parser->syck) { 
     259        syck_free_parser(parser->syck); 
     260    } 
     261    parser->syck = NULL; 
    263262 
    264263    Py_INCREF(Py_None); 
     
    266265} 
    267266 
    268 static char _syck_Parser_close_doc[] = 
     267static char PySyckParser_close_doc[] = 
    269268    "Closes the parser and frees memory"; 
    270269 
    271 static PyMethodDef _syck_Parser_methods[] = { 
    272     {"parse",  (PyCFunction)_syck_Parser_parse, METH_VARARGS, _syck_Parser_parse_doc}, 
    273     {"parse_documents",  (PyCFunction)_syck_Parser_parse_documents, METH_VARARGS, _syck_Parser_parse_documents_doc}, 
    274     {"close",  (PyCFunction)_syck_Parser_close, METH_VARARGS, _syck_Parser_close_doc}, 
     270static PyMethodDef PySyckParser_methods[] = { 
     271    {"parse",  (PyCFunction)PySyckParser_parse, METH_VARARGS, PySyckParser_parse_doc}, 
     272    {"parse_documents",  (PyCFunction)PySyckParser_parse_documents, METH_VARARGS, PySyckParser_parse_documents_doc}, 
     273    {"close",  (PyCFunction)PySyckParser_close, METH_VARARGS, PySyckParser_close_doc}, 
    275274    {NULL}  /* Sentinel */ 
    276275}; 
    277276 
    278277static void 
    279 _syck_Parser_dealloc(_syck_Parser *self) 
    280 { 
    281     Py_XDECREF(self->source); 
    282     if (self->parser) { 
    283         syck_free_parser(self->parser); 
    284     } 
    285     PyObject_Del(self); 
    286 } 
    287  
    288 static PyObject * 
    289 _syck_Parser_getattr(_syck_Parser *self, char *name) 
    290 { 
    291     return Py_FindMethod(_syck_Parser_methods, (PyObject *)self, name); 
    292 } 
    293  
    294 static char _syck_Parser_doc[] = 
     278PySyckParser_dealloc(PySyckParserObject *parser) 
     279{ 
     280    Py_XDECREF(parser->source); 
     281    if (parser->syck) { 
     282        syck_free_parser(parser->syck); 
     283    } 
     284    PyObject_Del(parser); 
     285} 
     286 
     287static PyObject * 
     288PySyckParser_getattr(PySyckParserObject *parser, char *name) 
     289{ 
     290    return Py_FindMethod(PySyckParser_methods, (PyObject *)parser, name); 
     291} 
     292 
     293static char PySyckParser_doc[] = 
    295294    "_syck.Parser(yaml_string_or_file, implicit_typing=True, taguri_expansion=True) -> Parser object\n" 
    296295    "\n" 
     
    300299    "close() -- Closes the parser and frees memory.\n"; 
    301300 
    302 static PyTypeObject _syck_ParserType = { 
     301static PyTypeObject PySyckParser_Type = { 
    303302    PyObject_HEAD_INIT(NULL) 
    304303    0,                                  /* ob_size */ 
    305304    "_syck.Parser",                     /* tp_name */ 
    306     sizeof(_syck_Parser),               /* tp_basicsize */ 
     305    sizeof(PySyckParserObject),         /* tp_basicsize */ 
    307306    0,                                  /* tp_itemsize */ 
    308     (destructor)_syck_Parser_dealloc,   /* tp_dealloc */ 
     307    (destructor)PySyckParser_dealloc,   /* tp_dealloc */ 
    309308    0,                                  /* tp_print */ 
    310     (getattrfunc)_syck_Parser_getattr,  /* tp_getattr */ 
     309    (getattrfunc)PySyckParser_getattr,  /* tp_getattr */ 
    311310    0,                                  /* tp_setattr */ 
    312311    0,                                  /* tp_compare */ 
     
    322321    0,                                  /* tp_as_buffer */ 
    323322    Py_TPFLAGS_DEFAULT,                 /* tp_flags */ 
    324     _syck_Parser_doc,                   /* tp_doc */ 
     323    PySyckParser_doc,                   /* tp_doc */ 
    325324}; 
    326325 
    327326static long 
    328 _syck_Parser_io_file_read(char *buf, SyckIoFile *file, long max_size, long skip) 
    329 { 
    330     _syck_Parser *runtime = (_syck_Parser *)file->ptr; 
     327PySyckParser_read_handler(char *buf, SyckIoFile *file, long max_size, long skip) 
     328{ 
     329    PySyckParserObject *parser = (PySyckParserObject *)file->ptr; 
    331330 
    332331    PyObject *value; 
     
    337336    buf[skip] = '\0'; 
    338337 
    339     if (runtime->error_state) { 
     338    if (parser->error) { 
    340339        return skip; 
    341340    } 
     
    343342    max_size -= skip; 
    344343 
    345     value = PyObject_CallMethod(runtime->source, "read", "(i)", max_size); 
     344    value = PyObject_CallMethod(parser->source, "read", "(i)", max_size); 
    346345    if (!value) { 
    347         runtime->error_state = 1; 
     346        parser->error = 1; 
    348347        return skip; 
    349348    } 
     
    352351        Py_DECREF(value); 
    353352        PyErr_SetString(PyExc_TypeError, "file-like object should return a string"); 
    354         runtime->error_state = 1; 
     353        parser->error = 1; 
    355354         
    356355        return skip; 
     
    367366        Py_DECREF(value); 
    368367        PyErr_SetString(PyExc_ValueError, "read returns an overly long string"); 
    369         runtime->error_state = 1; 
     368        parser->error = 1; 
    370369        return skip; 
    371370    } 
     
    381380 
    382381static SYMID 
    383 _syck_Parser_node_handler(SyckParser *parser, SyckNode *node) 
    384 { 
    385     _syck_Parser *runtime = (_syck_Parser *)parser->bonus; 
     382PySyckParser_node_handler(SyckParser *syck, SyckNode *node) 
     383{ 
     384    PySyckParserObject *parser = (PySyckParserObject *)syck->bonus; 
    386385 
    387386    SYMID index; 
     
    391390    int k; 
    392391 
    393     if (runtime->error_state) 
     392    if (parser->error) 
    394393        return 0; 
    395394 
     
    407406            for (k = 0; k < node->data.list->idx; k++) { 
    408407                index = syck_seq_read(node, k); 
    409                 item = PyList_GetItem(runtime->symbols, index-1); 
     408                item = PyList_GetItem(parser->symbols, index-1); 
    410409                if (!item) goto error; 
    411410                Py_INCREF(item); 
     
    420419            { 
    421420                index = syck_map_read(node, map_key, k); 
    422                 key = PyList_GetItem(runtime->symbols, index-1); 
     421                key = PyList_GetItem(parser->symbols, index-1); 
    423422                if (!key) goto error; 
    424423                index = syck_map_read(node, map_value, k); 
    425                 value = PyList_GetItem(runtime->symbols, index-1); 
     424                value = PyList_GetItem(parser->symbols, index-1); 
    426425                if (!value) goto error; 
    427426                if (PyDict_SetItem(object, key, value) < 0) 
     
    431430    } 
    432431 
    433     object = _syck_NewNode_FromValue(node->type_id, object); 
     432    object = PySyckNode_New(node->type_id, object); 
    434433    if (!object) goto error; 
    435434 
    436     if (PyList_Append(runtime->symbols, object) < 0) 
     435    if (PyList_Append(parser->symbols, object) < 0) 
    437436        goto error; 
    438437 
    439     index = PyList_Size(runtime->symbols); 
     438    index = PyList_Size(parser->symbols); 
    440439    return index; 
    441440 
    442441error: 
    443442    Py_XDECREF(object); 
    444     runtime->error_state = 1; 
     443    parser->error = 1; 
    445444    return 0; 
    446445} 
    447446 
    448447static void 
    449 _syck_Parser_error_handler(SyckParser *parser, char *str) 
    450 { 
    451     _syck_Parser *runtime = (_syck_Parser *)parser->bonus; 
     448PySyckParser_error_handler(SyckParser *syck, char *str) 
     449{ 
     450    PySyckParserObject *parser = (PySyckParserObject *)syck->bonus; 
    452451    PyObject *value; 
    453452 
    454     if (runtime->error_state) return; 
    455  
    456     runtime->error_state = 1; 
    457  
    458     value = Py_BuildValue("(sii)", str, parser->linect, parser->cursor-parser->lineptr); 
     453    if (parser->error) return; 
     454 
     455    parser->error = 1; 
     456 
     457    value = Py_BuildValue("(sii)", str, syck->linect, syck->cursor-syck->lineptr); 
    459458    if (value) { 
    460         PyErr_SetObject(_syck_Error, value); 
    461     } 
    462 } 
    463  
    464 static PyObject * 
    465 _syck_NewParser(PyObject *self, PyObject *args, PyObject *kwds) 
    466 { 
    467     _syck_Parser *parser; 
     459        PyErr_SetObject(PySyck_Error, value); 
     460    } 
     461} 
     462 
     463static PyObject * 
     464PySyck_Parser(PyObject *self, PyObject *args, PyObject *kwds) 
     465{ 
     466    PySyckParserObject *parser; 
    468467    PyObject *source; 
    469468    int implicit_typing = 1; 
     
    476475        return NULL; 
    477476 
    478     parser = PyObject_NEW(_syck_Parser, &_syck_ParserType); 
     477    parser = PyObject_NEW(PySyckParserObject, &PySyckParser_Type); 
    479478    if (!parser) 
    480479        return NULL; 
     
    482481    Py_INCREF(source); 
    483482    parser->source = source; 
    484     parser->error_state = 0; 
    485  
    486     parser->parser = syck_new_parser(); 
    487     parser->parser->bonus = parser; 
     483    parser->error = 0; 
     484 
     485    parser->syck = syck_new_parser(); 
     486    parser->syck->bonus = parser; 
    488487 
    489488    if (PyString_Check(source)) { 
    490         syck_parser_str_auto(parser->parser, PyString_AS_STRING(source), NULL); 
     489        syck_parser_str(parser->syck, PyString_AS_STRING(source), PyString_GET_SIZE(source), NULL); 
    491490    } 
    492491    else { 
    493         syck_parser_file(parser->parser, (FILE *)parser, _syck_Parser_io_file_read); 
    494     } 
    495     syck_parser_implicit_typing(parser->parser, implicit_typing); 
    496     syck_parser_taguri_expansion(parser->parser, taguri_expansion); 
    497  
    498     syck_parser_handler(parser->parser, _syck_Parser_node_handler); 
    499     syck_parser_error_handler(parser->parser, _syck_Parser_error_handler); 
     492        syck_parser_file(parser->syck, (FILE *)parser, PySyckParser_read_handler); 
     493    } 
     494    syck_parser_implicit_typing(parser->syck, implicit_typing); 
     495    syck_parser_taguri_expansion(parser->syck, taguri_expansion); 
     496 
     497    syck_parser_handler(parser->syck, PySyckParser_node_handler); 
     498    syck_parser_error_handler(parser->syck, PySyckParser_error_handler); 
    500499    /* 
    501500    syck_parser_bad_anchor_handler(parser, _syck_Parser_bad_anchor_handler); 
     
    505504} 
    506505 
    507 static char _syck_NewParser_doc[] = 
     506static char PySyck_Parser_doc[] = 
    508507    "Creates a new Parser object."; 
    509508 
    510509/* The module definitions. */ 
    511510 
    512 static PyMethodDef _syck_methods[] = { 
    513     {"Node",  (PyCFunction)_syck_NewNode, METH_VARARGS, _syck_NewNode_doc}, 
    514     {"Parser",  (PyCFunction)_syck_NewParser, METH_VARARGS|METH_KEYWORDS, _syck_NewParser_doc}, 
     511static PyMethodDef PySyck_methods[] = { 
     512    {"Node",  (PyCFunction)PySyck_Node, METH_VARARGS, PySyck_Node_doc}, 
     513    {"Parser",  (PyCFunction)PySyck_Parser, METH_VARARGS|METH_KEYWORDS, PySyck_Parser_doc}, 
    515514    {NULL}  /* Sentinel */ 
    516515}; 
    517516 
    518 static char _syck_doc[] = 
     517static char PySyck_doc[] = 
    519518    "This module provides low-level access to the Syck parser and emitter.\n" 
    520519    "Do not use this module directly, use the package 'syck' instead.\n"; 
     
    525524    PyObject *m; 
    526525 
    527     _syck_NodeType.ob_type = &PyType_Type; 
    528     _syck_ParserType.ob_type = &PyType_Type; 
    529  
    530     _syck_Error = PyErr_NewException("_syck.error", NULL, NULL); 
    531     if (!_syck_Error) 
    532         return; 
    533  
    534     _syck_ScalarKind = PyString_FromString("scalar"); 
    535     if (!_syck_ScalarKind) 
    536         return; 
    537     _syck_SeqKind = PyString_FromString("seq"); 
    538     if (!_syck_SeqKind) 
    539         return; 
    540     _syck_MapKind = PyString_FromString("map"); 
    541     if (!_syck_MapKind) 
    542         return; 
    543  
    544     m = Py_InitModule3("_syck", _syck_methods, _syck_doc); 
    545  
    546     Py_INCREF(_syck_Error); 
    547     if (!PyModule_AddObject(m, "error", _syck_Error) < 0) 
    548         return; 
    549  
    550     Py_INCREF(&_syck_NodeType); 
    551     if (PyModule_AddObject(m, "NodeType", (PyObject *)&_syck_NodeType) < 0) 
    552         return; 
    553  
    554     Py_INCREF(&_syck_ParserType); 
    555     if (PyModule_AddObject(m, "ParserType", (PyObject *)&_syck_ParserType) < 0) 
    556         return; 
    557 } 
    558  
     526    PySyckNode_Type.ob_type = &PyType_Type; 
     527    PySyckParser_Type.ob_type = &PyType_Type; 
     528 
     529    PySyck_Error = PyErr_NewException("_syck.error", NULL, NULL); 
     530    if (!PySyck_Error) 
     531        return; 
     532 
     533    PySyck_ScalarKind = PyString_FromString("scalar"); 
     534    if (!PySyck_ScalarKind) 
     535        return; 
     536    PySyck_SeqKind = PyString_FromString("seq"); 
     537    if (!PySyck_SeqKind) 
     538        return; 
     539    PySyck_MapKind = PyString_FromString("map"); 
     540    if (!PySyck_MapKind) 
     541        return; 
     542 
     543    m = Py_InitModule3("_syck", PySyck_methods, PySyck_doc); 
     544 
     545    Py_INCREF(PySyck_Error); 
     546    if (!PyModule_AddObject(m, "error", PySyck_Error) < 0) 
     547        return; 
     548 
     549    Py_INCREF(&PySyckNode_Type); 
     550    if (PyModule_AddObject(m, "NodeType", (PyObject *)&PySyckNode_Type) < 0) 
     551        return; 
     552 
     553    Py_INCREF(&PySyckParser_Type); 
     554    if (PyModule_AddObject(m, "ParserType", (PyObject *)&PySyckParser_Type) < 0) 
     555        return; 
     556} 
     557 
Note: See TracChangeset for help on using the changeset viewer.