pump Namespace Reference

Classes
class	CodeNode
class	Cursor
class	ElseNode
class	Env
class	ExpNode
class	ForNode
class	IfNode
class	LiteralDollarNode
class	Output
class	RangeNode
class	RawCodeNode
class	Token
class	VarNode

Functions
def	Eof ()
def	StartsWith (lines, pos, string)
def	FindFirstInLine (line, token_table)
def	FindFirst (lines, token_table, cursor)
def	SubString (lines, start, end)
def	StripMetaComments (str)
def	MakeToken (lines, start, end, token_type)
def	ParseToken (lines, pos, regex, token_type)
def	Skip (lines, pos, regex)
def	SkipUntil (lines, pos, regex, token_type)
def	ParseExpTokenInParens (lines, pos)
def	RStripNewLineFromToken (token)
def	TokenizeLines (lines, pos)
def	Tokenize (s)
def	PopFront (a_list)
def	PushFront (a_list, elem)
def	PopToken (a_list, token_type=None)
def	PeekToken (a_list)
def	ParseExpNode (token)
def	ParseElseNode (tokens)
def	ParseAtomicCodeNode (tokens)
def	ParseCodeNode (tokens)
def	ParseToAST (pump_src_text)
def	RunAtomicCode (env, node, output)
def	RunCode (env, code_node, output)
def	IsSingleLineComment (cur_line)
def	IsInPreprocessorDirective (prev_lines, cur_line)
def	WrapComment (line, output)
def	WrapCode (line, line_concat, output)
def	WrapPreprocessorDirective (line, output)
def	WrapPlainCode (line, output)
def	IsMultiLineIWYUPragma (line)
def	IsHeaderGuardIncludeOrOneLineIWYUPragma (line)
def	WrapLongLine (line, output)
def	BeautifyCode (string)
def	ConvertFromPumpSource (src_text)
def	main (argv)

Variables
string	__author__ = 'wan@google.com (Zhanyong Wan)'
list	TOKEN_TABLE
	ID_REGEX = re.compile(r'[_A-Za-z]\w*')
	EQ_REGEX = re.compile(r'=')
	REST_OF_LINE_REGEX = re.compile(r'.*?(?=$|\$\$)')
	OPTIONAL_WHITE_SPACES_REGEX = re.compile(r'\s*')
	WHITE_SPACE_REGEX = re.compile(r'\s')
	DOT_DOT_REGEX = re.compile(r'\.\.')

Function Documentation

def pump.BeautifyCode

(

string

)

Definition at line 814 of file pump.py.

References join, and WrapLongLine().

Referenced by pump.Output.Append(), and ConvertFromPumpSource().

def BeautifyCode(string):
  lines = string.splitlines()
  output = []
  for line in lines:
    WrapLongLine(line, output)
  output2 = [line.rstrip() for line in output]
  return '\n'.join(output2) + '\n'

def pump.ConvertFromPumpSource

(

src_text

)

Return the text generated from the given Pump source text.

Definition at line 823 of file pump.py.

References BeautifyCode(), ParseToAST(), RunCode(), and StripMetaComments().

Referenced by pump.Output.Append(), and main().

def ConvertFromPumpSource(src_text):
  """Return the text generated from the given Pump source text."""
  ast = ParseToAST(StripMetaComments(src_text))
  output = Output()
  RunCode(Env(), ast, output)
  return BeautifyCode(output.string)

def pump.Eof

(

)

Returns the special cursor to denote the end-of-file.

Definition at line 132 of file pump.py.

Referenced by pump.Token.__init__(), pump.Cursor.__str__(), pump.Cursor.Clone(), pump.Token.Clone(), SubString(), and TokenizeLines().

def Eof():
  """Returns the special cursor to denote the end-of-file."""
  return Cursor(-1, -1)

def pump.FindFirst	(		lines,
			token_table,
			cursor
	)

Finds the first occurrence of any string in strings in lines.

Definition at line 186 of file pump.py.

References FindFirstInLine(), and MakeToken().

Referenced by pump.Token.Clone(), and TokenizeLines().

