#include <compile.h>

Classes
struct	Local

struct	Parser

struct	ParseRule

Static Public Member Functions
static const char *	Intern (const std::string &str)

static bool	HadError ()

static bool	Compile (const char source, Chunk chunk)

static TClassInfo *	GetClassInfo (const char *classname)

template<typename TObj >
static void	Register ()

Private Types
enum	Precedence { PREC_NONE, PREC_ASSIGNMENT, PREC_OR, PREC_AND, PREC_EQUALITY, PREC_COMPARISON, PREC_TERM, PREC_FACTOR, PREC_UNARY, PREC_CALL, PREC_PRIMARY }

using	ParseFn = void(Compiler::*)(bool)

Private Member Functions
void	Declaration ()

void	Statement ()

void	Synchronize ()

void	Block ()

void	BeginScope ()

void	EndScope ()

void	VarDeclaration ()

uint8_t	IdentifierConstant (Token *token)

uint8_t	ParseVariable (const char *errorMessage)

void	DefineVariable (uint8_t global)

void	DeclareVariable ()

void	AddLocal (Token name)

int	ResolveLocal (Token *name)

void	MarkIntialized ()

void	FieldsStatement ()

void	PrintStatement ()

void	ExpressionStatement ()

void	IfStatement ()

void	WhileStatement ()

void	ForStatement ()

void	ReturnStatement ()

bool	Match (TokenType type)

bool	Check (TokenType type)

void	ErrorAt (Token &token, const char *message)

void	PatchJump (int offset)

int	EmitJump (uint8_t instruction)

void	EmitLoop (int loopStart)

void	EmitByte (uint8_t byte)

void	EmitBytes (uint8_t bytea, uint8_t byteb)

void	EmitReturn ()

void	EmitConstant (Value value)

uint8_t	MakeConstant (Value value)

void	Number (bool canAssign)

void	Grouping (bool canAssign)

void	Unary (bool canAssign)

void	Binary (bool canAssign)

void	Literal (bool canAssign)

void	String (bool canAssign)

void	Variable (bool canAssign)

void	And (bool canAssign)

void	Or (bool canAssign)

void	Call (bool canAssign)

void	Index (bool canAssign)

void	Dot (bool canAssign)

void	NamedVariable (Token token, bool canAssign)

void	ParsePrecedence (Precedence precedence)

ParseRule *	GetRule (TokenType type) const

uint8_t	ArgumentList ()

void	Advance ()

void	Expression ()

void	Consume (TokenType type, const char *message)

void	SetChunk (Chunk *chunk)

void	Finish ()

Chunk *	CurrentChunk ()

	Compiler ()

bool	DoCompile (const char _source, Chunk chunk)

const char *	DoIntern (const std::string &str)

void	DoRegister (const char *classname)

Static Private Member Functions
static Compiler &	Instance ()

Private Attributes
std::unordered_set< std::string >	strings

Parser	parser

Scanner	scanner

Chunk *	current

std::vector< Local >	locals

int	scopeDepth

TClassList	tclasslist

const char *	source

Detailed Description

Definition at line 13 of file compile.h.

Member Typedef Documentation

using uscript::Compiler::ParseFn = void (Compiler::*)(bool)

private

Definition at line 35 of file compile.h.

Member Enumeration Documentation

enum uscript::Compiler::Precedence

private

Enumerator
PREC_NONE
PREC_ASSIGNMENT
PREC_OR
PREC_AND
PREC_EQUALITY
PREC_COMPARISON
PREC_TERM
PREC_FACTOR
PREC_UNARY
PREC_CALL
PREC_PRIMARY

Definition at line 21 of file compile.h.

                   {
     PREC_NONE,
     PREC_ASSIGNMENT,  // =
     PREC_OR,          // or
     PREC_AND,         // and
     PREC_EQUALITY,    // == !=
     PREC_COMPARISON,  // < > <= >=
     PREC_TERM,        // + -
     PREC_FACTOR,      // * /
     PREC_UNARY,       // ! -
     PREC_CALL,        // . ()
     PREC_PRIMARY
   };

Constructor & Destructor Documentation

uscript::Compiler::Compiler ( )

private

Definition at line 29 of file compile.cc.

                           {
   parser.hadError = false;
   parser.panicMode = false;
   scopeDepth = 0;
 }

