?login_element?

Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

  1. #!/usr/bin/env python
  2. #
  3. # Copyright 2008, Google Inc.
  4. # All rights reserved.
  5. #
  6. # Redistribution and use in source and binary forms, with or without
  7. # modification, are permitted provided that the following conditions are
  8. # met:
  9. #
  10. #     * Redistributions of source code must retain the above copyright
  11. # notice, this list of conditions and the following disclaimer.
  12. #     * Redistributions in binary form must reproduce the above
  13. # copyright notice, this list of conditions and the following disclaimer
  14. # in the documentation and/or other materials provided with the
  15. # distribution.
  16. #     * Neither the name of Google Inc. nor the names of its
  17. # contributors may be used to endorse or promote products derived from
  18. # this software without specific prior written permission.
  19. #
  20. # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21. # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22. # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23. # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24. # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25. # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26. # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27. # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28. # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29. # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30. # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31.  
  32. """pump v0.2.0 - Pretty Useful for Meta Programming.
  33.  
  34. A tool for preprocessor meta programming.  Useful for generating
  35. repetitive boilerplate code.  Especially useful for writing C++
  36. classes, functions, macros, and templates that need to work with
  37. various number of arguments.
  38.  
  39. USAGE:
  40.       pump.py SOURCE_FILE
  41.  
  42. EXAMPLES:
  43.       pump.py foo.cc.pump
  44.         Converts foo.cc.pump to foo.cc.
  45.  
  46. GRAMMAR:
  47.       CODE ::= ATOMIC_CODE*
  48.       ATOMIC_CODE ::= $var ID = EXPRESSION
  49.           | $var ID = [[ CODE ]]
  50.           | $range ID EXPRESSION..EXPRESSION
  51.           | $for ID SEPARATOR [[ CODE ]]
  52.           | $($)
  53.           | $ID
  54.           | $(EXPRESSION)
  55.           | $if EXPRESSION [[ CODE ]] ELSE_BRANCH
  56.           | [[ CODE ]]
  57.           | RAW_CODE
  58.       SEPARATOR ::= RAW_CODE | EMPTY
  59.       ELSE_BRANCH ::= $else [[ CODE ]]
  60.           | $elif EXPRESSION [[ CODE ]] ELSE_BRANCH
  61.           | EMPTY
  62.       EXPRESSION has Python syntax.
  63. """
  64.  
  65. __author__ = 'wan@google.com (Zhanyong Wan)'
  66.  
  67. import os
  68. import re
  69. import sys
  70.  
  71.  
  72. TOKEN_TABLE = [
  73.     (re.compile(r'\$var\s+'), '$var'),
  74.     (re.compile(r'\$elif\s+'), '$elif'),
  75.     (re.compile(r'\$else\s+'), '$else'),
  76.     (re.compile(r'\$for\s+'), '$for'),
  77.     (re.compile(r'\$if\s+'), '$if'),
  78.     (re.compile(r'\$range\s+'), '$range'),
  79.     (re.compile(r'\$[_A-Za-z]\w*'), '$id'),
  80.     (re.compile(r'\$\(\$\)'), '$($)'),
  81.     (re.compile(r'\$'), '$'),
  82.     (re.compile(r'\[\[\n?'), '[['),
  83.     (re.compile(r'\]\]\n?'), ']]'),
  84.     ]
  85.  
  86.  
  87. class Cursor:
  88.   """Represents a position (line and column) in a text file."""
  89.  
  90.   def __init__(self, line=-1, column=-1):
  91.     self.line = line
  92.     self.column = column
  93.  
  94.   def __eq__(self, rhs):
  95.     return self.line == rhs.line and self.column == rhs.column
  96.  
  97.   def __ne__(self, rhs):
  98.     return not self == rhs
  99.  
  100.   def __lt__(self, rhs):
  101.     return self.line < rhs.line or (
  102.         self.line == rhs.line and self.column < rhs.column)
  103.  
  104.   def __le__(self, rhs):
  105.     return self < rhs or self == rhs
  106.  
  107.   def __gt__(self, rhs):
  108.     return rhs < self
  109.  
  110.   def __ge__(self, rhs):
  111.     return rhs <= self
  112.  
  113.   def __str__(self):
  114.     if self == Eof():
  115.       return 'EOF'
  116.     else:
  117.       return '%s(%s)' % (self.line + 1, self.column)
  118.  
  119.   def __add__(self, offset):
  120.     return Cursor(self.line, self.column + offset)
  121.  
  122.   def __sub__(self, offset):
  123.     return Cursor(self.line, self.column - offset)
  124.  
  125.   def Clone(self):
  126.     """Returns a copy of self."""
  127.  
  128.     return Cursor(self.line, self.column)
  129.  
  130.  
  131. # Special cursor to indicate the end-of-file.
  132. def Eof():
  133.   """Returns the special cursor to denote the end-of-file."""
  134.   return Cursor(-1, -1)
  135.  
  136.  
  137. class Token:
  138.   """Represents a token in a Pump source file."""
  139.  
  140.   def __init__(self, start=None, end=None, value=None, token_type=None):
  141.     if start is None:
  142.       self.start = Eof()
  143.     else:
  144.       self.start = start
  145.     if end is None:
  146.       self.end = Eof()
  147.     else:
  148.       self.end = end
  149.     self.value = value
  150.     self.token_type = token_type
  151.  
  152.   def __str__(self):
  153.     return 'Token @%s: \'%s\' type=%s' % (
  154.         self.start, self.value, self.token_type)
  155.  
  156.   def Clone(self):
  157.     """Returns a copy of self."""
  158.  
  159.     return Token(self.start.Clone(), self.end.Clone(), self.value,
  160.                  self.token_type)
  161.  
  162.  
  163. def StartsWith(lines, pos, string):
  164.   """Returns True iff the given position in lines starts with 'string'."""
  165.  
  166.   return lines[pos.line][pos.column:].startswith(string)
  167.  
  168.  
  169. def FindFirstInLine(line, token_table):
  170.   best_match_start = -1
  171.   for (regex, token_type) in token_table:
  172.     m = regex.search(line)
  173.     if m:
  174.       # We found regex in lines
  175.       if best_match_start < 0 or m.start() < best_match_start:
  176.         best_match_start = m.start()
  177.         best_match_length = m.end() - m.start()
  178.         best_match_token_type = token_type
  179.  
  180.   if best_match_start < 0:
  181.     return None
  182.  
  183.   return (best_match_start, best_match_length, best_match_token_type)
  184.  
  185.  
  186. def FindFirst(lines, token_table, cursor):
  187.   """Finds the first occurrence of any string in strings in lines."""
  188.  
  189.   start = cursor.Clone()
  190.   cur_line_number = cursor.line
  191.   for line in lines[start.line:]:
  192.     if cur_line_number == start.line:
  193.       line = line[start.column:]
  194.     m = FindFirstInLine(line, token_table)
  195.     if m:
  196.       # We found a regex in line.
  197.       (start_column, length, token_type) = m
  198.       if cur_line_number == start.line:
  199.         start_column += start.column
  200.       found_start = Cursor(cur_line_number, start_column)
  201.       found_end = found_start + length
  202.       return MakeToken(lines, found_start, found_end, token_type)
  203.     cur_line_number += 1
  204.   # We failed to find str in lines
  205.   return None
  206.  
  207.  
  208. def SubString(lines, start, end):
  209.   """Returns a substring in lines."""
  210.  
  211.   if end == Eof():
  212.     end = Cursor(len(lines) - 1, len(lines[-1]))
  213.  
  214.   if start >= end:
  215.     return ''
  216.  
  217.   if start.line == end.line:
  218.     return lines[start.line][start.column:end.column]
  219.  
  220.   result_lines = ([lines[start.line][start.column:]] +
  221.                   lines[start.line + 1:end.line] +
  222.                   [lines[end.line][:end.column]])
  223.   return ''.join(result_lines)
  224.  
  225.  
  226. def StripMetaComments(str):
  227.   """Strip meta comments from each line in the given string."""
  228.  
  229.   # First, completely remove lines containing nothing but a meta
  230.   # comment, including the trailing \n.
  231.   str = re.sub(r'^\s*\$\$.*\n', '', str)
  232.  
  233.   # Then, remove meta comments from contentful lines.
  234.   return re.sub(r'\s*\$\$.*', '', str)
  235.  
  236.  
  237. def MakeToken(lines, start, end, token_type):
  238.   """Creates a new instance of Token."""
  239.  
  240.   return Token(start, end, SubString(lines, start, end), token_type)
  241.  
  242.  
  243. def ParseToken(lines, pos, regex, token_type):
  244.   line = lines[pos.line][pos.column:]
  245.   m = regex.search(line)
  246.   if m and not m.start():
  247.     return MakeToken(lines, pos, pos + m.end(), token_type)
  248.   else:
  249.     print 'ERROR: %s expected at %s.' % (token_type, pos)
  250.     sys.exit(1)
  251.  
  252.  
  253. ID_REGEX = re.compile(r'[_A-Za-z]\w*')
  254. EQ_REGEX = re.compile(r'=')
  255. REST_OF_LINE_REGEX = re.compile(r'.*?(?=$|\$\$)')
  256. OPTIONAL_WHITE_SPACES_REGEX = re.compile(r'\s*')
  257. WHITE_SPACE_REGEX = re.compile(r'\s')
  258. DOT_DOT_REGEX = re.compile(r'\.\.')
  259.  
  260.  
  261. def Skip(lines, pos, regex):
  262.   line = lines[pos.line][pos.column:]
  263.   m = re.search(regex, line)
  264.   if m and not m.start():
  265.     return pos + m.end()
  266.   else:
  267.     return pos
  268.  
  269.  
  270. def SkipUntil(lines, pos, regex, token_type):
  271.   line = lines[pos.line][pos.column:]
  272.   m = re.search(regex, line)
  273.   if m:
  274.     return pos + m.start()
  275.   else:
  276.     print ('ERROR: %s expected on line %s after column %s.' %
  277.            (token_type, pos.line + 1, pos.column))
  278.     sys.exit(1)
  279.  
  280.  
  281. def ParseExpTokenInParens(lines, pos):
  282.   def ParseInParens(pos):
  283.     pos = Skip(lines, pos, OPTIONAL_WHITE_SPACES_REGEX)
  284.     pos = Skip(lines, pos, r'\(')
  285.     pos = Parse(pos)
  286.     pos = Skip(lines, pos, r'\)')
  287.     return pos
  288.  
  289.   def Parse(pos):
  290.     pos = SkipUntil(lines, pos, r'\(|\)', ')')
  291.     if SubString(lines, pos, pos + 1) == '(':
  292.       pos = Parse(pos + 1)
  293.       pos = Skip(lines, pos, r'\)')
  294.       return Parse(pos)
  295.     else:
  296.       return pos
  297.  
  298.   start = pos.Clone()
  299.   pos = ParseInParens(pos)
  300.   return MakeToken(lines, start, pos, 'exp')
  301.  
  302.  
  303. def RStripNewLineFromToken(token):
  304.   if token.value.endswith('\n'):
  305.     return Token(token.start, token.end, token.value[:-1], token.token_type)
  306.   else:
  307.     return token
  308.  
  309.  
  310. def TokenizeLines(lines, pos):
  311.   while True:
  312.     found = FindFirst(lines, TOKEN_TABLE, pos)
  313.     if not found:
  314.       yield MakeToken(lines, pos, Eof(), 'code')
  315.       return
  316.  
  317.     if found.start == pos:
  318.       prev_token = None
  319.       prev_token_rstripped = None
  320.     else:
  321.       prev_token = MakeToken(lines, pos, found.start, 'code')
  322.       prev_token_rstripped = RStripNewLineFromToken(prev_token)
  323.  
  324.     if found.token_type == '$var':
  325.       if prev_token_rstripped:
  326.         yield prev_token_rstripped
  327.       yield found
  328.       id_token = ParseToken(lines, found.end, ID_REGEX, 'id')
  329.       yield id_token
  330.       pos = Skip(lines, id_token.end, OPTIONAL_WHITE_SPACES_REGEX)
  331.  
  332.       eq_token = ParseToken(lines, pos, EQ_REGEX, '=')
  333.       yield eq_token
  334.       pos = Skip(lines, eq_token.end, r'\s*')
  335.  
  336.       if SubString(lines, pos, pos + 2) != '[[':
  337.         exp_token = ParseToken(lines, pos, REST_OF_LINE_REGEX, 'exp')
  338.         yield exp_token
  339.         pos = Cursor(exp_token.end.line + 1, 0)
  340.     elif found.token_type == '$for':
  341.       if prev_token_rstripped:
  342.         yield prev_token_rstripped
  343.       yield found
  344.       id_token = ParseToken(lines, found.end, ID_REGEX, 'id')
  345.       yield id_token
  346.       pos = Skip(lines, id_token.end, WHITE_SPACE_REGEX)
  347.     elif found.token_type == '$range':
  348.       if prev_token_rstripped:
  349.         yield prev_token_rstripped
  350.       yield found
  351.       id_token = ParseToken(lines, found.end, ID_REGEX, 'id')
  352.       yield id_token
  353.       pos = Skip(lines, id_token.end, OPTIONAL_WHITE_SPACES_REGEX)
  354.  
  355.       dots_pos = SkipUntil(lines, pos, DOT_DOT_REGEX, '..')
  356.       yield MakeToken(lines, pos, dots_pos, 'exp')
  357.       yield MakeToken(lines, dots_pos, dots_pos + 2, '..')
  358.       pos = dots_pos + 2
  359.       new_pos = Cursor(pos.line + 1, 0)
  360.       yield MakeToken(lines, pos, new_pos, 'exp')
  361.       pos = new_pos
  362.     elif found.token_type == '$':
  363.       if prev_token:
  364.         yield prev_token
  365.       yield found
  366.       exp_token = ParseExpTokenInParens(lines, found.end)
  367.       yield exp_token
  368.       pos = exp_token.end
  369.     elif (found.token_type == ']]' or found.token_type == '$if' or
  370.           found.token_type == '$elif' or found.token_type == '$else'):
  371.       if prev_token_rstripped:
  372.         yield prev_token_rstripped
  373.       yield found
  374.       pos = found.end
  375.     else:
  376.       if prev_token:
  377.         yield prev_token
  378.       yield found
  379.       pos = found.end
  380.  
  381.  
  382. def Tokenize(s):
  383.   """A generator that yields the tokens in the given string."""
  384.   if s != '':
  385.     lines = s.splitlines(True)
  386.     for token in TokenizeLines(lines, Cursor(0, 0)):
  387.       yield token
  388.  
  389.  
  390. class CodeNode:
  391.   def __init__(self, atomic_code_list=None):
  392.     self.atomic_code = atomic_code_list
  393.  
  394.  
  395. class VarNode:
  396.   def __init__(self, identifier=None, atomic_code=None):
  397.     self.identifier = identifier
  398.     self.atomic_code = atomic_code
  399.  
  400.  
  401. class RangeNode:
  402.   def __init__(self, identifier=None, exp1=None, exp2=None):
  403.     self.identifier = identifier
  404.     self.exp1 = exp1
  405.     self.exp2 = exp2
  406.  
  407.  
  408. class ForNode:
  409.   def __init__(self, identifier=None, sep=None, code=None):
  410.     self.identifier = identifier
  411.     self.sep = sep
  412.     self.code = code
  413.  
  414.  
  415. class ElseNode:
  416.   def __init__(self, else_branch=None):
  417.     self.else_branch = else_branch
  418.  
  419.  
  420. class IfNode:
  421.   def __init__(self, exp=None, then_branch=None, else_branch=None):
  422.     self.exp = exp
  423.     self.then_branch = then_branch
  424.     self.else_branch = else_branch
  425.  
  426.  
  427. class RawCodeNode:
  428.   def __init__(self, token=None):
  429.     self.raw_code = token
  430.  
  431.  
  432. class LiteralDollarNode:
  433.   def __init__(self, token):
  434.     self.token = token
  435.  
  436.  
  437. class ExpNode:
  438.   def __init__(self, token, python_exp):
  439.     self.token = token
  440.     self.python_exp = python_exp
  441.  
  442.  
  443. def PopFront(a_list):
  444.   head = a_list[0]
  445.   a_list[:1] = []
  446.   return head
  447.  
  448.  
  449. def PushFront(a_list, elem):
  450.   a_list[:0] = [elem]
  451.  
  452.  
  453. def PopToken(a_list, token_type=None):
  454.   token = PopFront(a_list)
  455.   if token_type is not None and token.token_type != token_type:
  456.     print 'ERROR: %s expected at %s' % (token_type, token.start)
  457.     print 'ERROR: %s found instead' % (token,)
  458.     sys.exit(1)
  459.  
  460.   return token
  461.  
  462.  
  463. def PeekToken(a_list):
  464.   if not a_list:
  465.     return None
  466.  
  467.   return a_list[0]
  468.  
  469.  
  470. def ParseExpNode(token):
  471.   python_exp = re.sub(r'([_A-Za-z]\w*)', r'self.GetValue("\1")', token.value)
  472.   return ExpNode(token, python_exp)
  473.  
  474.  
  475. def ParseElseNode(tokens):
  476.   def Pop(token_type=None):
  477.     return PopToken(tokens, token_type)
  478.  
  479.   next = PeekToken(tokens)
  480.   if not next:
  481.     return None
  482.   if next.token_type == '$else':
  483.     Pop('$else')
  484.     Pop('[[')
  485.     code_node = ParseCodeNode(tokens)
  486.     Pop(']]')
  487.     return code_node
  488.   elif next.token_type == '$elif':
  489.     Pop('$elif')
  490.     exp = Pop('code')
  491.     Pop('[[')
  492.     code_node = ParseCodeNode(tokens)
  493.     Pop(']]')
  494.     inner_else_node = ParseElseNode(tokens)
  495.     return CodeNode([IfNode(ParseExpNode(exp), code_node, inner_else_node)])
  496.   elif not next.value.strip():
  497.     Pop('code')
  498.     return ParseElseNode(tokens)
  499.   else:
  500.     return None
  501.  
  502.  
  503. def ParseAtomicCodeNode(tokens):
  504.   def Pop(token_type=None):
  505.     return PopToken(tokens, token_type)
  506.  
  507.   head = PopFront(tokens)
  508.   t = head.token_type
  509.   if t == 'code':
  510.     return RawCodeNode(head)
  511.   elif t == '$var':
  512.     id_token = Pop('id')
  513.     Pop('=')
  514.     next = PeekToken(tokens)
  515.     if next.token_type == 'exp':
  516.       exp_token = Pop()
  517.       return VarNode(id_token, ParseExpNode(exp_token))
  518.     Pop('[[')
  519.     code_node = ParseCodeNode(tokens)
  520.     Pop(']]')
  521.     return VarNode(id_token, code_node)
  522.   elif t == '$for':
  523.     id_token = Pop('id')
  524.     next_token = PeekToken(tokens)
  525.     if next_token.token_type == 'code':
  526.       sep_token = next_token
  527.       Pop('code')
  528.     else:
  529.       sep_token = None
  530.     Pop('[[')
  531.     code_node = ParseCodeNode(tokens)
  532.     Pop(']]')
  533.     return ForNode(id_token, sep_token, code_node)
  534.   elif t == '$if':
  535.     exp_token = Pop('code')
  536.     Pop('[[')
  537.     code_node = ParseCodeNode(tokens)
  538.     Pop(']]')
  539.     else_node = ParseElseNode(tokens)
  540.     return IfNode(ParseExpNode(exp_token), code_node, else_node)
  541.   elif t == '$range':
  542.     id_token = Pop('id')
  543.     exp1_token = Pop('exp')
  544.     Pop('..')
  545.     exp2_token = Pop('exp')
  546.     return RangeNode(id_token, ParseExpNode(exp1_token),
  547.                      ParseExpNode(exp2_token))
  548.   elif t == '$id':
  549.     return ParseExpNode(Token(head.start + 1, head.end, head.value[1:], 'id'))
  550.   elif t == '$($)':
  551.     return LiteralDollarNode(head)
  552.   elif t == '$':
  553.     exp_token = Pop('exp')
  554.     return ParseExpNode(exp_token)
  555.   elif t == '[[':
  556.     code_node = ParseCodeNode(tokens)
  557.     Pop(']]')
  558.     return code_node
  559.   else:
  560.     PushFront(tokens, head)
  561.     return None
  562.  
  563.  
  564. def ParseCodeNode(tokens):
  565.   atomic_code_list = []
  566.   while True:
  567.     if not tokens:
  568.       break
  569.     atomic_code_node = ParseAtomicCodeNode(tokens)
  570.     if atomic_code_node:
  571.       atomic_code_list.append(atomic_code_node)
  572.     else:
  573.       break
  574.   return CodeNode(atomic_code_list)
  575.  
  576.  
  577. def ParseToAST(pump_src_text):
  578.   """Convert the given Pump source text into an AST."""
  579.   tokens = list(Tokenize(pump_src_text))
  580.   code_node = ParseCodeNode(tokens)
  581.   return code_node
  582.  
  583.  
  584. class Env:
  585.   def __init__(self):
  586.     self.variables = []
  587.     self.ranges = []
  588.  
  589.   def Clone(self):
  590.     clone = Env()
  591.     clone.variables = self.variables[:]
  592.     clone.ranges = self.ranges[:]
  593.     return clone
  594.  
  595.   def PushVariable(self, var, value):
  596.     # If value looks like an int, store it as an int.
  597.     try:
  598.       int_value = int(value)
  599.       if ('%s' % int_value) == value:
  600.         value = int_value
  601.     except Exception:
  602.       pass
  603.     self.variables[:0] = [(var, value)]
  604.  
  605.   def PopVariable(self):
  606.     self.variables[:1] = []
  607.  
  608.   def PushRange(self, var, lower, upper):
  609.     self.ranges[:0] = [(var, lower, upper)]
  610.  
  611.   def PopRange(self):
  612.     self.ranges[:1] = []
  613.  
  614.   def GetValue(self, identifier):
  615.     for (var, value) in self.variables:
  616.       if identifier == var:
  617.         return value
  618.  
  619.     print 'ERROR: meta variable %s is undefined.' % (identifier,)
  620.     sys.exit(1)
  621.  
  622.   def EvalExp(self, exp):
  623.     try:
  624.       result = eval(exp.python_exp)
  625.     except Exception, e:
  626.       print 'ERROR: caught exception %s: %s' % (e.__class__.__name__, e)
  627.       print ('ERROR: failed to evaluate meta expression %s at %s' %
  628.              (exp.python_exp, exp.token.start))
  629.       sys.exit(1)
  630.     return result
  631.  
  632.   def GetRange(self, identifier):
  633.     for (var, lower, upper) in self.ranges:
  634.       if identifier == var:
  635.         return (lower, upper)
  636.  
  637.     print 'ERROR: range %s is undefined.' % (identifier,)
  638.     sys.exit(1)
  639.  
  640.  
  641. class Output:
  642.   def __init__(self):
  643.     self.string = ''
  644.  
  645.   def GetLastLine(self):
  646.     index = self.string.rfind('\n')
  647.     if index < 0:
  648.       return ''
  649.  
  650.     return self.string[index + 1:]
  651.  
  652.   def Append(self, s):
  653.     self.string += s
  654.  
  655.  
  656. def RunAtomicCode(env, node, output):
  657.   if isinstance(node, VarNode):
  658.     identifier = node.identifier.value.strip()
  659.     result = Output()
  660.     RunAtomicCode(env.Clone(), node.atomic_code, result)
  661.     value = result.string
  662.     env.PushVariable(identifier, value)
  663.   elif isinstance(node, RangeNode):
  664.     identifier = node.identifier.value.strip()
  665.     lower = int(env.EvalExp(node.exp1))
  666.     upper = int(env.EvalExp(node.exp2))
  667.     env.PushRange(identifier, lower, upper)
  668.   elif isinstance(node, ForNode):
  669.     identifier = node.identifier.value.strip()
  670.     if node.sep is None:
  671.       sep = ''
  672.     else:
  673.       sep = node.sep.value
  674.     (lower, upper) = env.GetRange(identifier)
  675.     for i in range(lower, upper + 1):
  676.       new_env = env.Clone()
  677.       new_env.PushVariable(identifier, i)
  678.       RunCode(new_env, node.code, output)
  679.       if i != upper:
  680.         output.Append(sep)
  681.   elif isinstance(node, RawCodeNode):
  682.     output.Append(node.raw_code.value)
  683.   elif isinstance(node, IfNode):
  684.     cond = env.EvalExp(node.exp)
  685.     if cond:
  686.       RunCode(env.Clone(), node.then_branch, output)
  687.     elif node.else_branch is not None:
  688.       RunCode(env.Clone(), node.else_branch, output)
  689.   elif isinstance(node, ExpNode):
  690.     value = env.EvalExp(node)
  691.     output.Append('%s' % (value,))
  692.   elif isinstance(node, LiteralDollarNode):
  693.     output.Append('$')
  694.   elif isinstance(node, CodeNode):
  695.     RunCode(env.Clone(), node, output)
  696.   else:
  697.     print 'BAD'
  698.     print node
  699.     sys.exit(1)
  700.  
  701.  
  702. def RunCode(env, code_node, output):
  703.   for atomic_code in code_node.atomic_code:
  704.     RunAtomicCode(env, atomic_code, output)
  705.  
  706.  
  707. def IsSingleLineComment(cur_line):
  708.   return '//' in cur_line
  709.  
  710.  
  711. def IsInPreprocessorDirective(prev_lines, cur_line):
  712.   if cur_line.lstrip().startswith('#'):
  713.     return True
  714.   return prev_lines and prev_lines[-1].endswith('\\')
  715.  
  716.  
  717. def WrapComment(line, output):
  718.   loc = line.find('//')
  719.   before_comment = line[:loc].rstrip()
  720.   if before_comment == '':
  721.     indent = loc
  722.   else:
  723.     output.append(before_comment)
  724.     indent = len(before_comment) - len(before_comment.lstrip())
  725.   prefix = indent*' ' + '// '
  726.   max_len = 80 - len(prefix)
  727.   comment = line[loc + 2:].strip()
  728.   segs = [seg for seg in re.split(r'(\w+\W*)', comment) if seg != '']
  729.   cur_line = ''
  730.   for seg in segs:
  731.     if len((cur_line + seg).rstrip()) < max_len:
  732.       cur_line += seg
  733.     else:
  734.       if cur_line.strip() != '':
  735.         output.append(prefix + cur_line.rstrip())
  736.       cur_line = seg.lstrip()
  737.   if cur_line.strip() != '':
  738.     output.append(prefix + cur_line.strip())
  739.  
  740.  
  741. def WrapCode(line, line_concat, output):
  742.   indent = len(line) - len(line.lstrip())
  743.   prefix = indent*' '  # Prefix of the current line
  744.   max_len = 80 - indent - len(line_concat)  # Maximum length of the current line
  745.   new_prefix = prefix + 4*' '  # Prefix of a continuation line
  746.   new_max_len = max_len - 4  # Maximum length of a continuation line
  747.   # Prefers to wrap a line after a ',' or ';'.
  748.   segs = [seg for seg in re.split(r'([^,;]+[,;]?)', line.strip()) if seg != '']
  749.   cur_line = ''  # The current line without leading spaces.
  750.   for seg in segs:
  751.     # If the line is still too long, wrap at a space.
  752.     while cur_line == '' and len(seg.strip()) > max_len:
  753.       seg = seg.lstrip()
  754.       split_at = seg.rfind(' ', 0, max_len)
  755.       output.append(prefix + seg[:split_at].strip() + line_concat)
  756.       seg = seg[split_at + 1:]
  757.       prefix = new_prefix
  758.       max_len = new_max_len
  759.  
  760.     if len((cur_line + seg).rstrip()) < max_len:
  761.       cur_line = (cur_line + seg).lstrip()
  762.     else:
  763.       output.append(prefix + cur_line.rstrip() + line_concat)
  764.       prefix = new_prefix
  765.       max_len = new_max_len
  766.       cur_line = seg.lstrip()
  767.   if cur_line.strip() != '':
  768.     output.append(prefix + cur_line.strip())
  769.  
  770.  
  771. def WrapPreprocessorDirective(line, output):
  772.   WrapCode(line, ' \\', output)
  773.  
  774.  
  775. def WrapPlainCode(line, output):
  776.   WrapCode(line, '', output)
  777.  
  778.  
  779. def IsMultiLineIWYUPragma(line):
  780.   return re.search(r'/\* IWYU pragma: ', line)
  781.  
  782.  
  783. def IsHeaderGuardIncludeOrOneLineIWYUPragma(line):
  784.   return (re.match(r'^#(ifndef|define|endif\s*//)\s*[\w_]+\s*$', line) or
  785.           re.match(r'^#include\s', line) or
  786.           # Don't break IWYU pragmas, either; that causes iwyu.py problems.
  787.           re.search(r'// IWYU pragma: ', line))
  788.  
  789.  
  790. def WrapLongLine(line, output):
  791.   line = line.rstrip()
  792.   if len(line) <= 80:
  793.     output.append(line)
  794.   elif IsSingleLineComment(line):
  795.     if IsHeaderGuardIncludeOrOneLineIWYUPragma(line):
  796.       # The style guide made an exception to allow long header guard lines,
  797.       # includes and IWYU pragmas.
  798.       output.append(line)
  799.     else:
  800.       WrapComment(line, output)
  801.   elif IsInPreprocessorDirective(output, line):
  802.     if IsHeaderGuardIncludeOrOneLineIWYUPragma(line):
  803.       # The style guide made an exception to allow long header guard lines,
  804.       # includes and IWYU pragmas.
  805.       output.append(line)
  806.     else:
  807.       WrapPreprocessorDirective(line, output)
  808.   elif IsMultiLineIWYUPragma(line):
  809.     output.append(line)
  810.   else:
  811.     WrapPlainCode(line, output)
  812.  
  813.  
  814. def BeautifyCode(string):
  815.   lines = string.splitlines()
  816.   output = []
  817.   for line in lines:
  818.     WrapLongLine(line, output)
  819.   output2 = [line.rstrip() for line in output]
  820.   return '\n'.join(output2) + '\n'
  821.  
  822.  
  823. def ConvertFromPumpSource(src_text):
  824.   """Return the text generated from the given Pump source text."""
  825.   ast = ParseToAST(StripMetaComments(src_text))
  826.   output = Output()
  827.   RunCode(Env(), ast, output)
  828.   return BeautifyCode(output.string)
  829.  
  830.  
  831. def main(argv):
  832.   if len(argv) == 1:
  833.     print __doc__
  834.     sys.exit(1)
  835.  
  836.   file_path = argv[-1]
  837.   output_str = ConvertFromPumpSource(file(file_path, 'r').read())
  838.   if file_path.endswith('.pump'):
  839.     output_file_path = file_path[:-5]
  840.   else:
  841.     output_file_path = '-'
  842.   if output_file_path == '-':
  843.     print output_str,
  844.   else:
  845.     output_file = file(output_file_path, 'w')
  846.     output_file.write('// This file was GENERATED by command:\n')
  847.     output_file.write('//     %s %s\n' %
  848.                       (os.path.basename(__file__), os.path.basename(file_path)))
  849.     output_file.write('// DO NOT EDIT BY HAND!!!\n\n')
  850.     output_file.write(output_str)
  851.     output_file.close()
  852.  
  853.  
  854. if __name__ == '__main__':
  855.   main(sys.argv)
  856.