def FindFirst(lines, token_table, cursor):
  """Finds the first occurrence of any string in strings in lines."""

  start = cursor.Clone()
  cur_line_number = cursor.line
  for line in lines[start.line:]:
    if cur_line_number == start.line:
      line = line[start.column:]
    m = FindFirstInLine(line, token_table)
    if m:
      # We found a regex in line.
      (start_column, length, token_type) = m
      if cur_line_number == start.line:
        start_column += start.column
      found_start = Cursor(cur_line_number, start_column)
      found_end = found_start + length
      return MakeToken(lines, found_start, found_end, token_type)
    cur_line_number += 1
  # We failed to find str in lines
  return None

def pump.FindFirstInLine	(		line,
			token_table
	)

Definition at line 169 of file pump.py.

Referenced by pump.Token.Clone(), and FindFirst().

def FindFirstInLine(line, token_table):
  best_match_start = -1
  for (regex, token_type) in token_table:
    m = regex.search(line)
    if m:
      # We found regex in lines
      if best_match_start < 0 or m.start() < best_match_start:
        best_match_start = m.start()
        best_match_length = m.end() - m.start()
        best_match_token_type = token_type

  if best_match_start < 0:
    return None

  return (best_match_start, best_match_length, best_match_token_type)

def pump.IsHeaderGuardIncludeOrOneLineIWYUPragma

(

line

)

Definition at line 783 of file pump.py.

Referenced by pump.Output.Append(), and WrapLongLine().

def IsHeaderGuardIncludeOrOneLineIWYUPragma(line):
  return (re.match(r'^#(ifndef|define|endif\s*//)\s*[\w_]+\s*$', line) or
          re.match(r'^#include\s', line) or
          # Don't break IWYU pragmas, either; that causes iwyu.py problems.
          re.search(r'// IWYU pragma: ', line))

def pump.IsInPreprocessorDirective	(		prev_lines,
			cur_line
	)

Definition at line 711 of file pump.py.

Referenced by pump.Output.Append(), and WrapLongLine().

def IsInPreprocessorDirective(prev_lines, cur_line):
  if cur_line.lstrip().startswith('#'):
    return True
  return prev_lines and prev_lines[-1].endswith('\\')

def pump.IsMultiLineIWYUPragma

(

line

)

Definition at line 779 of file pump.py.

Referenced by pump.Output.Append(), and WrapLongLine().

def IsMultiLineIWYUPragma(line):
  return re.search(r'/\* IWYU pragma: ', line)

def pump.IsSingleLineComment

(

cur_line

)

Definition at line 707 of file pump.py.

Referenced by pump.Output.Append(), and WrapLongLine().

def IsSingleLineComment(cur_line):
  return '//' in cur_line

def pump.main

(

argv

)

Definition at line 831 of file pump.py.

References ConvertFromPumpSource().

Referenced by pump.Output.Append().

def main(argv):
  if len(argv) == 1:
    print __doc__
    sys.exit(1)

  file_path = argv[-1]
  output_str = ConvertFromPumpSource(file(file_path, 'r').read())
  if file_path.endswith('.pump'):
    output_file_path = file_path[:-5]
  else:
    output_file_path = '-'
  if output_file_path == '-':
    print output_str,
  else:
    output_file = file(output_file_path, 'w')
    output_file.write('// This file was GENERATED by command:\n')
    output_file.write('//     %s %s\n' %
                      (os.path.basename(__file__), os.path.basename(file_path)))
    output_file.write('// DO NOT EDIT BY HAND!!!\n\n')
    output_file.write(output_str)
    output_file.close()

def pump.MakeToken	(		lines,
			start,
			end,
			token_type
	)

Creates a new instance of Token.

Definition at line 237 of file pump.py.

References SubString().

Referenced by pump.Token.Clone(), FindFirst(), ParseExpTokenInParens(), ParseToken(), and TokenizeLines().

def MakeToken(lines, start, end, token_type):
  """Creates a new instance of Token."""

  return Token(start, end, SubString(lines, start, end), token_type)

def pump.ParseAtomicCodeNode

(

tokens

)

Definition at line 503 of file pump.py.

References ParseCodeNode(), ParseElseNode(), ParseExpNode(), PeekToken(), PopFront(), PopToken(), and PushFront().

Referenced by pump.ExpNode.__init__(), and ParseCodeNode().