Member Function Documentation

void uscript::Compiler::AddLocal ( Token name )

private

Definition at line 108 of file compile.cc.

                                          {
   if (locals.size() > UINT8_MAX) {
     ErrorAt(parser.previous, "Too many local variables in one chunk.");
   }
   Local local;
   local.name = name;
   local.depth = -1;
   locals.push_back(local);
 }

void uscript::Compiler::Advance ( )

private

Definition at line 398 of file compile.cc.

                               {
   parser.previous = parser.current;
 
   while (1) {
     parser.current = scanner.ScanToken();
     if (parser.current.type != uscript::TOKEN_ERROR) break;
 
     ErrorAt(parser.current, parser.current.start);
   }
 }

void uscript::Compiler::And ( bool canAssign )

private

Definition at line 465 of file compile.cc.

                                         {
   int endJump = EmitJump(uscript::OP_JUMP_IF_FALSE);
 
   EmitByte(uscript::OP_POP);
 
   ParsePrecedence(PREC_AND);
 
   PatchJump(endJump);
 }

uint8_t uscript::Compiler::ArgumentList ( )

private

Definition at line 475 of file compile.cc.

                                       {
   uint8_t argCount = 0;
   if (!Check(uscript::TOKEN_RIGHT_PAREN)) {
     do {
       Expression();
       if (argCount == 255) {
         ErrorAt(parser.previous, "Cannot have more than 255 arguments.");
       }
       argCount++;
     } while (Match(uscript::TOKEN_COMMA));
   }
 
   Consume(uscript::TOKEN_RIGHT_PAREN, "Expect ')' after function arguments.");
   return argCount;
 }

void uscript::Compiler::BeginScope ( )

private

Definition at line 306 of file compile.cc.

                                  {
   scopeDepth ++;
 }

void uscript::Compiler::Binary ( bool canAssign )

private

Definition at line 575 of file compile.cc.

                                            {
   uscript::TokenType operatorType = parser.previous.type;
 
   uscript::Compiler::ParseRule *rule = GetRule(operatorType);
 
   ParsePrecedence((uscript::Compiler::Precedence) (rule->precedence + 1));
 
   switch (operatorType) {
     case uscript::TOKEN_PLUS:    EmitByte(uscript::OP_ADD); break;
     case uscript::TOKEN_MINUS:   EmitByte(uscript::OP_SUBTRACT); break;
     case uscript::TOKEN_STAR:    EmitByte(uscript::OP_MULTIPLY); break;
     case uscript::TOKEN_SLASH:   EmitByte(uscript::OP_DIVIDE); break;
     case uscript::TOKEN_BANG_EQUAL:    EmitBytes(uscript::OP_EQUAL, uscript::OP_NOT); break;
     case uscript::TOKEN_EQUAL_EQUAL:   EmitByte(uscript::OP_EQUAL); break;
     case uscript::TOKEN_GREATER:       EmitByte(uscript::OP_GREATER); break;
     case uscript::TOKEN_GREATER_EQUAL: EmitBytes(uscript::OP_LESS, uscript::OP_NOT); break;
     case uscript::TOKEN_LESS:          EmitByte(uscript::OP_LESS); break;
     case uscript::TOKEN_LESS_EQUAL:    EmitBytes(uscript::OP_GREATER, uscript::OP_NOT); break;
     default:
       return; // unreachable
   }
 }

void uscript::Compiler::Block ( )

private

Definition at line 299 of file compile.cc.

                             {
   while (!Check(uscript::TOKEN_RIGHT_BRACE) && !Check(uscript::TOKEN_EOF)) {
     Declaration();
   }
   Consume(uscript::TOKEN_RIGHT_BRACE, "Expect '}' after block.");
 }

void uscript::Compiler::Call ( bool canAssign )

private

Definition at line 504 of file compile.cc.

                                          {
   uint8_t argCount = ArgumentList();
   EmitBytes(uscript::OP_CALL, argCount);
 }

bool uscript::Compiler::Check ( uscript::TokenType type )

private

Definition at line 344 of file compile.cc.

                                                  {
   return parser.current.type == type;
 }

static bool uscript::Compiler::Compile	(	const char *	source,
		Chunk *	chunk
	)

