Adapt nyan to new specification

nyan/ast.cpp

@@ -1,4 +1,4 @@
-// Copyright 2016-2019 the nyan authors, LGPLv3+. See copying.md for legal info.
+// Copyright 2016-2020 the nyan authors, LGPLv3+. See copying.md for legal info.
 
 #include "ast.h"
 
@@ -61,6 +61,11 @@ std::string ASTBase::str() const {
 }
 
 
+const std::vector<ASTArgument> &AST::get_args() const {
+	return this->args;
+}
+
+
 const std::vector<ASTObject> &AST::get_objects() const {
 	return this->objects;
 }
@@ -72,9 +77,27 @@ const std::vector<ASTImport> &AST::get_imports() const {
 
 
 AST::AST(TokenStream &tokens) {
+	auto token = tokens.next();
+
+	// Ensure that AST has version argument
+	if (token->type == token_type::BANG) {
+		this->args.emplace_back(tokens);
+
+		if (this->args.front().get_arg().str() != "version") {
+			throw InternalError{"file must start with 'version' argument, not "
+								+ this->args.front().get_arg().str()};
+		}
+	}
+	else {
+		throw InternalError{"missing starting argument: version"};
+	}
+
 	while (tokens.full()) {
-		auto token = tokens.next();
-		if (token->type == token_type::IMPORT) {
+		token = tokens.next();
+		if (token->type == token_type::BANG) {
+			this->args.emplace_back(tokens);
+		}
+		else if (token->type == token_type::IMPORT) {
 			this->imports.emplace_back(tokens);
 		}
 		else if (token->type == token_type::ID) {
@@ -96,6 +119,37 @@ AST::AST(TokenStream &tokens) {
 }
 
 
+ASTArgument::ASTArgument(TokenStream &tokens) {
+	auto token = tokens.next();
+
+	if (token->type == token_type::ID) {
+		this->arg = IDToken{*token, tokens};
+		token = tokens.next();
+	} else {
+		throw ASTError("expected argument keyword, encountered", *token);
+	}
+
+	while (not token->is_endmarker()) {
+		if (token->is_content()) {
+			this->params.emplace_back(*token, tokens);
+			token = tokens.next();
+		} else {
+			throw ASTError("expected parameter value, encountered", *token);
+		}
+	}
+}
+
+
+const IDToken &ASTArgument::get_arg() const {
+	return this->arg;
+}
+
+
+const std::vector<IDToken> &ASTArgument::get_params() const {
+	return this->params;
+}
+
+
 ASTImport::ASTImport(TokenStream &tokens) {
 	auto token = tokens.next();
 
@@ -448,33 +502,30 @@ ASTMember::ASTMember(const Token &name,
 ASTMemberType::ASTMemberType()
 	:
 	does_exist{false},
-	has_payload{false} {}
+	has_args{false} {}
 
 
 ASTMemberType::ASTMemberType(const Token &name,
                              TokenStream &tokens)
 	:
 	does_exist{true},
-	has_payload{false} {
+	has_args{false} {
 
 	this->name = IDToken{name, tokens};
 
-	// now there may follow a type payload, e.g. set(payloadtype)
+	// now there may follow type arguments, e.g. set(arg, key=val)
 	auto token = tokens.next();
 	if (token->type == token_type::LPAREN) {
-		token = tokens.next();
-		if (token->type == token_type::ID) {
-			this->payload = IDToken{*token, tokens};
-			this->has_payload = true;
-		}
-		else {
-			throw ASTError("expected type identifier, but got", *token);
-		}
-
-		token = tokens.next();
-
-		if (token->type != token_type::RPAREN) {
-			throw ASTError("expected closing parens, but encountered", *token);
+		comma_list(
+			token_type::RPAREN,
+			tokens,
+			[this] (const Token & /*token*/, TokenStream &stream) {
+				stream.reinsert_last();
+				this->args.emplace_back(stream);
+			}
+		);
+		if (this->args.size() > 0) {
+			this->has_args = true;
 		}
 	} else {
 		tokens.reinsert_last();
@@ -487,6 +538,36 @@ bool ASTMemberType::exists() const {
 }
 
 
+ASTMemberTypeArgument::ASTMemberTypeArgument(TokenStream &tokens)
+	:
+	has_key{false} {
+	auto token = tokens.next();
+	if (token->type != token_type::ID) {
+		throw ASTError("expected argument value or key, but got", *token);
+	}
+
+	auto next_token = tokens.next();
+	// check if the argument is keyed
+	if (next_token->type == token_type::OPERATOR) {
+		if (unlikely(op_from_token(*next_token) != nyan_op::ASSIGN)) {
+			throw ASTError("expected argument keyed assignment, but got", *token);
+		}
+
+		this->has_key = true;
+		this->key = IDToken(*token, tokens);
+
+		token = tokens.next();
+		if (unlikely(token->type != token_type::ID)) {
+			throw ASTError("expected argument value, but got", *token);
+		}
+	} else {
+		tokens.reinsert_last();
+	}
+
+	this->value = IDToken{*token, tokens};
+}
+
+
 ASTMemberValue::ASTMemberValue()
 	:
 	does_exist{false} {}
@@ -512,6 +593,7 @@ ASTMemberValue::ASTMemberValue(container_t type,
 	switch (this->container_type) {
 	case container_t::SET:
 	case container_t::ORDEREDSET:
+	case container_t::DICT:
 		end_token = token_type::RBRACE; break;
 
 	default:
@@ -560,6 +642,12 @@ void AST::strb(std::ostringstream &builder, int indentlevel) const {
 	}
 }
 
+void ASTArgument::strb(std::ostringstream &builder, int /*indentlevel*/) const {
+	builder << "!" << this->arg.str();
+	for (auto &param : this->params) {
+		builder << " " << param.str();
+	}
+}
 
 void ASTImport::strb(std::ostringstream &builder, int /*indentlevel*/) const {
 	builder << "import " << this->namespace_name.str();
@@ -658,19 +746,32 @@ void ASTMember::strb(std::ostringstream &builder, int indentlevel) const {
 void ASTMemberType::strb(std::ostringstream &builder, int /*indentlevel*/) const {
 	builder << this->name.str();
 
-	if (this->has_payload) {
-		builder << "(" << this->payload.str() << ")";
+	if (this->has_args) {
+		builder << "(";
+		for (auto &arg : this->args) {
+			arg.strb(builder);
+		}
+		builder << ")";
 	}
 }
 
 
+void ASTMemberTypeArgument::strb(std::ostringstream &builder, int /*indentlevel*/) const {
+	if (this->has_key) {
+		builder << this->key.str() << "=";
+	}
+
+	builder << this->value.str();
+}
+
 void ASTMemberValue::strb(std::ostringstream &builder, int /*indentlevel*/) const {
 	switch (this->container_type) {
 	case container_t::SINGLE:
 		builder << this->values[0].str();
 		return;
 
 	case container_t::SET:
+	case container_t::DICT:
 		builder << "{"; break;
 
 	case container_t::ORDEREDSET:
@@ -692,6 +793,7 @@ void ASTMemberValue::strb(std::ostringstream &builder, int /*indentlevel*/) cons
 	switch (this->container_type) {
 	case container_t::SET:
 	case container_t::ORDEREDSET:
+	case container_t::DICT:
 		builder << "}"; break;
 
 	default:

nyan/ast.h

@@ -1,4 +1,4 @@
-// Copyright 2016-2019 the nyan authors, LGPLv3+. See copying.md for legal info.
+// Copyright 2016-2020 the nyan authors, LGPLv3+. See copying.md for legal info.
 #pragma once
 
 
@@ -47,6 +47,26 @@ class ASTBase {
 };
 
 
+/**
+ * AST representation of a member type argument declaration.
+ */
+class ASTMemberTypeArgument : public ASTBase {
+	friend class ASTMemberType;
+	friend class Database;
+	friend class Type;
+
+public:
+	ASTMemberTypeArgument(TokenStream &tokens);
+
+	void strb(std::ostringstream &builder, int indentlevel=0) const override;
+
+protected:
+	bool has_key;
+	IDToken key;
+	IDToken value;
+};
+
+
 /**
  * AST representation of a member type declaration.
  */
@@ -65,8 +85,8 @@ class ASTMemberType : ASTBase {
 	bool does_exist;
 	IDToken name;
 
-	bool has_payload;
-	IDToken payload;
+	bool has_args;
+	std::vector<ASTMemberTypeArgument> args;
 };
 
 
@@ -116,6 +136,27 @@ class ASTMember : public ASTBase {
 };
 
 
+/**
+ * The abstract syntax tree representation of an argument.
+ */
+class ASTArgument : public ASTBase {
+public:
+	ASTArgument(TokenStream &tokens);
+
+	void strb(std::ostringstream &builder, int indentlevel=0) const override;
+
+	/** return the argument */
+	const IDToken &get_arg() const;
+
+	/** return the parameters */
+	const std::vector<IDToken> &get_params() const;
+
+protected:
+	IDToken arg;
+	std::vector<IDToken> params;
+};
+
+
 /**
  * An import in a nyan file is represented by this AST entry.
  * Used for the `import ... (as ...)` statement.
@@ -142,7 +183,7 @@ class ASTImport : public ASTBase {
 
 
 /**
- * Inheritance chang
+ * Inheritance change
  */
 class ASTInheritanceChange : public ASTBase {
 	friend class Database;
@@ -196,10 +237,12 @@ class AST : public ASTBase {
 	AST(TokenStream &tokens);
 
 	void strb(std::ostringstream &builder, int indentlevel=0) const override;
+	const std::vector<ASTArgument> &get_args() const;
 	const std::vector<ASTObject> &get_objects() const;
 	const std::vector<ASTImport> &get_imports() const;
 
 protected:
+	std::vector<ASTArgument> args;
 	std::vector<ASTImport> imports;
 	std::vector<ASTObject> objects;
 };

nyan/basic_type.cpp

@@ -1,4 +1,4 @@
-// Copyright 2016-2018 the nyan authors, LGPLv3+. See copying.md for legal info.
+// Copyright 2016-2020 the nyan authors, LGPLv3+. See copying.md for legal info.
 
 #include "basic_type.h"
 
@@ -56,7 +56,8 @@ BasicType BasicType::from_type_token(const IDToken &tok) {
 	// container type name map
 	static const std::unordered_map<std::string, container_t> container_types = {
 		{"set", container_t::SET},
-		{"orderedset", container_t::ORDEREDSET}
+		{"orderedset", container_t::ORDEREDSET},
+		{"dict", container_t::DICT}
 	};
 
 

nyan/basic_type.h

@@ -22,7 +22,7 @@ enum class primitive_t {
 	INT,
 	FLOAT,
 	CONTAINER,
-	OBJECT
+	OBJECT,
 };
 
 
@@ -34,6 +34,7 @@ enum class container_t {
 	SINGLE,
 	SET,
 	ORDEREDSET,
+	DICT,
 };
 
 
@@ -122,6 +123,7 @@ constexpr const char *container_type_to_string(container_t type) {
 	case container_t::SINGLE:        return "single_value";
 	case container_t::SET:           return "set";
 	case container_t::ORDEREDSET:    return "orderedset";
+	case container_t::DICT:          return "dict";
 	}
 
 	return "unhandled container_t";

nyan/config.h

@@ -41,5 +41,16 @@ using value_int_t = int64_t;
 /** type used for nyan::Float values */
 using value_float_t = double;
 
+/** positive infinity for nyan::Int values */
+constexpr const value_int_t INT_POS_INF = std::numeric_limits<value_int_t>::max();
+
+/** negative infinity for nyan::Int values */
+constexpr const value_int_t INT_NEG_INF = std::numeric_limits<value_int_t>::min();
+
+/** positive infinity for nyan::Float values */
+constexpr const value_float_t FLOAT_POS_INF = std::numeric_limits<value_float_t>::infinity();
+
+/** negative infinity for nyan::Float values */
+constexpr const value_float_t FLOAT_NEG_INF = -std::numeric_limits<value_float_t>::infinity();
 
 } // namespace nyan

nyan/lexer/flex.lpp

@@ -65,6 +65,7 @@ float          -?({digit}+\.{digit}*|{digit}*\.{digit}+)
 "{"                     { impl->token(nyan::token_type::LBRACE); }
 "}"                     { impl->token(nyan::token_type::RBRACE); }
 "@"                     { impl->token(nyan::token_type::AT); }
+"!"                     { impl->token(nyan::token_type::BANG); }
 
 "pass"                  { impl->token(nyan::token_type::PASS); }
 "..."                   { impl->token(nyan::token_type::ELLIPSIS); }