home *** CD-ROM | disk | FTP | other *** search
/ PC Professionell 2004 December / PCpro_2004_12.ISO / files / webserver / xampp / xampp-python-addon-1.4.9-installer.exe / psp.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2004-10-01  |  14.6 KB  |  367 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.3)
  3.  
  4. import apache
  5. import Session
  6. import util
  7. import _psp
  8. import _apache
  9. import sys
  10. import os
  11. import marshal
  12. import new
  13. from cgi import escape
  14. import anydbm
  15. import whichdb
  16. import tempfile
  17. dbm_types = { }
  18. tempdir = tempfile.gettempdir()
  19.  
  20. def path_split(filename):
  21.     (dir, fname) = os.path.split(filename)
  22.     if sys.platform.startswith('win'):
  23.         dir += '\\'
  24.     else:
  25.         dir += '/'
  26.     return (dir, fname)
  27.  
  28.  
  29. def code2str(c):
  30.     ctuple = (c.co_argcount, c.co_nlocals, c.co_stacksize, c.co_flags, c.co_code, c.co_consts, c.co_names, c.co_varnames, c.co_filename, c.co_name, c.co_firstlineno, c.co_lnotab)
  31.     return marshal.dumps(ctuple)
  32.  
  33.  
  34. def str2code(s):
  35.     return new.code(*marshal.loads(s))
  36.  
  37.  
  38. class PSPInterface:
  39.     
  40.     def __init__(self, req, filename, form):
  41.         self.req = req
  42.         self.filename = filename
  43.         self.error_page = None
  44.         self.form = form
  45.  
  46.     
  47.     def set_error_page(self, page):
  48.         if page and page[0] == '/':
  49.             self.error_page = PSP(self.req, self.req.document_root() + page)
  50.         else:
  51.             dir = path_split(self.filename)[0]
  52.             self.error_page = PSP(self.req, dir + page)
  53.  
  54.     
  55.     def apply_data(self, object):
  56.         if not (self.form):
  57.             self.form = util.FieldStorage(self.req, keep_blank_values = 1)
  58.         
  59.         return util.apply_fs_data(object, self.form, req = self.req)
  60.  
  61.     
  62.     def redirect(self, location, permanent = 0):
  63.         util.redirect(self.req, location, permanent)
  64.  
  65.  
  66.  
  67. class PSP:
  68.     code = None
  69.     dbmcache = None
  70.     
  71.     def __init__(self, req, filename = None, string = None, vars = { }):
  72.         if string and filename:
  73.             raise ValueError, 'Must specify either filename or string'
  74.         
  75.         (self.req, self.vars) = (req, vars)
  76.         if not filename and not string:
  77.             filename = req.filename
  78.         
  79.         (self.filename, self.string) = (filename, string)
  80.         if filename:
  81.             if not os.path.isabs(filename):
  82.                 base = os.path.split(req.filename)[0]
  83.                 self.filename = os.path.join(base, filename)
  84.             
  85.             self.load_from_file()
  86.         else:
  87.             cached = strcache.get(string)
  88.             if cached:
  89.                 self.code = cached
  90.             else:
  91.                 self.code = _psp.parsestring(string)
  92.                 strcache.store(string)
  93.  
  94.     
  95.     def cache_get(self, filename, mtime):
  96.         opts = self.req.get_options()
  97.         if opts.has_key('PSPDbmCache'):
  98.             self.dbmcache = opts['PSPDbmCache']
  99.         
  100.         if self.dbmcache:
  101.             cached = dbm_cache_get(self.req.server, self.dbmcache, filename, mtime)
  102.             if cached:
  103.                 return cached
  104.             
  105.         
  106.         cached = mem_fcache.get(filename, mtime)
  107.         if cached:
  108.             return cached
  109.         
  110.  
  111.     
  112.     def cache_store(self, filename, mtime, code):
  113.         if self.dbmcache:
  114.             dbm_cache_store(self.req.server, self.dbmcache, filename, mtime, code)
  115.         else:
  116.             mem_fcache.store(filename, mtime, code)
  117.  
  118.     
  119.     def cfile_get(self, filename, mtime):
  120.         (name, ext) = os.path.splitext(filename)
  121.         cname = name + ext[:-1] + 'c'
  122.         if os.path.isfile(cname):
  123.             cmtime = os.path.getmtime(cname)
  124.             if cmtime >= mtime:
  125.                 return str2code(open(cname).read())
  126.             
  127.         
  128.  
  129.     
  130.     def load_from_file(self):
  131.         filename = self.filename
  132.         if not os.path.isfile(filename):
  133.             raise ValueError, '%s is not a file' % filename
  134.         
  135.         mtime = os.path.getmtime(filename)
  136.         code = self.cache_get(filename, mtime)
  137.         if not code:
  138.             code = self.cfile_get(filename, mtime)
  139.         
  140.         if not code:
  141.             (dir, fname) = path_split(self.filename)
  142.             source = _psp.parse(fname, dir)
  143.             code = compile(source, filename, 'exec')
  144.         
  145.         self.cache_store(filename, mtime, code)
  146.         self.code = code
  147.  
  148.     
  149.     def run(self, vars = { }):
  150.         (code, req) = (self.code, self.req)
  151.         session = None
  152.         if 'session' in code.co_names:
  153.             session = Session.Session(req)
  154.         
  155.         form = None
  156.         if 'form' in code.co_names:
  157.             form = util.FieldStorage(req, keep_blank_values = 1)
  158.         
  159.         psp = PSPInterface(req, self.filename, form)
  160.         
  161.         try:
  162.             global_scope = globals().copy()
  163.             global_scope.update({
  164.                 'req': req,
  165.                 'session': session,
  166.                 'form': form,
  167.                 'psp': psp })
  168.             global_scope.update(self.vars)
  169.             global_scope.update(vars)
  170.             
  171.             try:
  172.                 exec code in global_scope
  173.                 req.flush()
  174.                 if session is not None:
  175.                     session.save()
  176.             except:
  177.                 (et, ev, etb) = sys.exc_info()
  178.                 if psp.error_page:
  179.                     psp.error_page.run({
  180.                         'exception': (et, ev, etb) })
  181.                 else:
  182.                     raise et, ev, etb
  183.  
  184.         finally:
  185.             if session is not None:
  186.                 session.unlock()
  187.             
  188.  
  189.  
  190.     
  191.     def __str__(self):
  192.         self.req.content_type = 'text/html'
  193.         self.run()
  194.         return ''
  195.  
  196.     
  197.     def display_code(self):
  198.         '''
  199.         Display a niceliy HTML-formatted side-by-side of
  200.         what PSP generated next to orinial code.
  201.         '''
  202.         (req, filename) = (self.req, self.filename)
  203.         (dir, fname) = path_split(filename)
  204.         source = open(filename).read().splitlines()
  205.         pycode = _psp.parse(fname, dir).splitlines()
  206.         source = [ s.rstrip() for s in source ]
  207.         pycode = [ s.rstrip() for s in pycode ]
  208.         req.write('<table>\n<tr>')
  209.         for s in ('', ' PSP-produced Python Code:', ' %s:' % filename):
  210.             req.write('<td><tt>%s</tt></td>' % s)
  211.         
  212.         req.write('</tr>\n')
  213.         n = 1
  214.         for line in pycode:
  215.             req.write('<tr>')
  216.             left = escape(line).replace('\t', ' ' * 4).replace(' ', ' ')
  217.             for s in ('%d. ' % n, '<font color=blue>%s</font>' % left, ' <font color=green>%s</font>' % right):
  218.                 req.write('<td><tt>%s</tt></td>' % s)
  219.             
  220.             req.write('</tr>\n')
  221.             n += 1
  222.         
  223.         req.write('</table>\n')
  224.  
  225.  
  226.  
  227. def parse(filename, dir = None):
  228.     if dir:
  229.         return _psp.parse(filename, dir)
  230.     else:
  231.         return _psp.parse(filename)
  232.  
  233.  
  234. def parsestring(str):
  235.     return _psp.parsestring(str)
  236.  
  237.  
  238. def handler(req):
  239.     req.content_type = 'text/html'
  240.     config = req.get_config()
  241.     debug = debug = int(config.get('PythonDebug', 0))
  242.     if debug and req.filename[-1] == '_':
  243.         p = PSP(req, req.filename[:-1])
  244.         p.display_code()
  245.     else:
  246.         p = PSP(req)
  247.         p.run()
  248.     return apache.OK
  249.  
  250.  
  251. def dbm_cache_type(dbmfile):
  252.     if dbm_types.has_key(dbmfile):
  253.         return dbm_types[dbmfile]
  254.     
  255.     module = whichdb.whichdb(dbmfile)
  256.     if module:
  257.         dbm_type = __import__(module)
  258.         dbm_types[dbmfile] = dbm_type
  259.         return dbm_type
  260.     else:
  261.         return anydbm
  262.  
  263.  
  264. def dbm_cache_store(srv, dbmfile, filename, mtime, val):
  265.     dbm_type = dbm_cache_type(dbmfile)
  266.     _apache._global_lock(srv, 'pspcache')
  267.     
  268.     try:
  269.         dbm = dbm_type.open(dbmfile, 'c')
  270.         dbm[filename] = '%d %s' % (mtime, code2str(val))
  271.     finally:
  272.         
  273.         try:
  274.             dbm.close()
  275.         except:
  276.             pass
  277.  
  278.         _apache._global_unlock(srv, 'pspcache')
  279.  
  280.  
  281.  
  282. def dbm_cache_get(srv, dbmfile, filename, mtime):
  283.     dbm_type = dbm_cache_type(dbmfile)
  284.     _apache._global_lock(srv, 'pspcache')
  285.     
  286.     try:
  287.         dbm = dbm_type.open(dbmfile, 'c')
  288.         
  289.         try:
  290.             entry = dbm[filename]
  291.             (t, val) = entry.split(' ', 1)
  292.             if long(t) == mtime:
  293.                 return str2code(val)
  294.         except KeyError:
  295.             return None
  296.  
  297.     finally:
  298.         
  299.         try:
  300.             dbm.close()
  301.         except:
  302.             pass
  303.  
  304.         _apache._global_unlock(srv, 'pspcache')
  305.  
  306.  
  307.  
  308. class HitsCache:
  309.     
  310.     def __init__(self, size = 512):
  311.         self.cache = { }
  312.         self.size = size
  313.  
  314.     
  315.     def store(self, key, val):
  316.         self.cache[key] = (1, val)
  317.         if len(self.cache) > self.size:
  318.             self.clean()
  319.         
  320.  
  321.     
  322.     def get(self, key):
  323.         if self.cache.has_key(key):
  324.             (hist, val) = self.cache[key]
  325.             self.cache[key] = (hits + 1, code)
  326.             return val
  327.         else:
  328.             return None
  329.  
  330.     
  331.     def clean(self):
  332.         byhits = [ (n[1], n[0]) for n in self.cache.items() ]
  333.         byhits.sort()
  334.         for item in byhits[:len(self.cache) - int(self.size * 0.75)]:
  335.             (val, key) = item
  336.             del self.cache[key]
  337.         
  338.  
  339.  
  340. mem_scache = HitsCache()
  341.  
  342. class FileCache(HitsCache):
  343.     
  344.     def store(self, filename, mtime, code):
  345.         self.cache[filename] = (1, mtime, code)
  346.         if len(self.cache) > self.size:
  347.             self.clean()
  348.         
  349.  
  350.     
  351.     def get(self, filename, mtime):
  352.         
  353.         try:
  354.             (hits, c_mtime, code) = self.cache[filename]
  355.             if mtime != c_mtime:
  356.                 del self.cache[filename]
  357.                 return None
  358.             else:
  359.                 self.cache[filename] = (hits + 1, mtime, code)
  360.                 return code
  361.         except KeyError:
  362.             return None
  363.  
  364.  
  365.  
  366. mem_fcache = FileCache()
  367.