Torque2D Reference

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes

- Namespace List
- Namespace Members

Classes | Functions | Variables
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
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 | 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 | ConvertFromPumpSource (src_text)
def | main (argv)

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

## Function Documentation

def pump.BeautifyCode | ( |  | string | ) |

def pump.ConvertFromPumpSource | ( |  | src_text | ) |

    Return the text generated from the given Pump source text.

def pump.Eof | ( |  | ) |

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

def pump.FindFirst | ( |  | lines,
|  |  | token_table,
|  |  | cursor
| ) |  |

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

def pump.FindFirstInLine | ( |  | line,
|  |  | token_table
| ) |  |

def pump.IsComment | ( |  | cur_line | ) |

def pump.IsHeaderGuardOrInclude | ( |  | line | ) |

def pump.IsInPreprocessorDirevative | ( |  | prev_lines,
|  |  | cur_line
| ) |  |

def pump.main | ( |  | argv | ) |

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

    Creates a new instance of Token.

def pump.ParseAtomicCodeNode | ( |  | tokens | ) |

def pump.ParseCodeNode | ( |  | tokens | ) |

def pump.ParseElseNode | ( |  | tokens | ) |

def pump.ParseExpNode | ( |  | token | ) |

def pump.ParseExpTokenInParens | ( |  | lines,
|  |  | pos
| ) |  |

def pump.ParseToAST | ( |  | pump_src_text | ) |

    Convert the given Pump source text into an AST.

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

def pump.PeekToken | ( |  | a_list | ) |

def pump.PopFront | ( |  | a_list | ) |

def pump.PopToken | ( |  | a_list,
|  |  | token_type = `None`
| ) |  |

def pump.PushFront | ( |  | a_list,
|  |  | elem
| ) |  |

def pump.RStripNewLineFromToken | ( |  | token | ) |

def pump.RunAtomicCode | ( |  | env,
|  |  | node,
|  |  | output
| ) |  |

def pump.RunCode | ( |  | env,
|  |  | code_node,
|  |  | output
| ) |  |

def pump.Skip | ( |  | lines,
|  |  | pos,
|  |  | regex
| ) |  |

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

def pump.StartsWith | ( |  | lines,
|  |  | pos,
|  |  | string
| ) |  |

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

def pump.StripMetaComments | ( |  | str | ) |

    Strip meta comments from each line in the given string.

def pump.SubString | ( |  | lines,
|  |  | start,
|  |  | end
| ) |  |

    Returns a substring in lines.

def pump.Tokenize | ( |  | s | ) |

    A generator that yields the tokens in the given string.

def pump.TokenizeLines | ( |  | lines,
|  |  | pos
| ) |  |

def pump.WrapCode | ( |  | line,
|  |  | line_concat,
|  |  | output
| ) |  |

def pump.WrapComment | ( |  | line,
|  |  | output
| ) |  |

def pump.WrapLongLine | ( |  | line,
|  |  | output
| ) |  |

def pump.WrapPlainCode | ( |  | line,
|  |  | output
| ) |  |

def pump.WrapPreprocessorDirevative | ( |  | line,
|  |  | output
| ) |  |

## Variable Documentation

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

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

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

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

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

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

list TOKEN_TABLE

Initial value:
1 = [
2 (re.compile(r'\$var\s+'), '$var'),
3 (re.compile(r'\$elif\s+'), '$elif'),
4 (re.compile(r'\$else\s+'), '$else'),
5 (re.compile(r'\$for\s+'), '$for'),
6 (re.compile(r'\$if\s+'), '$if'),
7 (re.compile(r'\$range\s+'), '$range'),
8 (re.compile(r'\$[_A-Za-z]\w*'), '$id'),
9 (re.compile(r'\$\(\$\)'), '$($)'),
10 (re.compile(r'\$'), '$'),
11 (re.compile(r'\[\[\n?'), '[['),
12 (re.compile(r'\]\]\n?'), ']]'),
13 ]

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