← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/_dirstate_helpers_c.pyx

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-11-03 01:53:30 UTC
  • mfrom: (2955.1.1 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20071103015330-pt1tec7wyxwwcey8
Fix #158972 don't use timeout for HttpServer

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/_dirstate_helpers_c.pyx
1
 
# Copyright (C) 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
19
19
This is the python implementation for DirState functions.
20
20
"""
21
21
 
22
 
from bzrlib import errors
23
22
from bzrlib.dirstate import DirState
24
23
 
25
24
 
51
50
# inner loops, we don't need to do that at all, as the reference only lasts for
52
51
# a very short time.
53
52
cdef extern from "Python.h":
54
 
    ctypedef int Py_ssize_t
55
53
    int PyList_Append(object lst, object item) except -1
56
54
    void *PyList_GetItem_object_void "PyList_GET_ITEM" (object lst, int index)
57
55
    int PyList_CheckExact(object)
61
59
    char *PyString_AsString(object p)
62
60
    char *PyString_AS_STRING_void "PyString_AS_STRING" (void *p)
63
61
    object PyString_FromString(char *)
64
 
    object PyString_FromStringAndSize(char *, Py_ssize_t)
 
62
    object PyString_FromStringAndSize(char *, int)
65
63
    int PyString_Size(object p)
66
64
    int PyString_GET_SIZE_void "PyString_GET_SIZE" (void *p)
67
65
    int PyString_CheckExact(object p)
112
110
        return None
113
111
    return <char*>found - <char*>_s
114
112
 
115
 
cdef object safe_string_from_size(char *s, Py_ssize_t size):
116
 
    if size < 0:
117
 
        raise AssertionError(
118
 
            'tried to create a string with an invalid size: %d @0x%x'
119
 
            % (size, <int>s))
120
 
    return PyString_FromStringAndSize(s, size)
121
 
 
122
113
 
123
114
cdef int _is_aligned(void *ptr):
124
115
    """Is this pointer aligned to an integer size offset?
479
470
cdef class Reader:
480
471
    """Maintain the current location, and return fields as you parse them."""
481
472
 
482
 
    cdef object state # The DirState object
483
473
    cdef object text # The overall string object
484
474
    cdef char *text_cstr # Pointer to the beginning of text
485
475
    cdef int text_size # Length of text
488
478
    cdef char *cur_cstr # Pointer to the current record
489
479
    cdef char *next # Pointer to the end of this record
490
480
 
491
 
    def __init__(self, text, state):
492
 
        self.state = state
 
481
    def __init__(self, text):
493
482
        self.text = text
494
483
        self.text_cstr = PyString_AsString(text)
495
484
        self.text_size = PyString_Size(text)
496
485
        self.end_cstr = self.text_cstr + self.text_size
497
486
        self.cur_cstr = self.text_cstr
498
487
 
499
 
    cdef char *get_next(self, int *size) except NULL:
 
488
    cdef char *get_next(self, int *size):
500
489
        """Return a pointer to the start of the next field."""
501
490
        cdef char *next
502
 
        cdef Py_ssize_t extra_len
503
 
 
504
 
        if self.cur_cstr == NULL:
505
 
            raise AssertionError('get_next() called when cur_str is NULL')
506
 
        elif self.cur_cstr >= self.end_cstr:
507
 
            raise AssertionError('get_next() called when there are no chars'
508
 
                                 ' left')
509
491
        next = self.cur_cstr
510
 
        self.cur_cstr = <char*>memchr(next, c'\0', self.end_cstr - next)
511
 
        if self.cur_cstr == NULL:
512
 
            extra_len = self.end_cstr - next
513
 
            raise errors.DirstateCorrupt(self.state,
514
 
                'failed to find trailing NULL (\\0).'
515
 
                ' Trailing garbage: %r'
516
 
                % safe_string_from_size(next, extra_len))
 
492
        self.cur_cstr = <char*>memchr(next, c'\0', self.end_cstr-next)
517
493
        size[0] = self.cur_cstr - next
518
494
        self.cur_cstr = self.cur_cstr + 1
519
495
        return next
523
499
        cdef int size
524
500
        cdef char *next
525
501
        next = self.get_next(&size)
526
 
        return safe_string_from_size(next, size)
 
502
        return PyString_FromStringAndSize(next, size)
527
503
 
528
504
    cdef int _init(self) except -1:
529
505
        """Get the pointer ready.
594
570
                       # <object>
595
571
                       PyString_AS_STRING_void(p_current_dirname[0]),
596
572
                       cur_size+1) != 0):
597
 
            dirname = safe_string_from_size(dirname_cstr, cur_size)
 
573
            dirname = PyString_FromStringAndSize(dirname_cstr, cur_size)
598
574
            p_current_dirname[0] = <void*>dirname
599
575
            new_block[0] = 1
600
576
        else:
645
621
        # marker.
646
622
        trailing = self.get_next(&cur_size)
647
623
        if cur_size != 1 or trailing[0] != c'\n':
648
 
            raise errors.DirstateCorrupt(self.state,
 
624
            raise AssertionError(
649
625
                'Bad parse, we expected to end on \\n, not: %d %s: %s'
650
 
                % (cur_size, safe_string_from_size(trailing, cur_size),
 
626
                % (cur_size, PyString_FromStringAndSize(trailing, cur_size),
651
627
                   ret))
652
628
        return ret
653
629
 
654
 
    def _parse_dirblocks(self):
 
630
    def _parse_dirblocks(self, state):
655
631
        """Parse all dirblocks in the state file."""
656
632
        cdef int num_trees
657
633
        cdef object current_block
661
637
        cdef int expected_entry_count
662
638
        cdef int entry_count
663
639
 
664
 
        num_trees = self.state._num_present_parents() + 1
665
 
        expected_entry_count = self.state._num_entries
 
640
        num_trees = state._num_present_parents() + 1
 
641
        expected_entry_count = state._num_entries
666
642
 
667
643
        # Ignore the first record
668
644
        self._init()
669
645
 
670
646
        current_block = []
671
 
        dirblocks = [('', current_block), ('', [])]
672
 
        self.state._dirblocks = dirblocks
 
647
        state._dirblocks = [('', current_block), ('', [])]
673
648
        obj = ''
674
649
        current_dirname = <void*>obj
675
650
        new_block = 0
687
662
            if new_block:
688
663
                # new block - different dirname
689
664
                current_block = []
690
 
                PyList_Append(dirblocks,
 
665
                PyList_Append(state._dirblocks,
691
666
                              (<object>current_dirname, current_block))
692
667
            PyList_Append(current_block, entry)
693
668
            entry_count = entry_count + 1
694
669
        if entry_count != expected_entry_count:
695
 
            raise errors.DirstateCorrupt(self.state,
696
 
                    'We read the wrong number of entries.'
 
670
            raise AssertionError('We read the wrong number of entries.'
697
671
                    ' We expected to read %s, but read %s'
698
672
                    % (expected_entry_count, entry_count))
699
 
        self.state._split_root_dirblock_into_contents()
 
673
        state._split_root_dirblock_into_contents()
700
674
 
701
675
 
702
676
def _read_dirblocks_c(state):
715
689
    text = state._state_file.read()
716
690
    # TODO: check the crc checksums. crc_measured = zlib.crc32(text)
717
691
 
718
 
    reader = Reader(text, state)
 
692
    reader = Reader(text)
719
693
 
720
 
    reader._parse_dirblocks()
 
694
    reader._parse_dirblocks(state)
721
695
    state._dirblock_state = DirState.IN_MEMORY_UNMODIFIED