inlinestatic

Definition at line 140 of file compile.h.

140 { return Instance().DoCompile(source, chunk); }

uscript::Compiler::DoCompile

bool DoCompile(const char *_source, Chunk *chunk)

Definition: compile.cc:8

uscript::Compiler::source

const char * source

Definition: compile.h:58

uscript::Compiler::Instance

static Compiler & Instance()

Definition: compile.h:132

void uscript::Compiler::Consume	(	uscript::TokenType	type,
		const char *	message
	)

private

Definition at line 409 of file compile.cc.

                                                                         {
   if (parser.current.type == type) {
     Advance();
     return;
   }
 
   ErrorAt(parser.current, message);
 }

Chunk* uscript::Compiler::CurrentChunk ( )

inlineprivate

Definition at line 124 of file compile.h.

124 { return current; }

uscript::Compiler::current

Chunk * current

Definition: compile.h:52

void uscript::Compiler::Declaration ( )

private

Definition at line 35 of file compile.cc.

                                   {
   if (Match(uscript::TOKEN_VAR)) {
     VarDeclaration();
   }
   else {
     Statement();
   }
 
   if (parser.panicMode) Synchronize();
 }

void uscript::Compiler::DeclareVariable ( )

private

Definition at line 91 of file compile.cc.

                                       {
   if (scopeDepth == 0) return; // global variables are implicitly declared
 
   Token name = parser.previous;
   // make sure the local isn't already there
   for (int i = locals.size()-1; i >= 0; i--) {
     if (locals[i].depth != -1 && locals[i].depth < scopeDepth) {
       break;
     }
     if (identifiersEqual(&locals[i].name, &name)) {
       ErrorAt(parser.previous, "Variable with this name already declared in this scope.");
     }
   }
 
   AddLocal(name);
 }

void uscript::Compiler::DefineVariable ( uint8_t global )

private

Definition at line 122 of file compile.cc.

                                                    {
   if (scopeDepth > 0) {
     MarkIntialized();
     return;
   }
   EmitBytes(uscript::OP_DEFINE_GLOBAL, global);
 }

bool uscript::Compiler::DoCompile	(	const char *	_source,
		Chunk *	chunk
	)

private

Definition at line 8 of file compile.cc.

                                                                  {
   parser.hadError = false;
   source = _source;
   scanner.SetSource(_source);
   chunk->source = source;
 
   SetChunk(chunk);
 
   Advance();
 
   while (!Match(uscript::TOKEN_EOF)) {
     Declaration();
   }
 
   Consume(uscript::TOKEN_EOF, "Expect end of expression.");
 
   Finish();
 
   return !parser.hadError;
 }

const char * uscript::Compiler::DoIntern ( const std::string & str )

private

Definition at line 673 of file compile.cc.

                                                           {
   auto ret = strings.insert(str);
   return ret.first->c_str();
 }

void uscript::Compiler::DoRegister ( const char * classname )

private

Definition at line 678 of file compile.cc.

                                                       {
   uscript::TClassInfo *ret = tclasslist.Add(classname);
   if (ret == NULL) {
     std::cerr << "Missing class definition for cpp class: " << classname << std::endl; 
   }
   assert(ret != NULL);
 }

void uscript::Compiler::Dot ( bool canAssign )

private

Definition at line 491 of file compile.cc.

                                         {
   Consume(uscript::TOKEN_IDENTIFIER, "Expect property name after '.'.");
   uint8_t name = IdentifierConstant(&parser.previous); 
 
   EmitBytes(uscript::OP_GET_PROPERTY, name);
 }

void uscript::Compiler::EmitByte ( uint8_t byte )

private

Definition at line 359 of file compile.cc.

                                            {
   CurrentChunk()->Write(byte);
 }

void uscript::Compiler::EmitBytes	(	uint8_t	bytea,
		uint8_t	byteb
	)

private

Definition at line 363 of file compile.cc.

                                                             {
   CurrentChunk()->Write(bytea);
   CurrentChunk()->Write(byteb);
 }

void uscript::Compiler::EmitConstant ( Value value )

private

Definition at line 434 of file compile.cc.

                                               {
   return EmitBytes(uscript::OP_CONSTANT, MakeConstant(value));
 }

