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	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	Convert (file_path)
def	RunAtomicCode (env, node, output)
def	RunCode (env, code_node, output)
def	IsComment (cur_line)
def	IsInPreprocessorDirevative (prev_lines, cur_line)
def	WrapComment (line, output)
def	WrapCode (line, line_concat, output)
def	WrapPreprocessorDirevative (line, output)
def	WrapPlainCode (line, output)
def	IsHeaderGuardOrInclude (line)
def	WrapLongLine (line, output)
def	BeautifyCode (string)
def	main (argv)

Variables
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

BeautifyCode()

def pump.BeautifyCode

(

string

)

Convert()

def pump.Convert

(

file_path

)

Eof()

def pump.Eof

(

)

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

FindFirst()

def pump.FindFirst	(		lines,
			token_table,
			cursor
	)

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

FindFirstInLine()

def pump.FindFirstInLine	(		line,
			token_table
	)

IsComment()

def pump.IsComment

(

cur_line

)

IsHeaderGuardOrInclude()

def pump.IsHeaderGuardOrInclude

(

line

)

IsInPreprocessorDirevative()

def pump.IsInPreprocessorDirevative	(		prev_lines,
			cur_line
	)

main()

def pump.main

(

argv

)

MakeToken()

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

Creates a new instance of Token.

ParseAtomicCodeNode()

def pump.ParseAtomicCodeNode

(

tokens

)

ParseCodeNode()

def pump.ParseCodeNode

(

tokens

)

ParseElseNode()

def pump.ParseElseNode

(

tokens

)

ParseExpNode()

def pump.ParseExpNode

(

token

)

ParseExpTokenInParens()

def pump.ParseExpTokenInParens	(		lines,
			pos
	)

ParseToken()

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

PeekToken()

def pump.PeekToken

(

a_list

)

PopFront()

def pump.PopFront

(

a_list

)

PopToken()

def pump.PopToken	(		a_list,
			token_type = None
	)

PushFront()

def pump.PushFront	(		a_list,
			elem
	)

RStripNewLineFromToken()

def pump.RStripNewLineFromToken

(

token

)

RunAtomicCode()

def pump.RunAtomicCode	(		env,
			node,
			output
	)

RunCode()

def pump.RunCode	(		env,
			code_node,
			output
	)

Skip()

def pump.Skip	(		lines,
			pos,
			regex
	)

SkipUntil()

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

StartsWith()

def pump.StartsWith	(		lines,
			pos,
			string
	)

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

SubString()

def pump.SubString	(		lines,
			start,
			end
	)

Returns a substring in lines.

Tokenize()

def pump.Tokenize

(

s

)

TokenizeLines()

def pump.TokenizeLines	(		lines,
			pos
	)

WrapCode()

def pump.WrapCode	(		line,
			line_concat,
			output
	)

WrapComment()

def pump.WrapComment	(		line,
			output
	)

WrapLongLine()

def pump.WrapLongLine	(		line,
			output
	)

WrapPlainCode()

def pump.WrapPlainCode	(		line,
			output
	)

WrapPreprocessorDirevative()

def pump.WrapPreprocessorDirevative	(		line,
			output
	)

Variable Documentation

DOT_DOT_REGEX

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

EQ_REGEX

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

ID_REGEX

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

OPTIONAL_WHITE_SPACES_REGEX

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

REST_OF_LINE_REGEX

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

TOKEN_TABLE

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'\$'), '$'),
    (re.compile(r'\[\[\n?'), '[['),
    (re.compile(r'\]\]\n?'), ']]'),
    ]

WHITE_SPACE_REGEX

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