def ParseAtomicCodeNode(tokens):
  def Pop(token_type=None):
    return PopToken(tokens, token_type)

  head = PopFront(tokens)
  t = head.token_type
  if t == 'code':
    return RawCodeNode(head)
  elif t == '$var':
    id_token = Pop('id')
    Pop('=')
    next = PeekToken(tokens)
    if next.token_type == 'exp':
      exp_token = Pop()
      return VarNode(id_token, ParseExpNode(exp_token))
    Pop('[[')
    code_node = ParseCodeNode(tokens)
    Pop(']]')
    return VarNode(id_token, code_node)
  elif t == '$for':
    id_token = Pop('id')
    next_token = PeekToken(tokens)
    if next_token.token_type == 'code':
      sep_token = next_token
      Pop('code')
    else:
      sep_token = None
    Pop('[[')
    code_node = ParseCodeNode(tokens)
    Pop(']]')
    return ForNode(id_token, sep_token, code_node)
  elif t == '$if':
    exp_token = Pop('code')
    Pop('[[')
    code_node = ParseCodeNode(tokens)
    Pop(']]')
    else_node = ParseElseNode(tokens)
    return IfNode(ParseExpNode(exp_token), code_node, else_node)
  elif t == '$range':
    id_token = Pop('id')
    exp1_token = Pop('exp')
    Pop('..')
    exp2_token = Pop('exp')
    return RangeNode(id_token, ParseExpNode(exp1_token),
                     ParseExpNode(exp2_token))
  elif t == '$id':
    return ParseExpNode(Token(head.start + 1, head.end, head.value[1:], 'id'))
  elif t == '$($)':
    return LiteralDollarNode(head)
  elif t == '$':
    exp_token = Pop('exp')
    return ParseExpNode(exp_token)
  elif t == '[[':
    code_node = ParseCodeNode(tokens)
    Pop(']]')
    return code_node
  else:
    PushFront(tokens, head)
    return None

def pump.ParseCodeNode

(

tokens

)

Definition at line 564 of file pump.py.

References ParseAtomicCodeNode().

Referenced by pump.ExpNode.__init__(), ParseAtomicCodeNode(), ParseElseNode(), and ParseToAST().

def ParseCodeNode(tokens):
  atomic_code_list = []
  while True:
    if not tokens:
      break
    atomic_code_node = ParseAtomicCodeNode(tokens)
    if atomic_code_node:
      atomic_code_list.append(atomic_code_node)
    else:
      break
  return CodeNode(atomic_code_list)

def pump.ParseElseNode

(

tokens

)

Definition at line 475 of file pump.py.

References ParseCodeNode(), ParseExpNode(), PeekToken(), and PopToken().

Referenced by pump.ExpNode.__init__(), and ParseAtomicCodeNode().

def ParseElseNode(tokens):
  def Pop(token_type=None):
    return PopToken(tokens, token_type)

  next = PeekToken(tokens)
  if not next:
    return None
  if next.token_type == '$else':
    Pop('$else')
    Pop('[[')
    code_node = ParseCodeNode(tokens)
    Pop(']]')
    return code_node
  elif next.token_type == '$elif':
    Pop('$elif')
    exp = Pop('code')
    Pop('[[')
    code_node = ParseCodeNode(tokens)
    Pop(']]')
    inner_else_node = ParseElseNode(tokens)
    return CodeNode([IfNode(ParseExpNode(exp), code_node, inner_else_node)])
  elif not next.value.strip():
    Pop('code')
    return ParseElseNode(tokens)
  else:
    return None

def pump.ParseExpNode

(

token

)

Definition at line 470 of file pump.py.

Referenced by pump.ExpNode.__init__(), ParseAtomicCodeNode(), and ParseElseNode().

def ParseExpNode(token):
  python_exp = re.sub(r'([_A-Za-z]\w*)', r'self.GetValue("\1")', token.value)
  return ExpNode(token, python_exp)

def pump.ParseExpTokenInParens	(		lines,
			pos
	)

Definition at line 281 of file pump.py.

References MakeToken(), Skip(), SkipUntil(), and SubString().

Referenced by pump.Token.Clone(), and TokenizeLines().

def ParseExpTokenInParens(lines, pos):
  def ParseInParens(pos):
    pos = Skip(lines, pos, OPTIONAL_WHITE_SPACES_REGEX)
    pos = Skip(lines, pos, r'\(')
    pos = Parse(pos)
    pos = Skip(lines, pos, r'\)')
    return pos

  def Parse(pos):
    pos = SkipUntil(lines, pos, r'\(|\)', ')')
    if SubString(lines, pos, pos + 1) == '(':
      pos = Parse(pos + 1)
      pos = Skip(lines, pos, r'\)')
      return Parse(pos)
    else:
      return pos

  start = pos.Clone()
  pos = ParseInParens(pos)
  return MakeToken(lines, start, pos, 'exp')