int uscript::Compiler::EmitJump ( uint8_t instruction )

private

Definition at line 281 of file compile.cc.

                                                  {
   EmitByte(instruction);
   EmitByte(0xff);
   EmitByte(0xff);
   return CurrentChunk()->code.size() - 2;
 }

void uscript::Compiler::EmitLoop ( int loopStart )

private

Definition at line 348 of file compile.cc.

                                             {
   EmitByte(uscript::OP_LOOP);
 
   int offset = CurrentChunk()->code.size() - loopStart + 2;
 
   if (offset > UINT16_MAX) ErrorAt(parser.previous, "Loop body too large.");
 
   EmitByte((offset >> 8) & 0xff);
   EmitByte(offset & 0xff);
 }

void uscript::Compiler::EmitReturn ( )

private

Definition at line 430 of file compile.cc.

                                  {
   return EmitByte(uscript::OP_RETURN);
 }

void uscript::Compiler::EndScope ( )

private

Definition at line 310 of file compile.cc.

                                {
   scopeDepth --;
 
   while (locals.size() > 0 && locals[locals.size()-1].depth > scopeDepth) {
     EmitByte(uscript::OP_POP);
     locals.pop_back();
   } 
 
 }

void uscript::Compiler::ErrorAt	(	uscript::Token &	token,
		const char *	message
	)

private

Definition at line 386 of file compile.cc.

                                                                       {
   if (parser.panicMode) return;
 
   parser.hadError = true;
   parser.panicMode = true;
   PrintErrorAt(token, message, source);
 }

void uscript::Compiler::Expression ( )

private

Definition at line 394 of file compile.cc.

                                  {
   ParsePrecedence(uscript::Compiler::PREC_ASSIGNMENT);
 }

void uscript::Compiler::ExpressionStatement ( )

private

Definition at line 332 of file compile.cc.

                                           {
   Expression();
   Consume(uscript::TOKEN_SEMICOLON, "Expect ';' after value.");
   EmitByte(uscript::OP_POP);
 }

void uscript::Compiler::FieldsStatement ( )

private

Definition at line 320 of file compile.cc.

                                       {
   Expression();
   Consume(uscript::TOKEN_SEMICOLON, "Expect ';' after value.");
   EmitByte(uscript::OP_FIELDS);
 }

void uscript::Compiler::Finish ( )

private

Definition at line 418 of file compile.cc.

                              {
   if (CurrentChunk()->code.size() == 0 || CurrentChunk()->code[CurrentChunk()->code.size()-1] != uscript::OP_RETURN) {
     EmitConstant(NIL_VAL);
     EmitReturn();
   }
 #ifdef DEBUG_PRINT_CODE
   if (!parser.hadError) {
     CurrentChunk()->Disassemble("code");
   }
 #endif
 }

void uscript::Compiler::ForStatement ( )

private

Definition at line 201 of file compile.cc.

                                    {
   BeginScope();
 
   Consume(uscript::TOKEN_LEFT_PAREN, "Expect '(' after 'for'.");
   if (Match(uscript::TOKEN_SEMICOLON)) {
     // no initializer
   }
   else if (Match(uscript::TOKEN_VAR)) {
     VarDeclaration();
   }
   else {
     ExpressionStatement();
   }
 
   int loopStart = CurrentChunk()->code.size();
 
   int exitJump = -1;
   if (!Match(uscript::TOKEN_SEMICOLON)) {
     Expression();
     Consume(uscript::TOKEN_SEMICOLON, "Expect ';' after loop condition.");
     exitJump = EmitJump(uscript::OP_JUMP_IF_FALSE);
     EmitByte(uscript::OP_POP);
   }
 
   if (!Match(uscript::TOKEN_RIGHT_PAREN)) {
     int bodyJump = EmitJump(uscript::OP_JUMP);
     int incrementStart = CurrentChunk()->code.size();
 
     Expression();
     EmitByte(uscript::OP_POP);
 
     Consume(uscript::TOKEN_RIGHT_PAREN, "Expect ')' after for clause.");
 
     EmitLoop(loopStart);
     loopStart = incrementStart;
     PatchJump(bodyJump);
     
   }
 
   // body of for loop
   Statement();
 
   EmitLoop(loopStart);
 
   if (exitJump != -1) {
     PatchJump(exitJump);
     EmitByte(uscript::OP_POP);
   }
   
   EndScope();
 }

