SYMBOL INDEX (929 symbols across 81 files)

FILE: c/chunk.c
  function initChunk (line 12) | void initChunk(Chunk* chunk) {
  function freeChunk (line 24) | void freeChunk(Chunk* chunk) {
  function writeChunk (line 40) | void writeChunk(Chunk* chunk, uint8_t byte, int line) {
  function addConstant (line 61) | int addConstant(Chunk* chunk, Value value) {

FILE: c/chunk.h
  type OpCode (line 11) | typedef enum {
  type Chunk (line 107) | typedef struct {

FILE: c/compiler.c
  type Parser (line 24) | typedef struct {
  type Precedence (line 36) | typedef enum {
  type ParseRule (line 61) | typedef struct {
  type Local (line 69) | typedef struct {
  type Upvalue (line 78) | typedef struct {
  type FunctionType (line 84) | typedef enum {
  type Compiler (line 101) | typedef struct Compiler {
  type ClassCompiler (line 119) | typedef struct ClassCompiler {
  function Chunk (line 145) | static Chunk* currentChunk() {
  function errorAt (line 152) | static void errorAt(Token* token, const char* message) {
  function error (line 174) | static void error(const char* message) {
  function errorAtCurrent (line 179) | static void errorAtCurrent(const char* message) {
  function advance (line 185) | static void advance() {
  function consume (line 197) | static void consume(TokenType type, const char* message) {
  function check (line 207) | static bool check(TokenType type) {
  function match (line 212) | static bool match(TokenType type) {
  function emitByte (line 219) | static void emitByte(uint8_t byte) {
  function emitBytes (line 224) | static void emitBytes(uint8_t byte1, uint8_t byte2) {
  function emitLoop (line 230) | static void emitLoop(int loopStart) {
  function emitJump (line 241) | static int emitJump(uint8_t instruction) {
  function emitReturn (line 249) | static void emitReturn() {
  function makeConstant (line 265) | static uint8_t makeConstant(Value value) {
  function emitConstant (line 276) | static void emitConstant(Value value) {
  function patchJump (line 281) | static void patchJump(int offset) {
  function initCompiler (line 298) | static void initCompiler(Compiler* compiler, FunctionType type) {
  function ObjFunction (line 345) | static ObjFunction* endCompiler() {
  function beginScope (line 375) | static void beginScope() {
  function endScope (line 380) | static void endScope() {
  function identifierConstant (line 414) | static uint8_t identifierConstant(Token* name) {
  function identifiersEqual (line 420) | static bool identifiersEqual(Token* a, Token* b) {
  function resolveLocal (line 426) | static int resolveLocal(Compiler* compiler, Token* name) {
  function addUpvalue (line 443) | static int addUpvalue(Compiler* compiler, uint8_t index,
  function resolveUpvalue (line 469) | static int resolveUpvalue(Compiler* compiler, Token* name) {
  function addLocal (line 491) | static void addLocal(Token name) {
  function declareVariable (line 513) | static void declareVariable() {
  function parseVariable (line 534) | static uint8_t parseVariable(const char* errorMessage) {
  function markInitialized (line 546) | static void markInitialized() {
  function defineVariable (line 555) | static void defineVariable(uint8_t global) {
  function argumentList (line 569) | static uint8_t argumentList() {
  function and_ (line 587) | static void and_(bool canAssign) {
  function binary (line 601) | static void binary(bool canAssign) {
  function call (line 625) | static void call(bool canAssign) {
  function dot (line 631) | static void dot(bool canAssign) {
  function literal (line 654) | static void literal(bool canAssign) {
  function grouping (line 669) | static void grouping(bool canAssign) {
  function number (line 680) | static void number(bool canAssign) {
  function or_ (line 692) | static void or_(bool canAssign) {
  function string (line 708) | static void string(bool canAssign) {
  function namedVariable (line 718) | static void namedVariable(Token name, bool canAssign) {
  function variable (line 776) | static void variable(bool canAssign) {
  function Token (line 781) | static Token syntheticToken(const char* text) {
  function super_ (line 789) | static void super_(bool canAssign) {
  function this_ (line 823) | static void this_(bool canAssign) {
  function unary (line 839) | static void unary(bool canAssign) {
  function parsePrecedence (line 980) | static void parsePrecedence(Precedence precedence) {
  function ParseRule (line 1022) | static ParseRule* getRule(TokenType type) {
  function expression (line 1027) | static void expression() {
  function block (line 1037) | static void block() {
  function function (line 1046) | static void function(FunctionType type) {
  function method (line 1085) | static void method() {
  function classDeclaration (line 1111) | static void classDeclaration() {
  function funDeclaration (line 1182) | static void funDeclaration() {
  function varDeclaration (line 1190) | static void varDeclaration() {
  function expressionStatement (line 1205) | static void expressionStatement() {
  function forStatement (line 1212) | static void forStatement() {
  function ifStatement (line 1279) | static void ifStatement() {
  function printStatement (line 1308) | static void printStatement() {
  function returnStatement (line 1315) | static void returnStatement() {
  function whileStatement (line 1338) | static void whileStatement() {
  function synchronize (line 1358) | static void synchronize() {
  function declaration (line 1383) | static void declaration() {
  function statement (line 1415) | static void statement() {
  function ObjFunction (line 1455) | ObjFunction* compile(const char* source) {
  function markCompilerRoots (line 1517) | void markCompilerRoots() {

FILE: c/debug.c
  function disassembleChunk (line 12) | void disassembleChunk(Chunk* chunk, const char* name) {
  function constantInstruction (line 20) | static int constantInstruction(const char* name, Chunk* chunk,
  function invokeInstruction (line 32) | static int invokeInstruction(const char* name, Chunk* chunk,
  function simpleInstruction (line 43) | static int simpleInstruction(const char* name, int offset) {
  function byteInstruction (line 49) | static int byteInstruction(const char* name, Chunk* chunk,
  function jumpInstruction (line 57) | static int jumpInstruction(const char* name, int sign,
  function disassembleInstruction (line 67) | int disassembleInstruction(Chunk* chunk, int offset) {

FILE: c/main.c
  function repl (line 20) | static void repl() {
  function runFile (line 71) | static void runFile(const char* path) {
  function main (line 81) | int main(int argc, const char* argv[]) {

FILE: c/memory.c
  function markObject (line 53) | void markObject(Obj* object) {
  function markValue (line 85) | void markValue(Value value) {
  function markArray (line 90) | static void markArray(ValueArray* array) {
  function blackenObject (line 97) | static void blackenObject(Obj* object) {
  function freeObject (line 163) | static void freeObject(Obj* object) {
  function markRoots (line 233) | static void markRoots() {
  function traceReferences (line 264) | static void traceReferences() {
  function sweep (line 272) | static void sweep() {
  function collectGarbage (line 297) | void collectGarbage() {
  function freeObjects (line 337) | void freeObjects() {

FILE: c/object.c
  function Obj (line 19) | static Obj* allocateObject(size_t size, ObjType type) {
  function ObjBoundMethod (line 41) | ObjBoundMethod* newBoundMethod(Value receiver,
  function ObjClass (line 51) | ObjClass* newClass(ObjString* name) {
  function ObjClosure (line 61) | ObjClosure* newClosure(ObjFunction* function) {
  function ObjFunction (line 80) | ObjFunction* newFunction() {
  function ObjInstance (line 92) | ObjInstance* newInstance(ObjClass* klass) {
  function ObjNative (line 100) | ObjNative* newNative(NativeFn function) {
  function ObjString (line 112) | static ObjString* allocateString(char* chars, int length,
  function hashString (line 136) | static uint32_t hashString(const char* key, int length) {
  function ObjString (line 146) | ObjString* takeString(char* chars, int length) {
  function ObjString (line 165) | ObjString* copyString(const char* chars, int length) {
  function ObjUpvalue (line 186) | ObjUpvalue* newUpvalue(Value* slot) {
  function printFunction (line 199) | static void printFunction(ObjFunction* function) {
  function printObject (line 210) | void printObject(Value value) {

FILE: c/object.h
  type ObjType (line 65) | typedef enum {
  type Obj (line 91) | struct Obj {
  type ObjFunction (line 102) | typedef struct {
  type Value (line 114) | typedef Value (*NativeFn)(int argCount, Value* args);
  type ObjNative (line 116) | typedef struct {
  type ObjString (line 123) | struct ObjString {
  type ObjUpvalue (line 133) | typedef struct ObjUpvalue {
  type ObjClosure (line 145) | typedef struct {
  type ObjClass (line 156) | typedef struct {
  type ObjInstance (line 166) | typedef struct {
  type ObjBoundMethod (line 174) | typedef struct {
  function isObjType (line 214) | static inline bool isObjType(Value value, ObjType type) {

FILE: c/scanner.c
  type Scanner (line 8) | typedef struct {
  function initScanner (line 16) | void initScanner(const char* source) {
  function isAlpha (line 23) | static bool isAlpha(char c) {
  function isDigit (line 30) | static bool isDigit(char c) {
  function isAtEnd (line 35) | static bool isAtEnd() {
  function advance (line 40) | static char advance() {
  function peek (line 46) | static char peek() {
  function peekNext (line 51) | static char peekNext() {
  function match (line 57) | static bool match(char expected) {
  function Token (line 65) | static Token makeToken(TokenType type) {
  function Token (line 75) | static Token errorToken(const char* message) {
  function skipWhitespace (line 85) | static void skipWhitespace() {
  function TokenType (line 117) | static TokenType checkKeyword(int start, int length,
  function TokenType (line 128) | static TokenType identifierType() {
  function Token (line 170) | static Token identifier() {
  function Token (line 176) | static Token number() {
  function Token (line 191) | static Token string() {
  function Token (line 205) | Token scanToken() {

FILE: c/scanner.h
  type TokenType (line 6) | typedef enum {
  type Token (line 30) | typedef struct {

FILE: c/table.c
  function initTable (line 14) | void initTable(Table* table) {
  function freeTable (line 20) | void freeTable(Table* table) {
  function Entry (line 30) | static Entry* findEntry(Entry* entries, int capacity,
  function tableGet (line 74) | bool tableGet(Table* table, ObjString* key, Value* value) {
  function adjustCapacity (line 85) | static void adjustCapacity(Table* table, int capacity) {
  function tableSet (line 117) | bool tableSet(Table* table, ObjString* key, Value value) {
  function tableDelete (line 140) | bool tableDelete(Table* table, ObjString* key) {
  function tableAddAll (line 154) | void tableAddAll(Table* from, Table* to) {
  function ObjString (line 164) | ObjString* tableFindString(Table* table, const char* chars,
  function tableRemoveWhite (line 196) | void tableRemoveWhite(Table* table) {
  function markTable (line 206) | void markTable(Table* table) {

FILE: c/table.h
  type Entry (line 9) | typedef struct {
  type Table (line 15) | typedef struct {

FILE: c/value.c
  function initValueArray (line 13) | void initValueArray(ValueArray* array) {
  function writeValueArray (line 19) | void writeValueArray(ValueArray* array, Value value) {
  function freeValueArray (line 32) | void freeValueArray(ValueArray* array) {
  function printValue (line 38) | void printValue(Value value) {
  function valuesEqual (line 76) | bool valuesEqual(Value a, Value b) {

FILE: c/value.h
  type Obj (line 12) | typedef struct Obj Obj;
  type ObjString (line 14) | typedef struct ObjString ObjString;
  type Value (line 34) | typedef uint64_t Value;
  function valueToNum (line 80) | static inline double valueToNum(Value value) {
  function Value (line 88) | static inline Value numToValue(double num) {
  type ValueType (line 99) | typedef enum {
  type Value (line 113) | typedef struct {
  type ValueArray (line 156) | typedef struct {

FILE: c/vm.c
  function Value (line 30) | static Value clockNative(int argCount, Value* args) {
  function resetStack (line 35) | static void resetStack() {
  function runtimeError (line 46) | static void runtimeError(const char* format, ...) {
  function defineNative (line 89) | static void defineNative(const char* name, NativeFn function) {
  function initVM (line 98) | void initVM() {
  function freeVM (line 135) | void freeVM() {
  function push (line 150) | void push(Value value) {
  function Value (line 156) | Value pop() {
  function Value (line 162) | static Value peek(int distance) {
  function call (line 171) | static bool call(ObjClosure* closure, int argCount) {
  function callValue (line 209) | static bool callValue(Value callee, int argCount) {
  function invokeFromClass (line 267) | static bool invokeFromClass(ObjClass* klass, ObjString* name,
  function invoke (line 278) | static bool invoke(ObjString* name, int argCount) {
  function bindMethod (line 302) | static bool bindMethod(ObjClass* klass, ObjString* name) {
  function ObjUpvalue (line 317) | static ObjUpvalue* captureUpvalue(Value* local) {
  function closeUpvalues (line 346) | static void closeUpvalues(Value* last) {
  function defineMethod (line 357) | static void defineMethod(ObjString* name) {
  function isFalsey (line 365) | static bool isFalsey(Value value) {
  function concatenate (line 370) | static void concatenate() {
  function InterpretResult (line 395) | static InterpretResult run() {
  function hack (line 866) | void hack(bool b) {
  function InterpretResult (line 881) | InterpretResult interpret(const char* source) {

FILE: c/vm.h
  type CallFrame (line 29) | typedef struct {
  type VM (line 41) | typedef struct {
  type InterpretResult (line 85) | typedef enum {

FILE: java/com/craftinginterpreters/lox/AstPrinter.java
  class AstPrinter (line 12) | class AstPrinter implements Expr.Visitor<String>, Stmt.Visitor<String> {
    method print (line 14) | String print(Expr expr) {
    method print (line 19) | String print(Stmt stmt) {
    method visitBlockStmt (line 25) | @Override
    method visitClassStmt (line 40) | @Override
    method visitExpressionStmt (line 61) | @Override
    method visitFunctionStmt (line 68) | @Override
    method visitIfStmt (line 90) | @Override
    method visitPrintStmt (line 102) | @Override
    method visitReturnStmt (line 109) | @Override
    method visitVarStmt (line 117) | @Override
    method visitWhileStmt (line 128) | @Override
    method visitAssignExpr (line 135) | @Override
    method visitBinaryExpr (line 141) | @Override
    method visitCallExpr (line 148) | @Override
    method visitGetExpr (line 155) | @Override
    method visitGroupingExpr (line 161) | @Override
    method visitLiteralExpr (line 166) | @Override
    method visitLogicalExpr (line 173) | @Override
    method visitSetExpr (line 180) | @Override
    method visitSuperExpr (line 188) | @Override
    method visitThisExpr (line 195) | @Override
    method visitUnaryExpr (line 201) | @Override
    method visitVariableExpr (line 207) | @Override
    method parenthesize (line 214) | private String parenthesize(String name, Expr... exprs) {
    method parenthesize2 (line 231) | private String parenthesize2(String name, Object... parts) {
    method transform (line 241) | private void transform(StringBuilder builder, Object... parts) {

FILE: java/com/craftinginterpreters/lox/Environment.java
  class Environment (line 7) | class Environment {
    method Environment (line 13) | Environment() {
    method Environment (line 17) | Environment(Environment enclosing) {
    method get (line 23) | Object get(Token name) {
    method assign (line 38) | void assign(Token name, Object value) {
    method define (line 56) | void define(String name, Object value) {
    method ancestor (line 61) | Environment ancestor(int distance) {
    method getAt (line 71) | Object getAt(int distance, String name) {
    method assignAt (line 76) | void assignAt(int distance, Token name, Object value) {
    method toString (line 81) | @Override

FILE: java/com/craftinginterpreters/lox/Expr.java
  class Expr (line 6) | abstract class Expr {
    type Visitor (line 7) | interface Visitor<R> {
      method visitAssignExpr (line 8) | R visitAssignExpr(Assign expr);
      method visitBinaryExpr (line 9) | R visitBinaryExpr(Binary expr);
      method visitCallExpr (line 10) | R visitCallExpr(Call expr);
      method visitGetExpr (line 11) | R visitGetExpr(Get expr);
      method visitGroupingExpr (line 12) | R visitGroupingExpr(Grouping expr);
      method visitLiteralExpr (line 13) | R visitLiteralExpr(Literal expr);
      method visitLogicalExpr (line 14) | R visitLogicalExpr(Logical expr);
      method visitSetExpr (line 15) | R visitSetExpr(Set expr);
      method visitSuperExpr (line 16) | R visitSuperExpr(Super expr);
      method visitThisExpr (line 17) | R visitThisExpr(This expr);
      method visitUnaryExpr (line 18) | R visitUnaryExpr(Unary expr);
      method visitVariableExpr (line 19) | R visitVariableExpr(Variable expr);
    class Assign (line 24) | static class Assign extends Expr {
      method Assign (line 25) | Assign(Token name, Expr value) {
      method accept (line 30) | @Override
    class Binary (line 40) | static class Binary extends Expr {
      method Binary (line 41) | Binary(Expr left, Token operator, Expr right) {
      method accept (line 47) | @Override
    class Call (line 58) | static class Call extends Expr {
      method Call (line 59) | Call(Expr callee, Token paren, List<Expr> arguments) {
      method accept (line 65) | @Override
    class Get (line 76) | static class Get extends Expr {
      method Get (line 77) | Get(Expr object, Token name) {
      method accept (line 82) | @Override
    class Grouping (line 92) | static class Grouping extends Expr {
      method Grouping (line 93) | Grouping(Expr expression) {
      method accept (line 97) | @Override
    class Literal (line 106) | static class Literal extends Expr {
      method Literal (line 107) | Literal(Object value) {
      method accept (line 111) | @Override
    class Logical (line 120) | static class Logical extends Expr {
      method Logical (line 121) | Logical(Expr left, Token operator, Expr right) {
      method accept (line 127) | @Override
    class Set (line 138) | static class Set extends Expr {
      method Set (line 139) | Set(Expr object, Token name, Expr value) {
      method accept (line 145) | @Override
    class Super (line 156) | static class Super extends Expr {
      method Super (line 157) | Super(Token keyword, Token method) {
      method accept (line 162) | @Override
    class This (line 172) | static class This extends Expr {
      method This (line 173) | This(Token keyword) {
      method accept (line 177) | @Override
    class Unary (line 186) | static class Unary extends Expr {
      method Unary (line 187) | Unary(Token operator, Expr right) {
      method accept (line 192) | @Override
    class Variable (line 202) | static class Variable extends Expr {
      method Variable (line 203) | Variable(Token name) {
      method accept (line 207) | @Override
    method accept (line 216) | abstract <R> R accept(Visitor<R> visitor);

FILE: java/com/craftinginterpreters/lox/Interpreter.java
  class Interpreter (line 21) | class Interpreter implements Expr.Visitor<Object>,
    method Interpreter (line 38) | Interpreter() {
    method interpret (line 66) | void interpret(List<Stmt> statements) {
    method evaluate (line 77) | private Object evaluate(Expr expr) {
    method execute (line 82) | private void execute(Stmt stmt) {
    method resolve (line 87) | void resolve(Expr expr, int depth) {
    method executeBlock (line 92) | void executeBlock(List<Stmt> statements,
    method visitBlockStmt (line 107) | @Override
    method visitClassStmt (line 114) | @Override
    method visitExpressionStmt (line 172) | @Override
    method visitFunctionStmt (line 179) | @Override
    method visitIfStmt (line 196) | @Override
    method visitPrintStmt (line 207) | @Override
    method visitReturnStmt (line 215) | @Override
    method visitVarStmt (line 224) | @Override
    method visitWhileStmt (line 236) | @Override
    method visitAssignExpr (line 245) | @Override
    method visitBinaryExpr (line 265) | @Override
    method visitCallExpr (line 337) | @Override
    method visitGetExpr (line 366) | @Override
    method visitGroupingExpr (line 378) | @Override
    method visitLiteralExpr (line 384) | @Override
    method visitLogicalExpr (line 390) | @Override
    method visitSetExpr (line 404) | @Override
    method visitSuperExpr (line 419) | @Override
    method visitThisExpr (line 445) | @Override
    method visitUnaryExpr (line 451) | @Override
    method visitVariableExpr (line 472) | @Override
    method lookUpVariable (line 482) | private Object lookUpVariable(Token name, Expr expr) {
    method checkNumberOperand (line 493) | private void checkNumberOperand(Token operator, Object operand) {
    method checkNumberOperands (line 499) | private void checkNumberOperands(Token operator,
    method isTruthy (line 507) | private boolean isTruthy(Object object) {
    method isEqual (line 514) | private boolean isEqual(Object a, Object b) {
    method stringify (line 522) | private String stringify(Object object) {

FILE: java/com/craftinginterpreters/lox/Lox.java
  class Lox (line 12) | public class Lox {
    method main (line 23) | public static void main(String[] args) throws IOException {
    method runFile (line 34) | private static void runFile(String path) throws IOException {
    method runPrompt (line 48) | private static void runPrompt() throws IOException {
    method run (line 64) | private static void run(String source) {
    method error (line 109) | static void error(int line, String message) {
    method report (line 113) | private static void report(int line, String where,
    method error (line 121) | static void error(Token token, String message) {
    method runtimeError (line 130) | static void runtimeError(RuntimeError error) {

FILE: java/com/craftinginterpreters/lox/LoxCallable.java
  type LoxCallable (line 6) | interface LoxCallable {
    method arity (line 8) | int arity();
    method call (line 10) | Object call(Interpreter interpreter, List<Object> arguments);

FILE: java/com/craftinginterpreters/lox/LoxClass.java
  class LoxClass (line 11) | class LoxClass implements LoxCallable {
    method LoxClass (line 30) | LoxClass(String name, LoxClass superclass,
    method findMethod (line 39) | LoxFunction findMethod(String name) {
    method toString (line 54) | @Override
    method call (line 59) | @Override
    method arity (line 73) | @Override

FILE: java/com/craftinginterpreters/lox/LoxFunction.java
  class LoxFunction (line 6) | class LoxFunction implements LoxCallable {
    method LoxFunction (line 21) | LoxFunction(Stmt.Function declaration, Environment closure,
    method bind (line 31) | LoxFunction bind(LoxInstance instance) {
    method toString (line 44) | @Override
    method arity (line 50) | @Override
    method call (line 56) | @Override

FILE: java/com/craftinginterpreters/lox/LoxInstance.java
  class LoxInstance (line 7) | class LoxInstance {
    method LoxInstance (line 13) | LoxInstance(LoxClass klass) {
    method get (line 18) | Object get(Token name) {
    method set (line 38) | void set(Token name, Object value) {
    method toString (line 42) | @Override

FILE: java/com/craftinginterpreters/lox/Parser.java
  class Parser (line 14) | class Parser {
    class ParseError (line 16) | private static class ParseError extends RuntimeException {}
    method Parser (line 22) | Parser(List<Token> tokens) {
    method parse (line 35) | List<Stmt> parse() {
    method expression (line 50) | private Expr expression() {
    method declaration (line 60) | private Stmt declaration() {
    method classDeclaration (line 78) | private Stmt classDeclaration() {
    method statement (line 107) | private Stmt statement() {
    method forStatement (line 129) | private Stmt forStatement() {
    method ifStatement (line 189) | private Stmt ifStatement() {
    method printStatement (line 204) | private Stmt printStatement() {
    method returnStatement (line 211) | private Stmt returnStatement() {
    method varDeclaration (line 223) | private Stmt varDeclaration() {
    method whileStatement (line 236) | private Stmt whileStatement() {
    method expressionStatement (line 246) | private Stmt expressionStatement() {
    method function (line 253) | private Stmt.Function function(String kind) {
    method block (line 279) | private List<Stmt> block() {
    method assignment (line 291) | private Expr assignment() {
    method or (line 320) | private Expr or() {
    method and (line 333) | private Expr and() {
    method equality (line 346) | private Expr equality() {
    method comparison (line 359) | private Expr comparison() {
    method term (line 372) | private Expr term() {
    method factor (line 385) | private Expr factor() {
    method unary (line 398) | private Expr unary() {
    method finishCall (line 414) | private Expr finishCall(Expr callee) {
    method call (line 434) | private Expr call() {
    method primary (line 455) | private Expr primary() {
    method match (line 496) | private boolean match(TokenType... types) {
    method consume (line 508) | private Token consume(TokenType type, String message) {
    method check (line 515) | private boolean check(TokenType type) {
    method advance (line 521) | private Token advance() {
    method isAtEnd (line 527) | private boolean isAtEnd() {
    method peek (line 531) | private Token peek() {
    method previous (line 535) | private Token previous() {
    method error (line 540) | private ParseError error(Token token, String message) {
    method synchronize (line 546) | private void synchronize() {

FILE: java/com/craftinginterpreters/lox/Resolver.java
  class Resolver (line 9) | class Resolver implements Expr.Visitor<Void>, Stmt.Visitor<Void> {
    method Resolver (line 18) | Resolver(Interpreter interpreter) {
    type FunctionType (line 22) | private enum FunctionType {
    type ClassType (line 38) | private enum ClassType {
    method resolve (line 53) | void resolve(List<Stmt> statements) {
    method visitBlockStmt (line 60) | @Override
    method visitClassStmt (line 69) | @Override
    method visitExpressionStmt (line 136) | @Override
    method visitFunctionStmt (line 143) | @Override
    method visitIfStmt (line 158) | @Override
    method visitPrintStmt (line 167) | @Override
    method visitReturnStmt (line 174) | @Override
    method visitVarStmt (line 197) | @Override
    method visitWhileStmt (line 208) | @Override
    method visitAssignExpr (line 216) | @Override
    method visitBinaryExpr (line 224) | @Override
    method visitCallExpr (line 232) | @Override
    method visitGetExpr (line 244) | @Override
    method visitGroupingExpr (line 251) | @Override
    method visitLiteralExpr (line 258) | @Override
    method visitLogicalExpr (line 264) | @Override
    method visitSetExpr (line 272) | @Override
    method visitSuperExpr (line 280) | @Override
    method visitThisExpr (line 297) | @Override
    method visitUnaryExpr (line 313) | @Override
    method visitVariableExpr (line 320) | @Override
    method resolve (line 333) | private void resolve(Stmt stmt) {
    method resolve (line 338) | private void resolve(Expr expr) {
    method resolveFunction (line 347) | private void resolveFunction(
    method beginScope (line 366) | private void beginScope() {
    method endScope (line 371) | private void endScope() {
    method declare (line 376) | private void declare(Token name) {
    method define (line 391) | private void define(Token name) {
    method resolveLocal (line 397) | private void resolveLocal(Expr expr, Token name) {

FILE: java/com/craftinginterpreters/lox/Return.java
  class Return (line 4) | class Return extends RuntimeException {
    method Return (line 7) | Return(Object value) {

FILE: java/com/craftinginterpreters/lox/RuntimeError.java
  class RuntimeError (line 4) | class RuntimeError extends RuntimeException {
    method RuntimeError (line 7) | RuntimeError(Token token, String message) {

FILE: java/com/craftinginterpreters/lox/Scanner.java
  class Scanner (line 11) | class Scanner {
    method Scanner (line 43) | Scanner(String source) {
    method scanTokens (line 47) | List<Token> scanTokens() {
    method scanToken (line 59) | private void scanToken() {
    method identifier (line 135) | private void identifier() {
    method number (line 150) | private void number() {
    method string (line 166) | private void string() {
    method match (line 186) | private boolean match(char expected) {
    method peek (line 195) | private char peek() {
    method peekNext (line 201) | private char peekNext() {
    method isAlpha (line 207) | private boolean isAlpha(char c) {
    method isAlphaNumeric (line 213) | private boolean isAlphaNumeric(char c) {
    method isDigit (line 218) | private boolean isDigit(char c) {
    method isAtEnd (line 223) | private boolean isAtEnd() {
    method advance (line 228) | private char advance() {
    method addToken (line 232) | private void addToken(TokenType type) {
    method addToken (line 236) | private void addToken(TokenType type, Object literal) {

FILE: java/com/craftinginterpreters/lox/Stmt.java
  class Stmt (line 6) | abstract class Stmt {
    type Visitor (line 7) | interface Visitor<R> {
      method visitBlockStmt (line 8) | R visitBlockStmt(Block stmt);
      method visitClassStmt (line 9) | R visitClassStmt(Class stmt);
      method visitExpressionStmt (line 10) | R visitExpressionStmt(Expression stmt);
      method visitFunctionStmt (line 11) | R visitFunctionStmt(Function stmt);
      method visitIfStmt (line 12) | R visitIfStmt(If stmt);
      method visitPrintStmt (line 13) | R visitPrintStmt(Print stmt);
      method visitReturnStmt (line 14) | R visitReturnStmt(Return stmt);
      method visitVarStmt (line 15) | R visitVarStmt(Var stmt);
      method visitWhileStmt (line 16) | R visitWhileStmt(While stmt);
    class Block (line 21) | static class Block extends Stmt {
      method Block (line 22) | Block(List<Stmt> statements) {
      method accept (line 26) | @Override
    class Class (line 35) | static class Class extends Stmt {
      method Class (line 36) | Class(Token name,
      method accept (line 44) | @Override
    class Expression (line 55) | static class Expression extends Stmt {
      method Expression (line 56) | Expression(Expr expression) {
      method accept (line 60) | @Override
    class Function (line 69) | static class Function extends Stmt {
      method Function (line 70) | Function(Token name, List<Token> params, List<Stmt> body) {
      method accept (line 76) | @Override
    class If (line 87) | static class If extends Stmt {
      method If (line 88) | If(Expr condition, Stmt thenBranch, Stmt elseBranch) {
      method accept (line 94) | @Override
    class Print (line 105) | static class Print extends Stmt {
      method Print (line 106) | Print(Expr expression) {
      method accept (line 110) | @Override
    class Return (line 119) | static class Return extends Stmt {
      method Return (line 120) | Return(Token keyword, Expr value) {
      method accept (line 125) | @Override
    class Var (line 135) | static class Var extends Stmt {
      method Var (line 136) | Var(Token name, Expr initializer) {
      method accept (line 141) | @Override
    class While (line 151) | static class While extends Stmt {
      method While (line 152) | While(Expr condition, Stmt body) {
      method accept (line 157) | @Override
    method accept (line 167) | abstract <R> R accept(Visitor<R> visitor);

FILE: java/com/craftinginterpreters/lox/Token.java
  class Token (line 4) | class Token {
    method Token (line 10) | Token(TokenType type, String lexeme, Object literal, int line) {
    method toString (line 17) | public String toString() {

FILE: java/com/craftinginterpreters/lox/TokenType.java
  type TokenType (line 4) | enum TokenType {

FILE: java/com/craftinginterpreters/tool/GenerateAst.java
  class GenerateAst (line 9) | public class GenerateAst {
    method main (line 10) | public static void main(String[] args) throws IOException {
    method defineAst (line 93) | private static void defineAst(
    method defineVisitor (line 139) | private static void defineVisitor(
    method defineType (line 153) | private static void defineType(
    type PastryVisitor (line 210) | interface PastryVisitor {
      method visitBeignet (line 211) | void visitBeignet(Beignet beignet);
      method visitCruller (line 212) | void visitCruller(Cruller cruller);
    class Pastry (line 216) | abstract class Pastry {
      method accept (line 218) | abstract void accept(PastryVisitor visitor);
    class Beignet (line 222) | class Beignet extends Pastry {
      method accept (line 224) | @Override
    class Cruller (line 231) | class Cruller extends Pastry {
      method accept (line 233) | @Override

FILE: note/answers/chapter01_introduction/2/Hello.java
  class Hello (line 1) | public class Hello {
    method main (line 2) | public static void main(String[] args) {

FILE: note/answers/chapter01_introduction/3/linked_list.c
  type Node (line 5) | typedef struct sNode {
  function insert (line 13) | void insert(Node** list, Node* prev, const char* string) {
  function Node (line 32) | Node* find(Node* list, const char* string) {
  function delete (line 45) | void delete(Node** list, Node* node) {
  function dump (line 57) | void dump(Node* list) {
  function main (line 65) | int main(int argc, const char* argv[]) {

FILE: note/answers/chapter11_resolving/4/com/craftinginterpreters/lox/AstPrinter.java
  class AstPrinter (line 4) | class AstPrinter implements Expr.Visitor<String>, Stmt.Visitor<String> {
    method print (line 5) | String print(Expr expr) {
    method print (line 9) | String print(Stmt stmt) {
    method visitBlockStmt (line 12) | @Override
    method visitExpressionStmt (line 25) | @Override
    method visitFunctionStmt (line 30) | @Override
    method visitIfStmt (line 50) | @Override
    method visitPrintStmt (line 60) | @Override
    method visitReturnStmt (line 65) | @Override
    method visitVarStmt (line 71) | @Override
    method visitWhileStmt (line 80) | @Override
    method visitAssignExpr (line 85) | @Override
    method visitBinaryExpr (line 90) | @Override
    method visitCallExpr (line 95) | @Override
    method visitGroupingExpr (line 100) | @Override
    method visitLiteralExpr (line 105) | @Override
    method visitLogicalExpr (line 111) | @Override
    method visitUnaryExpr (line 116) | @Override
    method visitVariableExpr (line 121) | @Override
    method parenthesize (line 125) | private String parenthesize(String name, Expr... exprs) {
    method parenthesize2 (line 140) | private String parenthesize2(String name, Object... parts) {

FILE: note/answers/chapter11_resolving/4/com/craftinginterpreters/lox/Environment.java
  class Environment (line 6) | class Environment {
    method Environment (line 10) | Environment() {
    method Environment (line 14) | Environment(Environment enclosing) {
    method define (line 18) | void define(Object value) {
    method getAt (line 22) | Object getAt(int distance, int slot) {
    method assignAt (line 31) | void assignAt(int distance, int slot, Object value) {
    method toString (line 39) | @Override

FILE: note/answers/chapter11_resolving/4/com/craftinginterpreters/lox/Expr.java
  class Expr (line 5) | abstract class Expr {
    type Visitor (line 6) | interface Visitor<R> {
      method visitAssignExpr (line 7) | R visitAssignExpr(Assign expr);
      method visitBinaryExpr (line 8) | R visitBinaryExpr(Binary expr);
      method visitCallExpr (line 9) | R visitCallExpr(Call expr);
      method visitGroupingExpr (line 10) | R visitGroupingExpr(Grouping expr);
      method visitLiteralExpr (line 11) | R visitLiteralExpr(Literal expr);
      method visitLogicalExpr (line 12) | R visitLogicalExpr(Logical expr);
      method visitUnaryExpr (line 13) | R visitUnaryExpr(Unary expr);
      method visitVariableExpr (line 14) | R visitVariableExpr(Variable expr);
    class Assign (line 17) | static class Assign extends Expr {
      method Assign (line 18) | Assign(Token name, Expr value) {
      method accept (line 23) | <R> R accept(Visitor<R> visitor) {
    class Binary (line 31) | static class Binary extends Expr {
      method Binary (line 32) | Binary(Expr left, Token operator, Expr right) {
      method accept (line 38) | <R> R accept(Visitor<R> visitor) {
    class Call (line 47) | static class Call extends Expr {
      method Call (line 48) | Call(Expr callee, Token paren, List<Expr> arguments) {
      method accept (line 54) | <R> R accept(Visitor<R> visitor) {
    class Grouping (line 63) | static class Grouping extends Expr {
      method Grouping (line 64) | Grouping(Expr expression) {
      method accept (line 68) | <R> R accept(Visitor<R> visitor) {
    class Literal (line 75) | static class Literal extends Expr {
      method Literal (line 76) | Literal(Object value) {
      method accept (line 80) | <R> R accept(Visitor<R> visitor) {
    class Logical (line 87) | static class Logical extends Expr {
      method Logical (line 88) | Logical(Expr left, Token operator, Expr right) {
      method accept (line 94) | <R> R accept(Visitor<R> visitor) {
    class Unary (line 103) | static class Unary extends Expr {
      method Unary (line 104) | Unary(Token operator, Expr right) {
      method accept (line 109) | <R> R accept(Visitor<R> visitor) {
    class Variable (line 117) | static class Variable extends Expr {
      method Variable (line 118) | Variable(Token name) {
      method accept (line 122) | <R> R accept(Visitor<R> visitor) {
    method accept (line 129) | abstract <R> R accept(Visitor<R> visitor);

FILE: note/answers/chapter11_resolving/4/com/craftinginterpreters/lox/Interpreter.java
  class Interpreter (line 8) | class Interpreter implements Expr.Visitor<Object>, Stmt.Visitor<Void> {
    method Interpreter (line 14) | Interpreter() {
    method interpret (line 28) | void interpret(List<Stmt> statements) {
    method evaluate (line 37) | private Object evaluate(Expr expr) {
    method execute (line 40) | private void execute(Stmt stmt) {
    method resolve (line 43) | void resolve(Expr expr, int depth, int slot) {
    method executeBlock (line 47) | void executeBlock(List<Stmt> statements, Environment environment) {
    method visitBlockStmt (line 59) | @Override
    method visitExpressionStmt (line 64) | @Override
    method visitFunctionStmt (line 69) | @Override
    method visitIfStmt (line 75) | @Override
    method visitPrintStmt (line 84) | @Override
    method visitReturnStmt (line 90) | @Override
    method visitVarStmt (line 97) | @Override
    method visitWhileStmt (line 107) | @Override
    method visitAssignExpr (line 114) | @Override
    method visitBinaryExpr (line 132) | @Override
    method visitCallExpr (line 177) | @Override
    method visitGroupingExpr (line 200) | @Override
    method visitLiteralExpr (line 204) | @Override
    method visitLogicalExpr (line 208) | @Override
    method visitUnaryExpr (line 220) | @Override
    method visitVariableExpr (line 235) | @Override
    method lookUpVariable (line 239) | private Object lookUpVariable(Token name, Expr expr) {
    method checkNumberOperand (line 252) | private void checkNumberOperand(Token operator, Object operand) {
    method checkNumberOperands (line 256) | private void checkNumberOperands(Token operator,
    method isTruthy (line 262) | private boolean isTruthy(Object object) {
    method isEqual (line 267) | private boolean isEqual(Object a, Object b) {
    method stringify (line 274) | private String stringify(Object object) {
    method define (line 288) | private void define(Token name, Object value) {

FILE: note/answers/chapter11_resolving/4/com/craftinginterpreters/lox/Lox.java
  class Lox (line 11) | public class Lox {
    method main (line 16) | public static void main(String[] args) throws IOException {
    method runFile (line 25) | private static void runFile(String path) throws IOException {
    method runPrompt (line 33) | private static void runPrompt() throws IOException {
    method run (line 43) | private static void run(String source) {
    method error (line 60) | static void error(int line, String message) {
    method report (line 64) | static private void report(int line, String where, String message) {
    method error (line 69) | static void error(Token token, String message) {
    method runtimeError (line 76) | static void runtimeError(RuntimeError error) {

FILE: note/answers/chapter11_resolving/4/com/craftinginterpreters/lox/LoxCallable.java
  type LoxCallable (line 5) | interface LoxCallable {
    method arity (line 6) | int arity();
    method call (line 7) | Object call(Interpreter interpreter, List<Object> arguments);

FILE: note/answers/chapter11_resolving/4/com/craftinginterpreters/lox/LoxFunction.java
  class LoxFunction (line 5) | class LoxFunction implements LoxCallable {
    method LoxFunction (line 9) | LoxFunction(Stmt.Function declaration, Environment closure) {
    method toString (line 13) | @Override
    method arity (line 17) | @Override
    method call (line 21) | @Override

FILE: note/answers/chapter11_resolving/4/com/craftinginterpreters/lox/Parser.java
  class Parser (line 9) | class Parser {
    class ParseError (line 10) | private static class ParseError extends RuntimeException {}
    method Parser (line 15) | Parser(List<Token> tokens) {
    method parse (line 18) | List<Stmt> parse() {
    method expression (line 26) | private Expr expression() {
    method declaration (line 29) | private Stmt declaration() {
    method statement (line 40) | private Stmt statement() {
    method forStatement (line 50) | private Stmt forStatement() {
    method ifStatement (line 90) | private Stmt ifStatement() {
    method printStatement (line 103) | private Stmt printStatement() {
    method returnStatement (line 108) | private Stmt returnStatement() {
    method varDeclaration (line 118) | private Stmt varDeclaration() {
    method whileStatement (line 129) | private Stmt whileStatement() {
    method expressionStatement (line 137) | private Stmt expressionStatement() {
    method function (line 142) | private Stmt.Function function(String kind) {
    method block (line 161) | private List<Stmt> block() {
    method assignment (line 171) | private Expr assignment() {
    method or (line 188) | private Expr or() {
    method and (line 199) | private Expr and() {
    method equality (line 210) | private Expr equality() {
    method comparison (line 221) | private Expr comparison() {
    method addition (line 232) | private Expr addition() {
    method multiplication (line 244) | private Expr multiplication() {
    method unary (line 255) | private Expr unary() {
    method finishCall (line 264) | private Expr finishCall(Expr callee) {
    method call (line 279) | private Expr call() {
    method primary (line 293) | private Expr primary() {
    method match (line 314) | private boolean match(TokenType... types) {
    method consume (line 324) | private Token consume(TokenType type, String message) {
    method check (line 329) | private boolean check(TokenType tokenType) {
    method advance (line 333) | private Token advance() {
    method isAtEnd (line 337) | private boolean isAtEnd() {
    method peek (line 341) | private Token peek() {
    method previous (line 345) | private Token previous() {
    method error (line 348) | private ParseError error(Token token, String message) {
    method synchronize (line 352) | private void synchronize() {

FILE: note/answers/chapter11_resolving/4/com/craftinginterpreters/lox/Resolver.java
  class Resolver (line 8) | class Resolver implements Expr.Visitor<Void>, Stmt.Visitor<Void> {
    method Resolver (line 13) | Resolver(Interpreter interpreter) {
    class Variable (line 16) | private class Variable {
      method Variable (line 20) | private Variable(int slot) {
    type FunctionType (line 24) | private enum FunctionType {
    method resolve (line 28) | void resolve(List<Stmt> statements) {
    method visitBlockStmt (line 33) | @Override
    method visitExpressionStmt (line 40) | @Override
    method visitFunctionStmt (line 45) | @Override
    method visitIfStmt (line 53) | @Override
    method visitPrintStmt (line 60) | @Override
    method visitReturnStmt (line 65) | @Override
    method visitVarStmt (line 77) | @Override
    method visitWhileStmt (line 86) | @Override
    method visitAssignExpr (line 92) | @Override
    method visitBinaryExpr (line 98) | @Override
    method visitCallExpr (line 104) | @Override
    method visitGroupingExpr (line 114) | @Override
    method visitLiteralExpr (line 119) | @Override
    method visitLogicalExpr (line 123) | @Override
    method visitUnaryExpr (line 129) | @Override
    method visitVariableExpr (line 134) | @Override
    method resolve (line 146) | private void resolve(Stmt stmt) {
    method resolve (line 149) | private void resolve(Expr expr) {
    method resolveFunction (line 152) | private void resolveFunction(Stmt.Function function, FunctionType type) {
    method beginScope (line 165) | private void beginScope() {
    method endScope (line 168) | private void endScope() {
    method declare (line 171) | private void declare(Token name) {
    method define (line 182) | private void define(Token name) {
    method resolveLocal (line 186) | private void resolveLocal(Expr expr, Token name) {

FILE: note/answers/chapter11_resolving/4/com/craftinginterpreters/lox/Return.java
  class Return (line 3) | class Return extends RuntimeException {
    method Return (line 6) | Return(Object value) {

FILE: note/answers/chapter11_resolving/4/com/craftinginterpreters/lox/RuntimeError.java
  class RuntimeError (line 3) | class RuntimeError extends RuntimeException {
    method RuntimeError (line 6) | RuntimeError(Token token, String message) {

FILE: note/answers/chapter11_resolving/4/com/craftinginterpreters/lox/Scanner.java
  class Scanner (line 10) | class Scanner {
    method Scanner (line 38) | Scanner(String source) {
    method scanTokens (line 41) | List<Token> scanTokens() {
    method scanToken (line 51) | private void scanToken() {
    method identifier (line 100) | private void identifier() {
    method number (line 110) | private void number() {
    method string (line 124) | private void string() {
    method match (line 143) | private boolean match(char expected) {
    method peek (line 150) | private char peek() {
    method peekNext (line 154) | private char peekNext() {
    method isAlpha (line 158) | private boolean isAlpha(char c) {
    method isAlphaNumeric (line 164) | private boolean isAlphaNumeric(char c) {
    method isDigit (line 167) | private boolean isDigit(char c) {
    method isAtEnd (line 170) | private boolean isAtEnd() {
    method advance (line 173) | private char advance() {
    method addToken (line 178) | private void addToken(TokenType type) {
    method addToken (line 182) | private void addToken(TokenType type, Object literal) {

FILE: note/answers/chapter11_resolving/4/com/craftinginterpreters/lox/Stmt.java
  class Stmt (line 5) | abstract class Stmt {
    type Visitor (line 6) | interface Visitor<R> {
      method visitBlockStmt (line 7) | R visitBlockStmt(Block stmt);
      method visitExpressionStmt (line 8) | R visitExpressionStmt(Expression stmt);
      method visitFunctionStmt (line 9) | R visitFunctionStmt(Function stmt);
      method visitIfStmt (line 10) | R visitIfStmt(If stmt);
      method visitPrintStmt (line 11) | R visitPrintStmt(Print stmt);
      method visitReturnStmt (line 12) | R visitReturnStmt(Return stmt);
      method visitVarStmt (line 13) | R visitVarStmt(Var stmt);
      method visitWhileStmt (line 14) | R visitWhileStmt(While stmt);
    class Block (line 17) | static class Block extends Stmt {
      method Block (line 18) | Block(List<Stmt> statements) {
      method accept (line 22) | <R> R accept(Visitor<R> visitor) {
    class Expression (line 29) | static class Expression extends Stmt {
      method Expression (line 30) | Expression(Expr expression) {
      method accept (line 34) | <R> R accept(Visitor<R> visitor) {
    class Function (line 41) | static class Function extends Stmt {
      method Function (line 42) | Function(Token name, List<Token> parameters, List<Stmt> body) {
      method accept (line 48) | <R> R accept(Visitor<R> visitor) {
    class If (line 57) | static class If extends Stmt {
      method If (line 58) | If(Expr condition, Stmt thenBranch, Stmt elseBranch) {
      method accept (line 64) | <R> R accept(Visitor<R> visitor) {
    class Print (line 73) | static class Print extends Stmt {
      method Print (line 74) | Print(Expr expression) {
      method accept (line 78) | <R> R accept(Visitor<R> visitor) {
    class Return (line 85) | static class Return extends Stmt {
      method Return (line 86) | Return(Token keyword, Expr value) {
      method accept (line 91) | <R> R accept(Visitor<R> visitor) {
    class Var (line 99) | static class Var extends Stmt {
      method Var (line 100) | Var(Token name, Expr initializer) {
      method accept (line 105) | <R> R accept(Visitor<R> visitor) {
    class While (line 113) | static class While extends Stmt {
      method While (line 114) | While(Expr condition, Stmt body) {
      method accept (line 119) | <R> R accept(Visitor<R> visitor) {
    method accept (line 127) | abstract <R> R accept(Visitor<R> visitor);

FILE: note/answers/chapter11_resolving/4/com/craftinginterpreters/lox/Token.java
  class Token (line 3) | class Token {
    method Token (line 9) | Token(TokenType type, String lexeme, Object literal, int line) {
    method toString (line 16) | public String toString() {

FILE: note/answers/chapter11_resolving/4/com/craftinginterpreters/lox/TokenType.java
  type TokenType (line 3) | enum TokenType {

FILE: note/answers/chapter11_resolving/4/com/craftinginterpreters/tool/GenerateAst.java
  class GenerateAst (line 8) | public class GenerateAst {
    method main (line 9) | public static void main(String[] args) throws IOException {
    method defineAst (line 37) | private static void defineAst(
    method defineVisitor (line 65) | private static void defineVisitor(
    method defineType (line 77) | private static void defineType(
    type PastryVisitor (line 111) | interface PastryVisitor {
      method visitBeignet (line 112) | void visitBeignet(Beignet beignet);
      method visitCruller (line 113) | void visitCruller(Cruller cruller);
    class Pastry (line 115) | abstract class Pastry {
      method accept (line 116) | abstract void accept(PastryVisitor visitor);
    class Beignet (line 119) | class Beignet extends Pastry {
      method accept (line 120) | @Override
    class Cruller (line 126) | class Cruller extends Pastry {
      method accept (line 127) | @Override

FILE: site/script.js
  function refreshAsides (line 37) | function refreshAsides() {

FILE: tool/bin/benchmark.dart
  function main (line 6) | void main(List<String> arguments)
  function runBenchmark (line 25) | void runBenchmark(String interpreter, String benchmark)
  function runTrial (line 40) | double runTrial(String interpreter, String benchmark)
  function runComparison (line 52) | void runComparison(List<String> interpreters, String benchmark)

FILE: tool/bin/build.dart
  function main (line 33) | Future<void> main(List<String> arguments)
  function _buildPages (line 43) | void _buildPages({bool skipUpToDate = false})
  function _buildPage (line 73) | List<int> _buildPage(Book book, Mustache mustache, Page page,
  function _buildSass (line 138) | void _buildSass({bool skipUpToDate = false})
  function _runServer (line 157) | Future<void> _runServer()
  function handleRequest (line 158) | Future<shelf.Response> handleRequest(shelf.Request request)
  function _isUpToDate (line 190) | bool _isUpToDate(
  function _mostRecentlyModified (line 199) | DateTime _mostRecentlyModified(List<String> globs)

FILE: tool/bin/build_xml.dart
  function main (line 15) | Future<void> main(List<String> arguments)
  function _buildPage (line 35) | void _buildPage(Book book, Mustache mustache, Page page)

FILE: tool/bin/compile_snippets.dart
  function main (line 297) | Future<void> main(List<String> arguments)
  function _compileChapterTag (line 326) | Future<void> _compileChapterTag(Book book, Page chapter, CodeTag tag)

FILE: tool/bin/split_chapters.dart
  function main (line 4) | void main(List<String> arguments)

FILE: tool/bin/test.dart
  class Suite (line 34) | class Suite {
  function main (line 44) | void main(List<String> arguments)
  function _usageError (line 92) | void _usageError(ArgParser parser, String message)
  function _runSuites (line 102) | void _runSuites(List<String> names)
  function _runSuite (line 112) | bool _runSuite(String name)
  function _runTest (line 137) | void _runTest(String path)
  class ExpectedOutput (line 178) | class ExpectedOutput {
  class Test (line 185) | class Test {
    method parse (line 206) | bool parse()
    method run (line 295) | List<String> run()
    method _validateRuntimeError (line 318) | void _validateRuntimeError(List<String> errorLines)
    method _validateCompileErrors (line 348) | void _validateCompileErrors(List<String> error_lines)
    method _validateExitCode (line 384) | void _validateExitCode(int exitCode, List<String> errorLines)
    method _validateOutput (line 396) | void _validateOutput(List<String> outputLines)
    method fail (line 425) | void fail(String message, [List<String> lines])
  function _defineTestSuites (line 431) | void _defineTestSuites()
  function c (line 432) | void c(String name, Map<String, String> tests)
  function java (line 438) | void java(String name, Map<String, String> tests)

FILE: tool/bin/tile_pages.dart
  function main (line 11) | Future<void> main(List<String> arguments)

FILE: tool/lib/src/book.dart
  class Book (line 62) | class Book {
    method findChapter (line 148) | Page findChapter(String title)
    method findNumber (line 152) | Page findNumber(String number)
    method adjacentPage (line 156) | Page adjacentPage(Page start, int offset)
    method findSnippet (line 162) | Snippet findSnippet(CodeTag tag)
    method lastSnippet (line 167) | Snippet lastSnippet(Page page)
    method findTag (line 180) | CodeTag findTag(Page page, String name)
  class SourceFile (line 191) | class SourceFile {
  class SourceLine (line 203) | class SourceLine {
    method isPresent (line 217) | bool isPresent(CodeTag tag)
    method toString (line 227) | String toString()

FILE: tool/lib/src/code_tag.dart
  class CodeTag (line 3) | class CodeTag with Ordering<CodeTag> implements Comparable<CodeTag> {
    method compareTo (line 40) | int compareTo(CodeTag other)
    method toString (line 48) | String toString()

FILE: tool/lib/src/format.dart
  type Format (line 2) | enum Format {

FILE: tool/lib/src/location.dart
  class Location (line 3) | class Location {
    method toString (line 39) | String toString()
    method toHtml (line 48) | String toHtml(Location preceding, List<String> removed)
    method toXml (line 107) | String toXml(Location preceding, List<String> removed)
    method popToDepth (line 180) | Location popToDepth(int depth)

FILE: tool/lib/src/markdown/block_syntax.dart
  class BookHeaderSyntax (line 11) | class BookHeaderSyntax extends BlockSyntax {
    method parse (line 22) | Node parse(BlockParser parser)

FILE: tool/lib/src/markdown/code_syntax.dart
  class HighlightedCodeBlockSyntax (line 12) | class HighlightedCodeBlockSyntax extends BlockSyntax {
    method canParse (line 21) | bool canParse(BlockParser parser)
    method parseChildLines (line 24) | List<String> parseChildLines(BlockParser parser)
    method parse (line 42) | Node parse(BlockParser parser)
  class CodeTagBlockSyntax (line 106) | class CodeTagBlockSyntax extends BlockSyntax {
    method canParse (line 117) | bool canParse(BlockParser parser)
    method parse (line 120) | Node parse(BlockParser parser)
  function _buildSnippet (line 136) | String _buildSnippet(Format format, CodeTag tag, Snippet snippet)
  function _buildSnippetXml (line 192) | String _buildSnippetXml(CodeTag tag, Snippet snippet)
  function _writeContextHtml (line 254) | void _writeContextHtml(Format format, StringBuffer buffer, List<String> ...
  function _writeContextXml (line 273) | void _writeContextXml(StringBuffer buffer, List<String> lines, String tag)

FILE: tool/lib/src/markdown/html_renderer.dart
  class HtmlRenderer (line 4) | class HtmlRenderer implements NodeVisitor {
    method render (line 27) | String render(List<Node> nodes)
    method visitText (line 39) | void visitText(Text text)
    method visitElementBefore (line 58) | bool visitElementBefore(Element element)
    method visitElementAfter (line 84) | void visitElementAfter(Element element)

FILE: tool/lib/src/markdown/inline_syntax.dart
  class EllipseSyntax (line 6) | class EllipseSyntax extends InlineSyntax {
    method onMatch (line 11) | bool onMatch(InlineParser parser, Match match)
  class ApostropheSyntax (line 21) | class ApostropheSyntax extends InlineSyntax {
    method onMatch (line 26) | bool onMatch(InlineParser parser, Match match)
    method _isRight (line 47) | bool _isRight(int before, int after)
  class SmartQuoteSyntax (line 62) | class SmartQuoteSyntax extends InlineSyntax {
    method onMatch (line 67) | bool onMatch(InlineParser parser, Match match)
    method _isRight (line 89) | bool _isRight(int before, int after)
  class EmDashSyntax (line 107) | class EmDashSyntax extends InlineSyntax {
    method onMatch (line 112) | bool onMatch(InlineParser parser, Match match)
  class NewlineSyntax (line 121) | class NewlineSyntax extends InlineSyntax {
    method onMatch (line 124) | bool onMatch(InlineParser parser, Match match)

FILE: tool/lib/src/markdown/markdown.dart
  function renderMarkdown (line 12) | String renderMarkdown(Book book, Page page, List<String> lines, Format f...

FILE: tool/lib/src/markdown/xml_renderer.dart
  class XmlRenderer (line 12) | class XmlRenderer implements NodeVisitor {
    method render (line 32) | String render(List<Node> nodes)
    method visitText (line 71) | void visitText(Text node)
    method visitElementBefore (line 184) | bool visitElementBefore(Element element)
    method visitElementAfter (line 274) | void visitElementAfter(Element element)
    method _push (line 322) | void _push(String name)
    method _pop (line 327) | void _pop()
    method _addText (line 332) | void _addText(String text)
    method _addInline (line 345) | void _addInline(_Inline inline)
    method _resetParagraph (line 350) | void _resetParagraph()
    method _flushParagraph (line 354) | void _flushParagraph()
  class _Context (line 361) | class _Context {
    method has (line 368) | bool has(String name)
    method isIn (line 379) | bool isIn(String name)
    method toString (line 462) | String toString()
  class _Paragraph (line 469) | class _Paragraph {
    method _isNext (line 476) | bool _isNext(String tag, String previousTag)
    method prettyPrint (line 499) | String prettyPrint(_Paragraph previous)
  class _Inline (line 520) | class _Inline {
    method prettyPrint (line 530) | void prettyPrint(StringBuffer buffer, _Context context)

FILE: tool/lib/src/mustache.dart
  class Mustache (line 12) | class Mustache {
    method render (line 21) | String render(Book book, Page page, String body, {String template})
    method _makePartData (line 87) | Map<String, dynamic> _makePartData(Book book, int partIndex)
    method _makeChapterList (line 97) | List<Map<String, dynamic>> _makeChapterList(Page part)
    method _makeSections (line 109) | List<Map<String, dynamic>> _makeSections(Page page)
    method _load (line 125) | Template _load(String name)

FILE: tool/lib/src/page.dart
  class Page (line 10) | class Page {
    method findCodeTag (line 82) | CodeTag findCodeTag(String name)
    method toString (line 93) | String toString()
    method _ensureFile (line 96) | PageFile _ensureFile()
  class PageFile (line 100) | class PageFile {
  class Header (line 115) | class Header {

FILE: tool/lib/src/page_parser.dart
  function parsePage (line 14) | PageFile parsePage(Page page)
  function _createCodeTag (line 76) | CodeTag _createCodeTag(Page page, int index, String name, String options)

FILE: tool/lib/src/snippet.dart
  class Snippet (line 7) | class Snippet {
    method addLine (line 32) | void addLine(int lineIndex, SourceLine line)
    method removeLine (line 43) | void removeLine(int lineIndex, SourceLine line)
    method toString (line 95) | String toString()
    method calculateContext (line 98) | void calculateContext()

FILE: tool/lib/src/source_file_parser.dart
  class SourceFileParser (line 31) | class SourceFileParser {
    method parse (line 48) | SourceFile parse()
    method _updateLocationBefore (line 106) | void _updateLocationBefore(String line, int lineIndex)
    method _updateLocationAfter (line 172) | void _updateLocationAfter(String line)
    method _updateState (line 210) | bool _updateState(String line)
    method _push (line 296) | void _push(
    method _pop (line 315) | void _pop()
  class _ParseState (line 320) | class _ParseState {
    method toString (line 326) | String toString()

FILE: tool/lib/src/split_chapter.dart
  function splitChapter (line 16) | Future<void> splitChapter(Book book, Page chapter, [CodeTag tag])
  function _splitSourceFile (line 26) | Future<void> _splitSourceFile(Book book, Page chapter, String sourcePath,
  function _generateSourceFile (line 69) | String _generateSourceFile(

FILE: tool/lib/src/syntax/highlighter.dart
  function formatCode (line 15) | String formatCode(String language, List<String> lines, Format format,
  function checkLineLength (line 20) | void checkLineLength(String line)
  class Highlighter (line 33) | class Highlighter {
    method _highlight (line 46) | String _highlight(List<String> lines, String preClass, int indent)
    method _scanLine (line 68) | void _scanLine(String line, int indent)
    method writeToken (line 107) | void writeToken(String type, [String text])
    method writeText (line 124) | void writeText(String string)
    method _writeChar (line 130) | void _writeChar(int char)

FILE: tool/lib/src/syntax/language.dart
  class Language (line 4) | class Language {
    method keywordType (line 9) | keywordType(String wordList, String type)

FILE: tool/lib/src/syntax/rule.dart
  class Rule (line 5) | abstract class Rule {
    method apply (line 16) | bool apply(Highlighter highlighter)
    method applyRule (line 22) | void applyRule(Highlighter highlighter)
  class SimpleRule (line 27) | class SimpleRule extends Rule {
    method applyRule (line 32) | void applyRule(Highlighter highlighter)
  class CaptureRule (line 40) | class CaptureRule extends Rule {
    method applyRule (line 45) | void applyRule(Highlighter highlighter)
  class StringRule (line 59) | class StringRule extends Rule {
    method applyRule (line 64) | void applyRule(Highlighter highlighter)
  class IdentifierRule (line 90) | class IdentifierRule extends Rule {
    method applyRule (line 93) | void applyRule(Highlighter highlighter)

FILE: tool/lib/src/term.dart
  function cyan (line 14) | String cyan(Object message)
  function gray (line 15) | String gray(Object message)
  function green (line 16) | String green(Object message)
  function magenta (line 17) | String magenta(Object message)
  function pink (line 18) | String pink(Object message)
  function red (line 19) | String red(Object message)
  function yellow (line 20) | String yellow(Object message)
  function clearLine (line 22) | void clearLine()
  function writeLine (line 30) | void writeLine([String line])
  function _ansi (line 38) | String _ansi(String special, [String fallback = ''])

FILE: tool/lib/src/text.dart
  function toFileName (line 10) | String toFileName(String text)
  function longestLine (line 25) | int longestLine(int longest, Iterable<String> lines)
  function pluralize (line 32) | String pluralize<T>(Iterable<T> sequence)
  function trimTrailingNewline (line 70) | String trimTrailingNewline()