def pump.ParseToAST

(

pump_src_text

)

Convert the given Pump source text into an AST.

Definition at line 577 of file pump.py.

References bm.list, ParseCodeNode(), and Tokenize().

Referenced by pump.ExpNode.__init__(), pump.Output.Append(), and ConvertFromPumpSource().

def ParseToAST(pump_src_text):
  """Convert the given Pump source text into an AST."""
  tokens = list(Tokenize(pump_src_text))
  code_node = ParseCodeNode(tokens)
  return code_node

def pump.ParseToken	(		lines,
			pos,
			regex,
			token_type
	)

Definition at line 243 of file pump.py.

References MakeToken().

Referenced by pump.Token.Clone(), and TokenizeLines().

def ParseToken(lines, pos, regex, token_type):
  line = lines[pos.line][pos.column:]
  m = regex.search(line)
  if m and not m.start():
    return MakeToken(lines, pos, pos + m.end(), token_type)
  else:
    print 'ERROR: %s expected at %s.' % (token_type, pos)
    sys.exit(1)

def pump.PeekToken

(

a_list

)

Definition at line 463 of file pump.py.

Referenced by pump.ExpNode.__init__(), ParseAtomicCodeNode(), and ParseElseNode().

def PeekToken(a_list):
  if not a_list:
    return None

  return a_list[0]

def pump.PopFront

(

a_list

)

Definition at line 443 of file pump.py.

Referenced by pump.ExpNode.__init__(), ParseAtomicCodeNode(), and PopToken().

def PopFront(a_list):
  head = a_list[0]
  a_list[:1] = []
  return head

def pump.PopToken	(		a_list,
			token_type = None
	)

Definition at line 453 of file pump.py.

References PopFront().

Referenced by pump.ExpNode.__init__(), ParseAtomicCodeNode(), and ParseElseNode().

def PopToken(a_list, token_type=None):
  token = PopFront(a_list)
  if token_type is not None and token.token_type != token_type:
    print 'ERROR: %s expected at %s' % (token_type, token.start)
    print 'ERROR: %s found instead' % (token,)
    sys.exit(1)

  return token

def pump.PushFront	(		a_list,
			elem
	)

Definition at line 449 of file pump.py.

Referenced by pump.ExpNode.__init__(), and ParseAtomicCodeNode().

def PushFront(a_list, elem):
  a_list[:0] = [elem]

def pump.RStripNewLineFromToken

(

token

)

Definition at line 303 of file pump.py.

Referenced by pump.Token.Clone(), and TokenizeLines().

def RStripNewLineFromToken(token):
  if token.value.endswith('\n'):
    return Token(token.start, token.end, token.value[:-1], token.token_type)
  else:
    return token

def pump.RunAtomicCode	(		env,
			node,
			output
	)

Definition at line 656 of file pump.py.

References folly::gen.range(), and RunCode().

Referenced by pump.Output.Append(), and RunCode().

def RunAtomicCode(env, node, output):
  if isinstance(node, VarNode):
    identifier = node.identifier.value.strip()
    result = Output()
    RunAtomicCode(env.Clone(), node.atomic_code, result)
    value = result.string
    env.PushVariable(identifier, value)
  elif isinstance(node, RangeNode):
    identifier = node.identifier.value.strip()
    lower = int(env.EvalExp(node.exp1))
    upper = int(env.EvalExp(node.exp2))
    env.PushRange(identifier, lower, upper)
  elif isinstance(node, ForNode):
    identifier = node.identifier.value.strip()
    if node.sep is None:
      sep = ''
    else:
      sep = node.sep.value
    (lower, upper) = env.GetRange(identifier)
    for i in range(lower, upper + 1):
      new_env = env.Clone()
      new_env.PushVariable(identifier, i)
      RunCode(new_env, node.code, output)
      if i != upper:
        output.Append(sep)
  elif isinstance(node, RawCodeNode):
    output.Append(node.raw_code.value)
  elif isinstance(node, IfNode):
    cond = env.EvalExp(node.exp)
    if cond:
      RunCode(env.Clone(), node.then_branch, output)
    elif node.else_branch is not None:
      RunCode(env.Clone(), node.else_branch, output)
  elif isinstance(node, ExpNode):
    value = env.EvalExp(node)
    output.Append('%s' % (value,))
  elif isinstance(node, LiteralDollarNode):
    output.Append('$')
  elif isinstance(node, CodeNode):
    RunCode(env.Clone(), node, output)
  else:
    print 'BAD'
    print node
    sys.exit(1)