static TClassInfo* uscript::Compiler::GetClassInfo ( const char * classname )

inlinestatic

Definition at line 142 of file compile.h.

                                                          {
     return Instance().tclasslist.Add(classname);
   }

uscript::Compiler::ParseRule * uscript::Compiler::GetRule ( uscript::TokenType type ) const

private

Definition at line 621 of file compile.cc.

                                                                               {
   static ParseRule rules[] = {
     { &uscript::Compiler::Grouping, &uscript::Compiler::Call,    uscript::Compiler::PREC_CALL },       // TOKEN_LEFT_PAREN
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_RIGHT_PAREN
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_LEFT_BRACE
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_RIGHT_BRACE
     { NULL,     &uscript::Compiler::Index, uscript::Compiler::PREC_CALL }, // TOKEN_LEFT_BRACKET
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_RIGHT_BRACKET
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_COMMA
     { NULL,     &uscript::Compiler::Dot,    uscript::Compiler::PREC_CALL },       // TOKEN_DOT
     { &uscript::Compiler::Unary,    &uscript::Compiler::Binary,  uscript::Compiler::PREC_TERM },       // TOKEN_MINUS
     { NULL,     &uscript::Compiler::Binary,  uscript::Compiler::PREC_TERM },       // TOKEN_PLUS
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_SEMICOLON
     { NULL,     &uscript::Compiler::Binary,  uscript::Compiler::PREC_FACTOR },     // TOKEN_SLASH
     { NULL,     &uscript::Compiler::Binary,  uscript::Compiler::PREC_FACTOR },     // TOKEN_STAR
     { &uscript::Compiler::Unary,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_BANG
     { NULL,     &uscript::Compiler::Binary,    uscript::Compiler::PREC_EQUALITY },       // TOKEN_BANG_EQUAL
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_EQUAL
     { NULL,     &uscript::Compiler::Binary,    uscript::Compiler::PREC_EQUALITY },       // TOKEN_EQUAL_EQUAL
     { NULL,     &uscript::Compiler::Binary,    uscript::Compiler::PREC_COMPARISON },       // TOKEN_GREATER
     { NULL,     &uscript::Compiler::Binary,    uscript::Compiler::PREC_COMPARISON },       // TOKEN_GREATER_EQUAL
     { NULL,     &uscript::Compiler::Binary,    uscript::Compiler::PREC_COMPARISON },       // TOKEN_LESS
     { NULL,     &uscript::Compiler::Binary,    uscript::Compiler::PREC_COMPARISON },       // TOKEN_LESS_EQUAL
     { &uscript::Compiler::Variable,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_IDENTIFIER
     { &uscript::Compiler::String,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_STRING
     { &uscript::Compiler::Number,   NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_NUMBER
     { NULL,     &uscript::Compiler::And,    uscript::Compiler::PREC_AND },       // TOKEN_AND
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_CLASS
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_ELSE
     { &uscript::Compiler::Literal,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_FALSE
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_FOR
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_FUN
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_IF
     { &uscript::Compiler::Literal,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_NIL
     { NULL,     &uscript::Compiler::Or,    uscript::Compiler::PREC_OR },       // TOKEN_OR
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_PRINT
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_RETURN
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_SUPER
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_THIS
     { &uscript::Compiler::Literal,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_TRUE
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_VAR
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_WHILE
     { &uscript::Compiler::Unary,     NULL, uscript::Compiler::PREC_NONE }, // TOKEN LENGTH
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_FIELDS
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_ERROR
     { NULL,     NULL,    uscript::Compiler::PREC_NONE },       // TOKEN_EOF
   };
 
   return &rules[type];
 
 }

void uscript::Compiler::Grouping ( bool canAssign )

private

Definition at line 460 of file compile.cc.

                                              {
   Expression();
   Consume(uscript::TOKEN_RIGHT_PAREN, "Expect ')' after expression.");
 }

static bool uscript::Compiler::HadError ( )

inlinestatic

Definition at line 139 of file compile.h.

139 { return Instance().parser.hadError; }

uscript::Compiler::Parser::hadError

bool hadError

Definition: compile.h:17

uscript::Compiler::Instance

static Compiler & Instance()

Definition: compile.h:132

uscript::Compiler::parser

Parser parser

Definition: compile.h:50

uint8_t uscript::Compiler::IdentifierConstant ( uscript::Token * token )

private

Definition at line 61 of file compile.cc.

                                                                {
   std::string str(token->start, token->start + token->length);
   const char *interned = DoIntern(str);
   return MakeConstant(STRING_VAL(interned));
 }

void uscript::Compiler::IfStatement ( )

private

Definition at line 266 of file compile.cc.

                                   {
   Consume(uscript::TOKEN_LEFT_PAREN, "Expect '(' after if.");
   Expression();
   Consume(uscript::TOKEN_RIGHT_PAREN, "Expect ')' after condition.");
 
   int thenJump = EmitJump(uscript::OP_JUMP_IF_FALSE);
   EmitByte(uscript::OP_POP);
   Statement();
   PatchJump(thenJump);
 
   int elseJump = EmitJump(uscript::OP_JUMP);
   if (Match(uscript::TOKEN_ELSE)) Statement();
   PatchJump(elseJump);
 }

void uscript::Compiler::Index ( bool canAssign )

private

Definition at line 498 of file compile.cc.

                                           {
   Expression();
   Consume(uscript::TOKEN_RIGHT_BRACKET, "Expect ']' to close index."); 
   EmitByte(uscript::OP_INDEX);
 }

static Compiler& uscript::Compiler::Instance ( )

inlinestaticprivate

Definition at line 132 of file compile.h.

                               {
     static Compiler c;
     return c;
   }

static const char* uscript::Compiler::Intern ( const std::string & str )

inlinestatic

Definition at line 138 of file compile.h.

138 { return Instance().DoIntern(str); }

uscript::Compiler::DoIntern

const char * DoIntern(const std::string &str)

Definition: compile.cc:673

uscript::Compiler::Instance

static Compiler & Instance()

Definition: compile.h:132

void uscript::Compiler::Literal ( bool canAssign )

private

Definition at line 534 of file compile.cc.

                                             {
   switch (parser.previous.type) {
     case uscript::TOKEN_FALSE: EmitByte(uscript::OP_FALSE); break;
     case uscript::TOKEN_TRUE: EmitByte(uscript::OP_TRUE); break;
     case uscript::TOKEN_NIL: EmitByte(uscript::OP_NIL); break;
     default:
       return; //unreachable
   }
 }

uint8_t uscript::Compiler::MakeConstant ( Value value )

private

Definition at line 438 of file compile.cc.

                                                  {
   int constant = CurrentChunk()->AddConstant(value);
   if (constant > UINT8_MAX) {
     ErrorAt(parser.previous, "Too many constants in one chunk.");
     return 0;
   }
   return constant;
 }

void uscript::Compiler::MarkIntialized ( )

private

Definition at line 118 of file compile.cc.

                                      {
   locals[locals.size() -1].depth = scopeDepth;
 }

bool uscript::Compiler::Match ( uscript::TokenType type )

private

Definition at line 338 of file compile.cc.

                                                  {
   if (!Check(type)) return false;
   Advance();
   return true;
 }

void uscript::Compiler::NamedVariable	(	uscript::Token	name,
		bool	canAssign
	)

private

Definition at line 553 of file compile.cc.

                                                                      {
   uint8_t getOp, setOp;
   int arg = ResolveLocal(&name);
   if (arg != -1) {
     getOp = OP_GET_LOCAL;
     setOp = OP_SET_LOCAL;
   } 
   else {
     arg = IdentifierConstant(&name);
     getOp = OP_GET_GLOBAL;
     setOp = OP_SET_GLOBAL;
   }
 
   if (canAssign && Match(uscript::TOKEN_EQUAL)) {
     Expression();
     EmitBytes(setOp, (uint8_t)arg);
   }
   else {
     EmitBytes(getOp, (uint8_t)arg);
   }
 }

void uscript::Compiler::Number ( bool canAssign )

private

Definition at line 447 of file compile.cc.

                                            {
   // try to see if we can convert to integer
   char *end;
   int v_int = strtol(parser.previous.start, &end, 10 /* base 10*/);
   if (end == parser.previous.start + parser.previous.length) {
     return EmitConstant(INTEGER_VAL(v_int));
   }
   else {
     double value = strtod(parser.previous.start, NULL);
     EmitConstant(NUMBER_VAL(value));
   }
 }

void uscript::Compiler::Or ( bool canAssign )

private

Definition at line 509 of file compile.cc.

                                        {
   int elseJump = EmitJump(uscript::OP_JUMP_IF_FALSE);
   int endJump =  EmitJump(uscript::OP_JUMP);
 
   PatchJump(elseJump);
   EmitByte(uscript::OP_POP);
 
   ParsePrecedence(PREC_OR);
   PatchJump(endJump);
 }

void uscript::Compiler::ParsePrecedence ( Precedence precedence )

private

Definition at line 598 of file compile.cc.

                                                                           {
   Advance();
 
   ParseFn prefixRule = GetRule(parser.previous.type)->prefix;
   if (prefixRule == NULL) {
     ErrorAt(parser.previous, "Expect expression.");
     return;
   }
   
   bool canAssign = precedence <= uscript::Compiler::PREC_ASSIGNMENT;
   (*this.*prefixRule)(canAssign);
 
   while (precedence <= GetRule(parser.current.type)->precedence) {
     Advance();
     ParseFn infixRule = GetRule(parser.previous.type)->infix;
     (*this.*infixRule)(canAssign);
   }
 
   if (canAssign && Match(uscript::TOKEN_EQUAL)) {
     ErrorAt(parser.previous, "Invalid assignmnet target.");
   }
 }

uint8_t uscript::Compiler::ParseVariable ( const char * errorMessage )

private

Definition at line 67 of file compile.cc.

                                                                {
   Consume(uscript::TOKEN_IDENTIFIER, errorMessage);
   DeclareVariable();
   if (scopeDepth > 0) return 0; // local variable 
   return IdentifierConstant(&parser.previous); // global variable
 }

void uscript::Compiler::PatchJump ( int offset )

private

Definition at line 288 of file compile.cc.

                                           {
   int jump = CurrentChunk()->code.size() - offset - 2;
 
   if (jump > UINT16_MAX) {
     ErrorAt(parser.previous, "Too much code to jump over.");
   }
 
   CurrentChunk()->code[offset] = (jump >> 8) & 0xff; 
   CurrentChunk()->code[offset + 1] = jump & 0xff;
 }

void uscript::Compiler::PrintStatement ( )

private

Definition at line 326 of file compile.cc.

                                      {
   Expression();
   Consume(uscript::TOKEN_SEMICOLON, "Expect ';' after value.");
   EmitByte(uscript::OP_PRINT);
 }

template<typename TObj >

static void uscript::Compiler::Register ( )

inlinestatic

Definition at line 147 of file compile.h.

                                 {
     Instance().DoRegister(std::string(type_name<TObj>()).c_str());
   }

int uscript::Compiler::ResolveLocal ( Token * name )

private

Definition at line 79 of file compile.cc.

                                              {
   for (int i = locals.size() -1; i >= 0; i--) {
     if (identifiersEqual(name, &locals[i].name)) {
       if (locals[i].depth == -1) {
         ErrorAt(parser.previous, "Cannot read from local variable in its own initializer.");
       }
       return i;
     }
   } 
   return -1;
 }

void uscript::Compiler::ReturnStatement ( )

private

Definition at line 253 of file compile.cc.

                                       {
   if (Match(uscript::TOKEN_SEMICOLON)) {
     EmitConstant(NIL_VAL);
     EmitByte(uscript::OP_RETURN);
     return;
   } 
   Expression();
 
   Consume(uscript::TOKEN_SEMICOLON, "Expect ';' after return.");
   EmitByte(uscript::OP_RETURN);
   return;
 }

void uscript::Compiler::SetChunk ( Chunk * chunk )

inlineprivate

Definition at line 122 of file compile.h.

122 { current = chunk; }

uscript::Compiler::current

Chunk * current

Definition: compile.h:52

void uscript::Compiler::Statement ( )

private

Definition at line 154 of file compile.cc.

                                 {
   if (Match(uscript::TOKEN_PRINT)) {
     PrintStatement();
   }
   else if (Match(uscript::TOKEN_FIELDS)) {
     FieldsStatement();
   }
   else if (Match(uscript::TOKEN_IF)) {
     IfStatement();
   }
   else if (Match(uscript::TOKEN_WHILE)) {
     WhileStatement();
   }
   else if (Match(uscript::TOKEN_FOR)) {
     ForStatement();
   }
   else if (Match(uscript::TOKEN_RETURN)) {
     ReturnStatement();
   }
   else if (Match(uscript::TOKEN_LEFT_BRACE)) {
     BeginScope();
     Block();
     EndScope();
   }
   else {
     ExpressionStatement();
   }
 }

void uscript::Compiler::String ( bool canAssign )

private

Definition at line 544 of file compile.cc.

                                            {
   std::string str(parser.previous.start+1, parser.previous.start + parser.previous.length - 1);
   EmitConstant(STRING_VAL(DoIntern(str)));
 }

void uscript::Compiler::Synchronize ( )

private

Definition at line 131 of file compile.cc.

                                   {
   parser.panicMode = false;
 
   while (parser.current.type != TOKEN_EOF) {
     if (parser.previous.type == TOKEN_SEMICOLON) return;
 
     switch (parser.current.type) {
       case TOKEN_CLASS:
       case TOKEN_FUN:
       case TOKEN_VAR:
       case TOKEN_FOR:
       case TOKEN_IF:
       case TOKEN_WHILE:
       case TOKEN_PRINT:
       case TOKEN_RETURN:
         return;
       default:
         break;
     }
     Advance();
   }
 }

void uscript::Compiler::Unary ( bool canAssign )

private

Definition at line 520 of file compile.cc.

                                           {
   uscript::TokenType operatorType = parser.previous.type;
 
   // compile the operand
   ParsePrecedence(uscript::Compiler::PREC_UNARY);
 
   switch (operatorType) {
     case uscript::TOKEN_BANG: EmitByte(uscript::OP_NOT); break;
     case uscript::TOKEN_MINUS: EmitByte(uscript::OP_NEGATE); break;
     case uscript::TOKEN_LENGTH: EmitByte(uscript::OP_LENGTH); break;
     default: return; // unreachable
   }
 }

void uscript::Compiler::VarDeclaration ( )

private

Definition at line 46 of file compile.cc.

                                      {
   uint8_t global = ParseVariable("Expect variable name.");
 
   if (Match(uscript::TOKEN_EQUAL)) {
     Expression();
   }
   else {
     EmitByte(uscript::OP_NIL);
   }
 
   Consume(uscript::TOKEN_SEMICOLON, "Expect ';' after declaration");
 
   DefineVariable(global);
 }

void uscript::Compiler::Variable ( bool canAssign )

private

Definition at line 549 of file compile.cc.

                                              {
   NamedVariable(parser.previous, canAssign);
 }

void uscript::Compiler::WhileStatement ( )

private

Definition at line 183 of file compile.cc.

                                      {
   int loopStart = CurrentChunk()->code.size();
 
   Consume(uscript::TOKEN_LEFT_PAREN, "Expect '(' after while.");
   Expression();
   Consume(uscript::TOKEN_RIGHT_PAREN, "Expect ')' after condition.");
 
   int exitJump = EmitJump(uscript::OP_JUMP_IF_FALSE);
 
   EmitByte(uscript::OP_POP);
   Statement();
 
   PatchJump(exitJump);
   EmitByte(uscript::OP_POP);
 
   EmitLoop(loopStart);
 }

Member Data Documentation

Chunk* uscript::Compiler::current

private

Definition at line 52 of file compile.h.

std::vector<Local> uscript::Compiler::locals

private

Definition at line 53 of file compile.h.

Parser uscript::Compiler::parser

private

Definition at line 50 of file compile.h.

Scanner uscript::Compiler::scanner

private

Definition at line 51 of file compile.h.

int uscript::Compiler::scopeDepth

private

Definition at line 54 of file compile.h.

const char* uscript::Compiler::source

private

Definition at line 58 of file compile.h.

std::unordered_set<std::string> uscript::Compiler::strings

private

Definition at line 49 of file compile.h.

TClassList uscript::Compiler::tclasslist

private

Definition at line 56 of file compile.h.

The documentation for this class was generated from the following files:

Classes

Static Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation