Merge pull request #28 from callisto-lang/SafeStack

add unsafe block

Author: MESYETI

source/compiler.d

@@ -483,6 +483,11 @@ class Compiler {
 			case NodeType.Implement: backend.CompileImplement(cast(ImplementNode) inode); break;
 			case NodeType.Set:       backend.CompileSet(cast(SetNode) inode); break;
 			case NodeType.TryCatch:  backend.CompileTryCatch(cast(TryCatchNode) inode); break;
+			case NodeType.Unsafe: {
+				auto node = cast(UnsafeNode) inode;
+				Compile(node.nodes);
+				break;
+			}
 			default: {
 				backend.Error(inode.error, "Unimplemented node '%s'", inode.type);
 			}

source/parser.d

@@ -33,7 +33,8 @@ enum NodeType {
 	Addr,
 	Implement,
 	Set,
-	TryCatch
+	TryCatch,
+	Unsafe
 }
 
 class Node {
@@ -521,6 +522,27 @@ class TryCatchNode : Node {
 	}
 }
 
+class UnsafeNode : Node {
+	string[] paramTypes;
+	string[] retTypes;
+	Node[]   nodes;
+
+	this(ErrorInfo perror) {
+		type  = NodeType.Unsafe;
+		error = perror;
+	}
+
+	override string toString() {
+		string ret = format("unsafe %d -> %d", paramTypes.length, retTypes.length);
+
+		foreach (ref node ; nodes) {
+			ret ~= node.toString() ~ '\n';
+		}
+
+		return ret ~ "end";
+	}
+}
+
 class ParserError : Exception {
 	this() {
 		super("", "", 0);
@@ -1228,6 +1250,47 @@ class Parser {
 		return ret;
 	}
 
+	Node ParseUnsafe() {
+		auto ret = new UnsafeNode(GetError());
+		parsing  = NodeType.Unsafe;
+
+		Next();
+
+		while (!IsIdentifier("begin") && !IsIdentifier("->")) {
+			Expect(TokenType.Identifier);
+			ret.paramTypes ~= tokens[i].contents;
+			Next();
+			Expect(TokenType.Identifier);
+			Next();
+		}
+
+		if (IsIdentifier("->")) {
+			Next();
+
+			while (!IsIdentifier("begin")) {
+				Expect(TokenType.Identifier);
+				ret.retTypes ~= tokens[i].contents; // return type
+
+				Next();
+				Expect(TokenType.Identifier); // return name, ignored
+
+				if (tokens[i].contents == "begin") {
+					Error("Begin in return name");
+				}
+				Next();
+			}
+		}
+
+		Next();
+
+		while (!IsIdentifier("end")) {
+			ret.nodes ~= ParseStatement();
+			Next();
+		}
+
+		return ret;
+	}
+
 	Node ParseStatement() {
 		switch (tokens[i].type) {
 			case TokenType.Integer: {
@@ -1255,6 +1318,7 @@ class Parser {
 					case "implement":  return ParseImplement();
 					case "try":        return ParseTryCatch();
 					case "->":         return ParseSet();
+					case "unsafe":     return ParseUnsafe();
 					default: return new WordNode(GetError(), tokens[i].contents);
 				}
 			}

source/stackCheck.d

@@ -373,6 +373,11 @@ class StackChecker {
 		}
 	}
 
+	void EvaluateUnsafe(UnsafeNode node) {
+		Pop(node, node.paramTypes.length);
+		Push(node, node.retTypes.length);
+	}
+
 	void EvaluateNode(Node node) {
 		switch (node.type) {
 			case NodeType.Word: {
@@ -407,6 +412,7 @@ class StackChecker {
 			case NodeType.Set:       Pop(node, 1); break;
 			case NodeType.TryCatch:  EvaluateTryCatch(cast(TryCatchNode) node); break;
 			case NodeType.Struct:    EvaluateStruct(cast(StructNode) node); break;
+			case NodeType.Unsafe:    EvaluateUnsafe(cast(UnsafeNode) node); break;
 			default: break;
 		}
 	}