def pump.RunCode	(		env,
			code_node,
			output
	)

Definition at line 702 of file pump.py.

References RunAtomicCode().

Referenced by pump.Output.Append(), ConvertFromPumpSource(), and RunAtomicCode().

def RunCode(env, code_node, output):
  for atomic_code in code_node.atomic_code:
    RunAtomicCode(env, atomic_code, output)

def pump.Skip	(		lines,
			pos,
			regex
	)

Definition at line 261 of file pump.py.

Referenced by pump.Token.Clone(), ParseExpTokenInParens(), and TokenizeLines().

def Skip(lines, pos, regex):
  line = lines[pos.line][pos.column:]
  m = re.search(regex, line)
  if m and not m.start():
    return pos + m.end()
  else:
    return pos

def pump.SkipUntil	(		lines,
			pos,
			regex,
			token_type
	)

Definition at line 270 of file pump.py.

Referenced by pump.Token.Clone(), ParseExpTokenInParens(), and TokenizeLines().

def SkipUntil(lines, pos, regex, token_type):
  line = lines[pos.line][pos.column:]
  m = re.search(regex, line)
  if m:
    return pos + m.start()
  else:
    print ('ERROR: %s expected on line %s after column %s.' %
           (token_type, pos.line + 1, pos.column))
    sys.exit(1)

def pump.StartsWith	(		lines,
			pos,
			string
	)

Returns True iff the given position in lines starts with 'string'.

Definition at line 163 of file pump.py.

Referenced by pump.Token.Clone().

def StartsWith(lines, pos, string):
  """Returns True iff the given position in lines starts with 'string'."""

  return lines[pos.line][pos.column:].startswith(string)

def pump.StripMetaComments

(

str

)

Strip meta comments from each line in the given string.

Definition at line 226 of file pump.py.

Referenced by pump.Output.Append(), pump.Token.Clone(), and ConvertFromPumpSource().

def StripMetaComments(str):
  """Strip meta comments from each line in the given string."""

  # First, completely remove lines containing nothing but a meta
  # comment, including the trailing \n.
  str = re.sub(r'^\s*\$\$.*\n', '', str)

  # Then, remove meta comments from contentful lines.
  return re.sub(r'\s*\$\$.*', '', str)

def pump.SubString	(		lines,
			start,
			end
	)

Returns a substring in lines.

Definition at line 208 of file pump.py.

References Eof(), and join.

Referenced by pump.Token.Clone(), MakeToken(), ParseExpTokenInParens(), and TokenizeLines().

def SubString(lines, start, end):
  """Returns a substring in lines."""

  if end == Eof():
    end = Cursor(len(lines) - 1, len(lines[-1]))

  if start >= end:
    return ''

  if start.line == end.line:
    return lines[start.line][start.column:end.column]

  result_lines = ([lines[start.line][start.column:]] +
                  lines[start.line + 1:end.line] +
                  [lines[end.line][:end.column]])
  return ''.join(result_lines)

def pump.Tokenize

(

s

)

A generator that yields the tokens in the given string.

Definition at line 382 of file pump.py.

References TokenizeLines().

Referenced by pump.ExpNode.__init__(), pump.Token.Clone(), and ParseToAST().

def Tokenize(s):
  """A generator that yields the tokens in the given string."""
  if s != '':
    lines = s.splitlines(True)
    for token in TokenizeLines(lines, Cursor(0, 0)):
      yield token

def pump.TokenizeLines	(		lines,
			pos
	)

Definition at line 310 of file pump.py.

References Eof(), FindFirst(), MakeToken(), ParseExpTokenInParens(), ParseToken(), RStripNewLineFromToken(), Skip(), SkipUntil(), and SubString().

Referenced by pump.Token.Clone(), and Tokenize().

