content.py

winNT技术操作系统,国外开放的原代码和LIUX一样

            self.name     = "Other"
            self.title    = string.split( "Miscellaneous" )
            self.order    = []



class DocSection:

    def __init__( self, name = "Other" ):
        self.name        = name
        self.blocks      = {}
        self.block_names = []  # ordered block names in section
        self.defs        = []
        self.abstract    = ""
        self.description = ""
        self.order       = []
        self.title       = "ERROR"
        self.chapter     = None

    def add_def( self, block ):
        self.defs.append( block )

    def add_block( self, block ):
        self.block_names.append( block.name )
        self.blocks[ block.name ] = block

    def process( self ):
        # lookup one block that contains a valid section description
        for block in self.defs:
            title = block.get_markup_text( "title" )
            if title:
                self.title       = title
                self.abstract    = block.get_markup_words( "abstract" )
                self.description = block.get_markup_items( "description" )
                self.order       = block.get_markup_words( "order" )
                return

    def reorder( self ):

        self.block_names = sort_order_list( self.block_names, self.order )


class ContentProcessor:

    def __init__( self ):
        """initialize a block content processor"""
        self.reset()

        self.sections = {}    # dictionary of documentation sections
        self.section  = None  # current documentation section

        self.chapters = []        # list of chapters

    def set_section( self, section_name ):
        """set current section during parsing"""
        if not self.sections.has_key( section_name ):
            section = DocSection( section_name )
            self.sections[ section_name ] = section
            self.section                  = section
        else:
            self.section = self.sections[ section_name ]

    def add_chapter( self, block ):
        chapter = DocChapter( block )
        self.chapters.append( chapter )


    def reset( self ):
        """reset the content processor for a new block"""
        self.markups      = []
        self.markup       = None
        self.markup_lines = []

    def add_markup( self ):
        """add a new markup section"""
        if self.markup and self.markup_lines:

            # get rid of last line of markup if it's empty
            marks = self.markup_lines
            if len(marks) > 0 and not string.strip(marks[-1]):
                self.markup_lines = marks[:-1]

            m = DocMarkup( self.markup, self.markup_lines )

            self.markups.append( m )

            self.markup       = None
            self.markup_lines = []


    def process_content( self, content ):
        """process a block content and return a list of DocMarkup objects
           corresponding to it"""
        markup       = None
        markup_lines = []
        first        = 1

        for line in content:
            found = None
            for t in re_markup_tags:
                m = t.match( line )
                if m:
                    found  = string.lower(m.group(1))
                    prefix = len(m.group(0))
                    line   = " "*prefix + line[prefix:]   # remove markup from line
                    break

            # is it the start of a new markup section ?
            if found:
                first = 0
                self.add_markup()  # add current markup content
                self.markup = found
                if len(string.strip( line )) > 0:
                    self.markup_lines.append( line )
            elif first == 0:
                self.markup_lines.append( line )

        self.add_markup()

        return self.markups


    def  parse_sources( self, source_processor ):
        blocks = source_processor.blocks
        count  = len(blocks)
        for n in range(count):

            source = blocks[n]
            if source.content:
                # this is a documentation comment, we need to catch
                # all following normal blocks in the "follow" list
                #
                follow = []
                m = n+1
                while m < count and not blocks[m].content:
                    follow.append( blocks[m] )
                    m = m+1

                doc_block = DocBlock( source, follow, self )


    def  finish( self ):

        # process all sections to extract their abstract, description
        # and ordered list of items
        #
        for sec in self.sections.values():
            sec.process()

        # process chapters to check that all sections are correctly
        # listed there
        for chap in self.chapters:
            for sec in chap.order:
                if self.sections.has_key(sec):
                    section = self.sections[ sec ]
                    section.chapter = chap
                    section.reorder()
                    chap.sections.append( section )
                else:
                    sys.stderr.write( "WARNING: chapter '" +
                        chap.name + "' in " + chap.block.location() + \
                        " lists unknown section '" + sec + "'\n" )

        # check that all sections are in a chapter
        #
        others = []
        for sec in self.sections.values():
            if not sec.chapter:
                others.append(sec)

        # create a new special chapter for all remaining sections
        # when necessary
        #
        if others:
            chap = DocChapter( None )
            chap.sections = others
            self.chapters.append( chap )



class DocBlock:

    def __init__( self, source, follow, processor ):

        processor.reset()

        self.source    = source
        self.code      = []
        self.type      = "ERRTYPE"
        self.name      = "ERRNAME"
        self.section   = processor.section
        self.markups   = processor.process_content( source.content )

        # compute block type from first markup tag
        try:
            self.type = self.markups[0].tag
        except:
            pass


        # compute block name from first markup paragraph
        try:
            markup = self.markups[0]
            para   = markup.fields[0].items[0]
            name   = para.words[0]
            m = re_identifier.match( name )
            if m:
                name = m.group(1)
            self.name = name
        except:
            pass

        # detect new section starts
        if self.type == "section":
            processor.set_section( self.name )
            processor.section.add_def( self )

        # detect new chapter
        elif self.type == "chapter":
            processor.add_chapter( self )

        else:
            processor.section.add_block( self )

        # now, compute the source lines relevant to this documentation
        # block. We keep normal comments in for obvious reasons (??)
        source = []
        for b in follow:
            if b.format:
                break
            for l in b.lines:
                # we use "/* */" as a separator
                if re_source_sep.match( l ):
                    break
                source.append( l )

        # now strip the leading and trailing empty lines from the sources
        start = 0
        end   = len( source )-1

        while start < end and not string.strip( source[start] ):
            start = start + 1

        while start < end and not string.strip( source[end] ):
            end = end - 1

        source = source[start:end+1]

        self.code = source


    def location( self ):
        return self.source.location()



    def get_markup( self, tag_name ):
        """return the DocMarkup corresponding to a given tag in a block"""
        for m in self.markups:
            if m.tag == string.lower(tag_name):
                return m
        return None


    def get_markup_name( self, tag_name ):
        """return the name of a given primary markup in a block"""
        try:
            m = self.get_markup( tag_name )
            return m.get_name()
        except:
            return None


    def get_markup_words( self, tag_name ):
        try:
            m = self.get_markup( tag_name )
            return m.fields[0].items[0].words
        except:
            return []


    def get_markup_text( self, tag_name ):
        result = self.get_markup_words( tag_name )
        return string.join( result )


    def get_markup_items( self, tag_name ):
        try:
            m = self.get_markup( tag_name )
            return m.fields[0].items
        except:
            return None