botc: comparison parser.cxx

-:e4bbd540663b
+:07b7ab8080cf
 // and writes the data to the object file via ObjWriter - which also takes care
 // of necessary buffering so stuff is written in the correct order.
 void ScriptReader::BeginParse (ObjWriter* w) {
 	g_BlockStackCursor = 0;
 	while (Next()) {
-		printf ("BeginParse: token: `%s`\n", token.chars());
 		if (!token.icompare ("state")) {
 			MUST_TOPLEVEL
 			MustString ();
 			// Read the expression and write it.
 			MustNext ();
 			DataBuffer* c = ParseExpression (TYPE_INT);
 			w->WriteBuffer (c);
-			delete c;
 			MustNext (")");
 			MustNext ("{");
 			// Add a mark - to here temporarily - and add a reference to it.
 			// we just defined - and this mark will be at the end of the block.
 			w->Write<word> (DH_IFNOTGOTO);
 			w->AddReference (marknum);
 			// Store it in the block stack
+			g_BlockStackCursor++;
 			blockstack[g_BlockStackCursor] = marknum;
-			g_BlockStackCursor++;
 			continue;
 		}
 		if (!token.compare ("}")) {
 			// Closing brace
 			// If we're in the block stack, we're descending down from it now
 			if (g_BlockStackCursor > 0) {
 				// Adjust its closing mark so that it's here.
 				unsigned int marknum = blockstack[g_BlockStackCursor];
-				if (marknum != MAX_MARKS) {
+				if (marknum != MAX_MARKS)
-					// printf ("\tblock %d stack mark moved from %d ",
-						g_BlockStackCursor, w->GetCurrentBuffer()->marks[marknum]->pos);
 					w->MoveMark (marknum);
-					// printf ("to %d\n", w->GetCurrentBuffer()->marks[marknum]->pos);
+				w->AddMark (MARKTYPE_INTERNAL, "");
-				}
 				g_BlockStackCursor--;
 				continue;
 			}
 			int dataheader =	(g_CurMode == MODE_EVENT) ? DH_ENDEVENT :
 		}
 		// If it's a variable, expect assignment.
 		if (ScriptVar* var = FindGlobalVariable (token)) {
 			DataBuffer* b = ParseAssignment (var);
-			printf ("current token after assignment: `%s`\n", token.chars());
 			MustNext (";");
 			w->WriteBuffer (b);
-			delete b;
 			continue;
 		}
 		// If it's not a keyword, parse it as an expression.
-		printf ("token length: %d, first char: %c [%d]\n", token.len(), token.chars()[0], token.chars()[0]);
 		DataBuffer* b = ParseExpression (TYPE_VOID);
 		w->WriteBuffer (b);
-		delete b;
-		printf ("expression done! current token is %s\n", token.chars());
 		MustNext (";");
 	}
 	if (g_CurMode != MODE_TOPLEVEL)
 		ParserError ("script did not end at top level; did you forget a `}`?");
 DataBuffer* ScriptReader::ParseCommand (CommandDef* comm) {
 	DataBuffer* r = new DataBuffer(64);
 	if (g_CurMode == MODE_TOPLEVEL)
 		ParserError ("command call at top level");
-	printf ("\n\n\n=====================================\nBEGIN PARSING COMMAND\n");
-	printf ("token: %s\n", token.chars());
 	MustNext ("(");
 	MustNext ();
 	int curarg = 0;
 	while (1) {
-		printf ("at argument %d\n", curarg);
-		printf ("next token: %s\n", token.chars());
 		if (!token.compare (")")) {
-			printf ("closing command with token `%s`\n", token.chars());
 			if (curarg < comm->numargs - 1)
 				ParserError ("too few arguments passed to %s\n", comm->name.chars());
 			break;
 			curarg++;
 		}
 		if (curarg >= comm->maxargs)
 			ParserError ("too many arguments passed to %s\n", comm->name.chars());
 		r->Merge (ParseExpression (comm->argtypes[curarg]));
 		MustNext ();
-		printf ("after expression, token is `%s`\n", token.chars());
 		if (curarg < comm->numargs - 1) {
 			MustThis (",");
 			MustNext ();
 		} else if (curarg < comm->maxargs - 1) {
 	r->Write<word> (DH_COMMAND);
 	r->Write<word> (comm->number);
 	r->Write<word> (comm->maxargs);
-	printf ("command complete\n");
 	return r;
 }
 // ============================================================================
 // Is the given operator an assignment operator?
 }
 // ============================================================================
 // Parses an expression, potentially recursively
 DataBuffer* ScriptReader::ParseExpression (int reqtype) {
-	printf ("begin parsing expression. this token is `%s`, next token is `%s`\n",
-		token.chars(), PeekNext().chars());
 	DataBuffer* retbuf = new DataBuffer (64);
 	DataBuffer* lb = NULL;
 	lb = ParseExprValue (reqtype);
-	printf ("done\n");
 	// Get an operator
-	printf ("parse operator at token %s\n", token.chars());
 	int oper = ParseOperator (true);
-	printf ("operator parsed: token is now %s\n", token.chars());
-	printf ("got %d\n", oper);
 	// No operator found - stop here.
 	if (oper == -1) {
 		retbuf->Merge (lb);
-		printf ("expression complete without operator, stopping at `%s`\n", token.chars());
 		return retbuf;
 	}
 	// We peeked the operator, move forward now
 	MustNext();
 	// Can't be an assignement operator, those belong in assignments.
 	if (IsAssignmentOperator (oper))
 		ParserError ("assignment operator inside expressions");
 	// Parse the right operand,
-	printf ("parse right operand\n");
 	MustNext ();
 	DataBuffer* rb = ParseExprValue (reqtype);
-	printf ("done\n");
 	retbuf->Merge (rb);
 	retbuf->Merge (lb);
 	long dh = DataHeaderByOperator (NULL, oper);
 	retbuf->Write<word> (dh);
-	printf ("expression complete\n");
 	return retbuf;
 }
 // ============================================================================
-// Parses an operator string. Returns the operator number code.
+// `arses an operator string. Returns the operator number code.
 int ScriptReader::ParseOperator (bool peek) {
 	str oper;
 	if (peek)
 		oper += PeekNext ();
 	else
 		oper += token;
 	// Check one-char operators
 	bool equalsnext = !PeekNext (peek ? 1 : 0).compare ("=");
-	printf ("operator one-char: %s\nequals is%s next (`%s`)\n", oper.chars(),
-		(equalsnext) ? "" : " not", PeekNext (peek ? 1 : 0).chars());
 	int o =	(!oper.compare ("=") && !equalsnext) ? OPER_ASSIGN :
 		(!oper.compare (">") && !equalsnext) ? OPER_GREATERTHAN :
 		(!oper.compare ("<") && !equalsnext) ? OPER_LESSTHAN :
 		!oper.compare ("+") ? OPER_ADD :
 		!oper.compare ("-") ? OPER_SUBTRACT :
 		return o;
 	}
 	// Two-char operators
 	oper += PeekNext (peek ? 1 : 0);
-	printf ("operator two-char: %s\n", oper.chars());
 	o =	!oper.compare ("+=") ? OPER_ASSIGNADD :
 		!oper.compare ("-=") ? OPER_ASSIGNSUB :
 		!oper.compare ("*=") ? OPER_ASSIGNMUL :
 		!oper.compare ("/=") ? OPER_ASSIGNDIV :
 // ============================================================================
 // Parses a value in the expression and returns the data needed to push
 // it, contained in a data buffer. A value can be either a variable, a command,
 // a literal or an expression.
 DataBuffer* ScriptReader::ParseExprValue (int reqtype) {
-	printf ("parse expr value `%s` with requirement type %d\n", token.chars(), reqtype);
 	DataBuffer* b = new DataBuffer(16);
 	ScriptVar* g;
 	if (!token.compare ("(")) {
-		printf ("value is an expression\n");
 		// Expression
 		MustNext ();
 		DataBuffer* c = ParseExpression (reqtype);
 		b->Merge (c);
 		MustNext (")");
 	} else if (CommandDef* comm = FindCommand (token)) {
-		printf ("value is a command\n");
 		delete b;
 		// Command
 		if (reqtype && comm->returnvalue != reqtype)
 			ParserError ("%s returns an incompatible data type", comm->name.chars());
 		b = ParseCommand (comm);
 	} else if ((g = FindGlobalVariable (token)) && reqtype != TYPE_STRING) {
-		printf ("value is a global var\n");
 		// Global variable
 		b->Write<word> (DH_PUSHGLOBALVAR);
 		b->Write<word> (g->index);
 	} else {
-		printf ("value is a literal\n");
 		// If nothing else, check for literal
 		switch (reqtype) {
 		case TYPE_VOID:
 			ParserError ("bad syntax");
 			break;
 		}
 		case TYPE_STRING:
 			// PushToStringTable either returns the string index of the
 			// string if it finds it in the table, or writes it to the
 			// table and returns it index if it doesn't find it there.
-			printf ("value is a string literal\n");
 			MustString (true);
 			b->Write<word> (DH_PUSHSTRINGINDEX);
 			b->Write<word> (PushToStringTable (token.chars()));
 			break;
 		}
 	}
-	printf ("value parsed: current token is `%s`\n", token.chars());
 	return b;
 }
 // ============================================================================

Mercurial > botc / file comparison

comparison: parser.cxx

parser.cxx