def TokenizeLines(lines, pos):
  while True:
    found = FindFirst(lines, TOKEN_TABLE, pos)
    if not found:
      yield MakeToken(lines, pos, Eof(), 'code')
      return

    if found.start == pos:
      prev_token = None
      prev_token_rstripped = None
    else:
      prev_token = MakeToken(lines, pos, found.start, 'code')
      prev_token_rstripped = RStripNewLineFromToken(prev_token)

    if found.token_type == '$var':
      if prev_token_rstripped:
        yield prev_token_rstripped
      yield found
      id_token = ParseToken(lines, found.end, ID_REGEX, 'id')
      yield id_token
      pos = Skip(lines, id_token.end, OPTIONAL_WHITE_SPACES_REGEX)

      eq_token = ParseToken(lines, pos, EQ_REGEX, '=')
      yield eq_token
      pos = Skip(lines, eq_token.end, r'\s*')

      if SubString(lines, pos, pos + 2) != '[[':
        exp_token = ParseToken(lines, pos, REST_OF_LINE_REGEX, 'exp')
        yield exp_token
        pos = Cursor(exp_token.end.line + 1, 0)
    elif found.token_type == '$for':
      if prev_token_rstripped:
        yield prev_token_rstripped
      yield found
      id_token = ParseToken(lines, found.end, ID_REGEX, 'id')
      yield id_token
      pos = Skip(lines, id_token.end, WHITE_SPACE_REGEX)
    elif found.token_type == '$range':
      if prev_token_rstripped:
        yield prev_token_rstripped
      yield found
      id_token = ParseToken(lines, found.end, ID_REGEX, 'id')
      yield id_token
      pos = Skip(lines, id_token.end, OPTIONAL_WHITE_SPACES_REGEX)

      dots_pos = SkipUntil(lines, pos, DOT_DOT_REGEX, '..')
      yield MakeToken(lines, pos, dots_pos, 'exp')
      yield MakeToken(lines, dots_pos, dots_pos + 2, '..')
      pos = dots_pos + 2
      new_pos = Cursor(pos.line + 1, 0)
      yield MakeToken(lines, pos, new_pos, 'exp')
      pos = new_pos
    elif found.token_type == '$':
      if prev_token:
        yield prev_token
      yield found
      exp_token = ParseExpTokenInParens(lines, found.end)
      yield exp_token
      pos = exp_token.end
    elif (found.token_type == ']]' or found.token_type == '$if' or
          found.token_type == '$elif' or found.token_type == '$else'):
      if prev_token_rstripped:
        yield prev_token_rstripped
      yield found
      pos = found.end
    else:
      if prev_token:
        yield prev_token
      yield found
      pos = found.end

def pump.WrapCode	(		line,
			line_concat,
			output
	)

Definition at line 741 of file pump.py.

References folly::detail::distributed_mutex.strip().

Referenced by pump.Output.Append(), WrapPlainCode(), and WrapPreprocessorDirective().

def WrapCode(line, line_concat, output):
  indent = len(line) - len(line.lstrip())
  prefix = indent*' '  # Prefix of the current line
  max_len = 80 - indent - len(line_concat)  # Maximum length of the current line
  new_prefix = prefix + 4*' '  # Prefix of a continuation line
  new_max_len = max_len - 4  # Maximum length of a continuation line
  # Prefers to wrap a line after a ',' or ';'.
  segs = [seg for seg in re.split(r'([^,;]+[,;]?)', line.strip()) if seg != '']
  cur_line = ''  # The current line without leading spaces.
  for seg in segs:
    # If the line is still too long, wrap at a space.
    while cur_line == '' and len(seg.strip()) > max_len:
      seg = seg.lstrip()
      split_at = seg.rfind(' ', 0, max_len)
      output.append(prefix + seg[:split_at].strip() + line_concat)
      seg = seg[split_at + 1:]
      prefix = new_prefix
      max_len = new_max_len

    if len((cur_line + seg).rstrip()) < max_len:
      cur_line = (cur_line + seg).lstrip()
    else:
      output.append(prefix + cur_line.rstrip() + line_concat)
      prefix = new_prefix
      max_len = new_max_len
      cur_line = seg.lstrip()
  if cur_line.strip() != '':
    output.append(prefix + cur_line.strip())

def pump.WrapComment	(		line,
			output
	)

Definition at line 717 of file pump.py.

