Return to vdbe-compress.tcl CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / tool

Annotation of embedaddon/sqlite3/tool/vdbe-compress.tcl, revision 1.1

1.1     ! misho       1: #!/usr/bin/tcl
        !             2: #
        !             3: # This script makes modifications to the vdbe.c source file which reduce
        !             4: # the amount of stack space required by the sqlite3VdbeExec() routine.
        !             5: #
        !             6: # The modifications performed by this script are optional.  The vdbe.c
        !             7: # source file will compile correctly with and without the modifications
        !             8: # performed by this script.  And all routines within vdbe.c will compute
        !             9: # the same result.  The modifications made by this script merely help
        !            10: # the C compiler to generate code for sqlite3VdbeExec() that uses less
        !            11: # stack space.
        !            12: #
        !            13: # Script usage:
        !            14: #
        !            15: #          mv vdbe.c vdbe.c.template
        !            16: #          tclsh vdbe-compress.tcl <vdbe.c.template >vdbe.c
        !            17: #
        !            18: # Modifications made:
        !            19: #
        !            20: # All modifications are within the sqlite3VdbeExec() function.  The
        !            21: # modifications seek to reduce the amount of stack space allocated by
        !            22: # this routine by moving local variable declarations out of individual
        !            23: # opcode implementations and into a single large union.  The union contains
        !            24: # a separate structure for each opcode and that structure contains the
        !            25: # local variables used by that opcode.  In this way, the total amount
        !            26: # of stack space required by sqlite3VdbeExec() is reduced from the
        !            27: # sum of all local variables to the maximum of the local variable space
        !            28: # required for any single opcode.
        !            29: #
        !            30: # In order to be recognized by this script, local variables must appear
        !            31: # on the first line after the open curly-brace that begins a new opcode
        !            32: # implementation.  Local variables must not have initializers, though they
        !            33: # may be commented.
        !            34: #
        !            35: # The union definition is inserted in place of a special marker comment
        !            36: # in the preamble to the sqlite3VdbeExec() implementation.
        !            37: #
        !            38: #############################################################################
        !            39: #
        !            40: set beforeUnion {}   ;# C code before union
        !            41: set unionDef {}      ;# C code of the union
        !            42: set afterUnion {}    ;# C code after the union
        !            43: set sCtr 0           ;# Context counter
        !            44: 
        !            45: # Read program text up to the spot where the union should be
        !            46: # inserted.
        !            47: #
        !            48: while {![eof stdin]} {
        !            49:   set line [gets stdin]
        !            50:   if {[regexp {INSERT STACK UNION HERE} $line]} break
        !            51:   append beforeUnion $line\n
        !            52: }
        !            53: 
        !            54: # Process the remaining text.  Build up the union definition as we go.
        !            55: #
        !            56: set vlist {}
        !            57: set seenDecl 0
        !            58: set namechars {abcdefghijklmnopqrstuvwxyz}
        !            59: set nnc [string length $namechars]
        !            60: while {![eof stdin]} {
        !            61:   set line [gets stdin]
        !            62:   if {[regexp "^case (OP_\\w+): \173" $line all operator]} {
        !            63:     append afterUnion $line\n
        !            64:     set vlist {}
        !            65:     while {![eof stdin]} {
        !            66:       set line [gets stdin]
        !            67:       if {[regexp {^ +(const )?\w+ \**(\w+)(\[.*\])?;} $line \
        !            68:            all constKeyword vname notused1]} {
        !            69:         if {!$seenDecl} {
        !            70:           set sname {}
        !            71:           append sname [string index $namechars [expr {$sCtr/$nnc}]]
        !            72:           append sname [string index $namechars [expr {$sCtr%$nnc}]]
        !            73:           incr sCtr
        !            74:           append unionDef "    struct ${operator}_stack_vars \173\n"
        !            75:           append afterUnion \
        !            76:              "#if 0  /* local variables moved into u.$sname */\n"
        !            77:           set seenDecl 1
        !            78:         }
        !            79:         append unionDef "    $line\n"
        !            80:         append afterUnion $line\n
        !            81:         lappend vlist $vname
        !            82:       } else {
        !            83:         break
        !            84:       }
        !            85:     }
        !            86:     if {$seenDecl} {
        !            87:       append unionDef   "    \175 $sname;\n"
        !            88:       append afterUnion "#endif /* local variables moved into u.$sname */\n"
        !            89:     }
        !            90:     set seenDecl 0
        !            91:   }
        !            92:   if {[regexp "^\175" $line]} {
        !            93:     append afterUnion $line\n
        !            94:     set vlist {}
        !            95:   } elseif {[llength $vlist]>0} {
        !            96:     append line " "
        !            97:     foreach v $vlist {
        !            98:       regsub -all "(\[^a-zA-Z0-9>.\])${v}(\\W)" $line "\\1u.$sname.$v\\2" line
        !            99:       regsub -all "(\[^a-zA-Z0-9>.\])${v}(\\W)" $line "\\1u.$sname.$v\\2" line
        !           100:     }
        !           101:     append afterUnion [string trimright $line]\n
        !           102:   } elseif {$line=="" && [eof stdin]} {
        !           103:     # no-op
        !           104:   } else {
        !           105:     append afterUnion $line\n
        !           106:   }
        !           107: }
        !           108: 
        !           109: # Output the resulting text.
        !           110: #
        !           111: puts -nonewline $beforeUnion
        !           112: puts "  /********************************************************************"
        !           113: puts "  ** Automatically generated code"
        !           114: puts "  **"
        !           115: puts "  ** The following union is automatically generated by the"
        !           116: puts "  ** vdbe-compress.tcl script.  The purpose of this union is to"
        !           117: puts "  ** reduce the amount of stack space required by this function."
        !           118: puts "  ** See comments in the vdbe-compress.tcl script for details."
        !           119: puts "  */"
        !           120: puts "  union vdbeExecUnion \173"
        !           121: puts -nonewline $unionDef
        !           122: puts "  \175 u;"
        !           123: puts "  /* End automatically generated code"
        !           124: puts "  ********************************************************************/"
        !           125: puts -nonewline $afterUnion