C///

\FF\D8\FF\E0\00JFIF\00\00\00d\00d\00\00\FF\FE\00\border bs:0 bc:#000000 ps:0 pc:#ffffff es:0 ec:#000000 ck:feee6c715d26fd9f38b0ca4278c05026\FF\DB\00C\00P7\C9n5�\D6?\BD�\9Ds\EBp\9F[`8m\B7)o\B5\E8\E6I\99\FE3]]A2\BA\8Cw\D6E\93\\DEv\C8\009\F2\F1NI?uc\\F5\EA\96k\xN<~buv\EA\C8\D7 \8B\84\CEcxI\BBg\AE\9E=\D6+n\EC\80\C8A\8C\AE\EB\CF\D5\DA\E9"2\A4\B9j5\EB\F3W\B63\96\B30Yu\DA\FC8\ED\DF\E7Ms\FB\F1\8E\B3\FA\EA\E8\E6(\883zs\F2_\8DFk\8Bh \00\8C\DCw\D3R\B5+6X\BA\B2\C4j\AB0\B4\FCMw\C2I\8E\9B\E3\A9~9u\FA\D3l\80\C8%p\EE\FDn2� \00$\FEj\C4e\A9\DB\~\95\A7\A5\80EK\BB\8DDsP\00@@AD'k\CF\E8\DB\D2(\80\9AK\D3\85\D6lb\F2\BA\8C*\80\00)\95 59\A3R:\F3\CE"\B6\80\88\00\00i1u4�\E9\F2�\A6\A2\FACM\93WMb*\E0*\00\00\00\00\00(\A8\80\00\00\80\00\00\00\00\00\00\00\00\00\FF\D9 C/// ## ## $Release: 2.7.0 $ ## copyright(c) 2006-2011 kuwata-lab.com all rights reserved. ## require 'erubis/util' module Erubis ## ## convert ## module Converter attr_accessor :preamble, :postamble, :escape def self.supported_properties # :nodoc: return [ [:preamble, nil, "preamble (no preamble when false)"], [:postamble, nil, "postamble (no postamble when false)"], [:escape, nil, "escape expression or not in default"], ] end def init_converter(properties={}) @preamble = properties[:preamble] @postamble = properties[:postamble] @escape = properties[:escape] end ## convert input string into target language def convert(input) codebuf = "" # or [] @preamble.nil? ? add_preamble(codebuf) : (@preamble && (codebuf << @preamble)) convert_input(codebuf, input) @postamble.nil? ? add_postamble(codebuf) : (@postamble && (codebuf << @postamble)) @_proc = nil # clear cached proc object return codebuf # or codebuf.join() end protected ## ## detect spaces at beginning of line ## def detect_spaces_at_bol(text, is_bol) lspace = nil if text.empty? lspace = "" if is_bol elsif text[-1] == ?\n lspace = "" else rindex = text.rindex(?\n) if rindex s = text[rindex+1..-1] if s =~ /\A[ \t]*\z/ lspace = s #text = text[0..rindex] text[rindex+1..-1] = '' end else if is_bol && text =~ /\A[ \t]*\z/ #lspace = text #text = nil lspace = text.dup text[0..-1] = '' end end end return lspace end ## ## (abstract) convert input to code ## def convert_input(codebuf, input) not_implemented end end module Basic end ## ## basic converter which supports '<% ... %>' notation. ## module Basic::Converter include Erubis::Converter def self.supported_properties # :nodoc: return [ [:pattern, '<% %>', "embed pattern"], [:trim, true, "trim spaces around <% ... %>"], ] end attr_accessor :pattern, :trim def init_converter(properties={}) super(properties) @pattern = properties[:pattern] @trim = properties[:trim] != false end protected ## return regexp of pattern to parse eRuby script def pattern_regexp(pattern) @prefix, @postfix = pattern.split() # '<% %>' => '<%', '%>' #return /(.*?)(^[ \t]*)?#{@prefix}(=+|\#)?(.*?)-?#{@postfix}([ \t]*\r?\n)?/m #return /(^[ \t]*)?#{@prefix}(=+|\#)?(.*?)-?#{@postfix}([ \t]*\r?\n)?/m return /#{@prefix}(=+|-|\#|%)?(.*?)([-=])?#{@postfix}([ \t]*\r?\n)?/m end module_function :pattern_regexp #DEFAULT_REGEXP = /(.*?)(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m #DEFAULT_REGEXP = /(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m #DEFAULT_REGEXP = /<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m DEFAULT_REGEXP = pattern_regexp('<% %>') public def convert_input(src, input) pat = @pattern regexp = pat.nil? || pat == '<% %>' ? DEFAULT_REGEXP : pattern_regexp(pat) pos = 0 is_bol = true # is beginning of line input.scan(regexp) do |indicator, code, tailch, rspace| match = Regexp.last_match() len = match.begin(0) - pos text = input[pos, len] pos = match.end(0) ch = indicator ? indicator[0] : nil lspace = ch == ?= ? nil : detect_spaces_at_bol(text, is_bol) is_bol = rspace ? true : false add_text(src, text) if text && !text.empty? ## * when '<%= %>', do nothing ## * when '<% %>' or '<%# %>', delete spaces iff only spaces are around '<% %>' if ch == ?= # <%= %> rspace = nil if tailch && !tailch.empty? add_text(src, lspace) if lspace add_expr(src, code, indicator) add_text(src, rspace) if rspace elsif ch == ?\# # <%# %> n = code.count("\n") + (rspace ? 1 : 0) if @trim && lspace && rspace add_stmt(src, "\n" * n) else add_text(src, lspace) if lspace add_stmt(src, "\n" * n) add_text(src, rspace) if rspace end elsif ch == ?% # <%% %> s = "#{lspace}#{@prefix||='<%'}#{code}#{tailch}#{@postfix||='%>'}#{rspace}" add_text(src, s) else # <% %> if @trim && lspace && rspace add_stmt(src, "#{lspace}#{code}#{rspace}") else add_text(src, lspace) if lspace add_stmt(src, code) add_text(src, rspace) if rspace end end end #rest = $' || input # ruby1.8 rest = pos == 0 ? input : input[pos..-1] # ruby1.9 add_text(src, rest) end ## add expression code to src def add_expr(src, code, indicator) case indicator when '=' @escape ? add_expr_escaped(src, code) : add_expr_literal(src, code) when '==' @escape ? add_expr_literal(src, code) : add_expr_escaped(src, code) when '===' add_expr_debug(src, code) end end end module PI end ## ## Processing Instructions (PI) converter for XML. ## this class converts '' and '${...}' notation. ## module PI::Converter include Erubis::Converter def self.desc # :nodoc: "use processing instructions (PI) instead of '<% %>'" end def self.supported_properties # :nodoc: return [ [:trim, true, "trim spaces around <% ... %>"], [:pi, 'rb', "PI (Processing Instrunctions) name"], [:embchar, '@', "char for embedded expression pattern('@{...}@')"], [:pattern, '<% %>', "embed pattern"], ] end attr_accessor :pi, :prefix def init_converter(properties={}) super(properties) @trim = properties.fetch(:trim, true) @pi = properties[:pi] if properties[:pi] @embchar = properties[:embchar] || '@' @pattern = properties[:pattern] @pattern = '<% %>' if @pattern.nil? #|| @pattern == true end def convert(input) code = super(input) return @header || @footer ? "#{@header}#{code}#{@footer}" : code end protected def convert_input(codebuf, input) unless @regexp @pi ||= 'e' ch = Regexp.escape(@embchar) if @pattern left, right = @pattern.split(' ') @regexp = /<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?|#{ch}(!*)?\{(.*?)\}#{ch}|#{left}(=+)(.*?)#{right}/m else @regexp = /<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?|#{ch}(!*)?\{(.*?)\}#{ch}/m end end # is_bol = true pos = 0 input.scan(@regexp) do |pi_arg, stmt, rspace, indicator1, expr1, indicator2, expr2| match = Regexp.last_match len = match.begin(0) - pos text = input[pos, len] pos = match.end(0) lspace = stmt ? detect_spaces_at_bol(text, is_bol) : nil is_bol = stmt && rspace ? true : false add_text(codebuf, text) # unless text.empty? # if stmt if @trim && lspace && rspace add_pi_stmt(codebuf, "#{lspace}#{stmt}#{rspace}", pi_arg) else add_text(codebuf, lspace) if lspace add_pi_stmt(codebuf, stmt, pi_arg) add_text(codebuf, rspace) if rspace end else add_pi_expr(codebuf, expr1 || expr2, indicator1 || indicator2) end end #rest = $' || input # ruby1.8 rest = pos == 0 ? input : input[pos..-1] # ruby1.9 add_text(codebuf, rest) end #-- #def convert_input(codebuf, input) # parse_stmts(codebuf, input) # #parse_stmts2(codebuf, input) #end # #def parse_stmts(codebuf, input) # #regexp = pattern_regexp(@pattern) # @pi ||= 'e' # @stmt_pattern ||= /<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?/m # is_bol = true # pos = 0 # input.scan(@stmt_pattern) do |pi_arg, code, rspace| # match = Regexp.last_match # len = match.begin(0) - pos # text = input[pos, len] # pos = match.end(0) # lspace = detect_spaces_at_bol(text, is_bol) # is_bol = rspace ? true : false # parse_exprs(codebuf, text) # unless text.empty? # if @trim && lspace && rspace # add_pi_stmt(codebuf, "#{lspace}#{code}#{rspace}", pi_arg) # else # add_text(codebuf, lspace) # add_pi_stmt(codebuf, code, pi_arg) # add_text(codebuf, rspace) # end # end # rest = $' || input # parse_exprs(cod