References folly::detail::distributed_mutex.strip().

Referenced by pump.Output.Append(), and WrapLongLine().

def WrapComment(line, output):
  loc = line.find('//')
  before_comment = line[:loc].rstrip()
  if before_comment == '':
    indent = loc
  else:
    output.append(before_comment)
    indent = len(before_comment) - len(before_comment.lstrip())
  prefix = indent*' ' + '// '
  max_len = 80 - len(prefix)
  comment = line[loc + 2:].strip()
  segs = [seg for seg in re.split(r'(\w+\W*)', comment) if seg != '']
  cur_line = ''
  for seg in segs:
    if len((cur_line + seg).rstrip()) < max_len:
      cur_line += seg
    else:
      if cur_line.strip() != '':
        output.append(prefix + cur_line.rstrip())
      cur_line = seg.lstrip()
  if cur_line.strip() != '':
    output.append(prefix + cur_line.strip())

def pump.WrapLongLine	(		line,
			output
	)

Definition at line 790 of file pump.py.

References IsHeaderGuardIncludeOrOneLineIWYUPragma(), IsInPreprocessorDirective(), IsMultiLineIWYUPragma(), IsSingleLineComment(), WrapComment(), WrapPlainCode(), and WrapPreprocessorDirective().

Referenced by pump.Output.Append(), and BeautifyCode().

def WrapLongLine(line, output):
  line = line.rstrip()
  if len(line) <= 80:
    output.append(line)
  elif IsSingleLineComment(line):
    if IsHeaderGuardIncludeOrOneLineIWYUPragma(line):
      # The style guide made an exception to allow long header guard lines,
      # includes and IWYU pragmas.
      output.append(line)
    else:
      WrapComment(line, output)
  elif IsInPreprocessorDirective(output, line):
    if IsHeaderGuardIncludeOrOneLineIWYUPragma(line):
      # The style guide made an exception to allow long header guard lines,
      # includes and IWYU pragmas.
      output.append(line)
    else:
      WrapPreprocessorDirective(line, output)
  elif IsMultiLineIWYUPragma(line):
    output.append(line)
  else:
    WrapPlainCode(line, output)

def pump.WrapPlainCode	(		line,
			output
	)

Definition at line 775 of file pump.py.

References WrapCode().

Referenced by pump.Output.Append(), and WrapLongLine().

def WrapPlainCode(line, output):
  WrapCode(line, '', output)

def pump.WrapPreprocessorDirective	(		line,
			output
	)

Definition at line 771 of file pump.py.

References WrapCode().

Referenced by pump.Output.Append(), and WrapLongLine().

def WrapPreprocessorDirective(line, output):
  WrapCode(line, ' \\', output)

Variable Documentation

string pump.__author__ = 'wan@google.com (Zhanyong Wan)'

private

Definition at line 65 of file pump.py.

pump.DOT_DOT_REGEX = re.compile(r'\.\.')

Definition at line 258 of file pump.py.

pump.EQ_REGEX = re.compile(r'=')

Definition at line 254 of file pump.py.

pump.ID_REGEX = re.compile(r'[_A-Za-z]\w*')

Definition at line 253 of file pump.py.

pump.OPTIONAL_WHITE_SPACES_REGEX = re.compile(r'\s*')

Definition at line 256 of file pump.py.

pump.REST_OF_LINE_REGEX = re.compile(r'.*?(?=$|\$\$)')

Definition at line 255 of file pump.py.

list pump.TOKEN_TABLE

Initial value:

= [
    (re.compile(r'\$var\s+'), '$var'),
    (re.compile(r'\$elif\s+'), '$elif'),
    (re.compile(r'\$else\s+'), '$else'),
    (re.compile(r'\$for\s+'), '$for'),
    (re.compile(r'\$if\s+'), '$if'),
    (re.compile(r'\$range\s+'), '$range'),
    (re.compile(r'\$[_A-Za-z]\w*'), '$id'),
    (re.compile(r'\$\(\$\)'), '$($)'),
    (re.compile(r'\$'), '$'),
    (re.compile(r'\[\[\n?'), '[['),
    (re.compile(r'\]\]\n?'), ']]'),
    ]

Definition at line 72 of file pump.py.

pump.WHITE_SPACE_REGEX = re.compile(r'\s')

Definition at line 257 of file pump.py.