aboutsummaryrefslogtreecommitdiff
path: root/src/syntax
diff options
context:
space:
mode:
Diffstat (limited to 'src/syntax')
-rw-r--r--src/syntax/Makefile.am2
-rw-r--r--src/syntax/Makefile.in20
-rw-r--r--src/syntax/sexpr.cc934
3 files changed, 953 insertions, 3 deletions
diff --git a/src/syntax/Makefile.am b/src/syntax/Makefile.am
index a731618f..964f7e54 100644
--- a/src/syntax/Makefile.am
+++ b/src/syntax/Makefile.am
@@ -32,7 +32,7 @@
noinst_LIBRARIES = libsyntax.a
-libsyntax_a_SOURCES = token.cc
+libsyntax_a_SOURCES = token.cc sexpr.cc
oa_target_incdir = $(top_builddir)/$(target)/include
diff --git a/src/syntax/Makefile.in b/src/syntax/Makefile.in
index 8982abc0..f492a7f7 100644
--- a/src/syntax/Makefile.in
+++ b/src/syntax/Makefile.in
@@ -136,7 +136,8 @@ am__v_AR_0 = @echo " AR " $@;
am__v_AR_1 =
libsyntax_a_AR = $(AR) $(ARFLAGS)
libsyntax_a_LIBADD =
-am_libsyntax_a_OBJECTS = libsyntax_a-token.$(OBJEXT)
+am_libsyntax_a_OBJECTS = libsyntax_a-token.$(OBJEXT) \
+ libsyntax_a-sexpr.$(OBJEXT)
libsyntax_a_OBJECTS = $(am_libsyntax_a_OBJECTS)
AM_V_P = $(am__v_P_@AM_V@)
am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
@@ -375,7 +376,7 @@ top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
void_type = @void_type@
noinst_LIBRARIES = libsyntax.a
-libsyntax_a_SOURCES = token.cc
+libsyntax_a_SOURCES = token.cc sexpr.cc
oa_target_incdir = $(top_builddir)/$(target)/include
libsyntax_a_CPPFLAGS = -I$(top_srcdir)/src/include -I$(oa_target_incdir)
all: all-am
@@ -427,6 +428,7 @@ mostlyclean-compile:
distclean-compile:
-rm -f *.tab.c
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libsyntax_a-sexpr.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libsyntax_a-token.Po@am__quote@
.cc.o:
@@ -464,6 +466,20 @@ libsyntax_a-token.obj: token.cc
@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libsyntax_a_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libsyntax_a-token.obj `if test -f 'token.cc'; then $(CYGPATH_W) 'token.cc'; else $(CYGPATH_W) '$(srcdir)/token.cc'; fi`
+libsyntax_a-sexpr.o: sexpr.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libsyntax_a_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libsyntax_a-sexpr.o -MD -MP -MF $(DEPDIR)/libsyntax_a-sexpr.Tpo -c -o libsyntax_a-sexpr.o `test -f 'sexpr.cc' || echo '$(srcdir)/'`sexpr.cc
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libsyntax_a-sexpr.Tpo $(DEPDIR)/libsyntax_a-sexpr.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='sexpr.cc' object='libsyntax_a-sexpr.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libsyntax_a_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libsyntax_a-sexpr.o `test -f 'sexpr.cc' || echo '$(srcdir)/'`sexpr.cc
+
+libsyntax_a-sexpr.obj: sexpr.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libsyntax_a_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libsyntax_a-sexpr.obj -MD -MP -MF $(DEPDIR)/libsyntax_a-sexpr.Tpo -c -o libsyntax_a-sexpr.obj `if test -f 'sexpr.cc'; then $(CYGPATH_W) 'sexpr.cc'; else $(CYGPATH_W) '$(srcdir)/sexpr.cc'; fi`
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libsyntax_a-sexpr.Tpo $(DEPDIR)/libsyntax_a-sexpr.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='sexpr.cc' object='libsyntax_a-sexpr.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libsyntax_a_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libsyntax_a-sexpr.obj `if test -f 'sexpr.cc'; then $(CYGPATH_W) 'sexpr.cc'; else $(CYGPATH_W) '$(srcdir)/sexpr.cc'; fi`
+
mostlyclean-libtool:
-rm -f *.lo
diff --git a/src/syntax/sexpr.cc b/src/syntax/sexpr.cc
new file mode 100644
index 00000000..14113164
--- /dev/null
+++ b/src/syntax/sexpr.cc
@@ -0,0 +1,934 @@
+// Copyright (C) 2010-2013, Gabriel Dos Reis.
+// All rights reserved.
+// Written by Gabriel Dos Reis.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// - Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// - Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in
+// the documentation and/or other materials provided with the
+// distribution.
+//
+// - Neither the name of The Numerical Algorithms Group Ltd. nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// --% Author: Gabriel Dos Reis.
+
+#include <ctype.h>
+#include <string.h>
+#include <iostream>
+#include <iterator>
+#include <open-axiom/sexpr>
+#include <open-axiom/FileMapping>
+
+namespace OpenAxiom {
+ namespace Sexpr {
+ template<typename T, int N>
+ static inline int
+ length(const T(&)[N]) {
+ return N;
+ }
+
+ template<typename Sequence>
+ static inline typename Sequence::const_pointer
+ begin_ptr(const Sequence& s) {
+ return &*s.begin();
+ }
+
+ template<typename Sequence>
+ static inline typename Sequence::const_pointer
+ end_ptr(const Sequence& s) {
+ return s.empty() ? 0 : &*s.begin() + s.size();
+ }
+
+ std::ostream&
+ operator<<(std::ostream& os, const Token& t) {
+ switch (t.type) {
+ case Token::semicolon: os << "SEMICOLON"; break;
+ case Token::dot: os << "DOT"; break;
+ case Token::comma: os << "COMMA"; break;
+ case Token::open_paren: os << "OPEN_PAREN"; break;
+ case Token::close_paren: os << "CLOSE_PAREN"; break;
+ case Token::apostrophe: os << "APOSTROPHE"; break;
+ case Token::backquote: os << "BACKQUOTE"; break;
+ case Token::backslash: os << "BACKSLASH"; break;
+ case Token::sharp_open_paren: os << "SHARP_OPEN_PAREN"; break;
+ case Token::sharp_apostrophe: os << "SHARP_APOSTROPHE"; break;
+ case Token::sharp_colon: os << "SHARP_COLON"; break;
+ case Token::sharp_plus: os << "SHARP_PLUS"; break;
+ case Token::sharp_minus: os << "SHARP_MINUS"; break;
+ case Token::sharp_dot: os << "SHARP_DOT"; break;
+ case Token::comma_at: os << "COMMA_AT"; break;
+ case Token::integer: os << "INTEGER"; break;
+ case Token::character: os << "CHARACTER"; break;
+ case Token::string: os << "STRING"; break;
+ case Token::identifier: os << "IDENTIFIER"; break;
+ case Token::sharp_integer_sharp:
+ os << "SHARP_INTEGER_SHARP"; break;
+ case Token::sharp_integer_equal:
+ os << "SHARP_INTEGER_EQUAL"; break;
+ default: os << "UNKNOWN"; break;
+ }
+ os << '(';
+ if (t.lexeme != 0) {
+ os << '"';
+ std::copy(t.lexeme->begin(), t.lexeme->end(),
+ std::ostream_iterator<char>(os));
+ os << '"';
+ }
+ else
+ os << "<missing>";
+ return os << ')';
+ }
+
+ // -----------
+ // -- Lexer --
+ // -----------
+ static void
+ syntax_error(const std::string& s) {
+ throw BasicError(s);
+ }
+
+ // Return true if character `c' introduces a blank.
+ static bool
+ is_blank(char c) {
+ return c == ' ' or c == '\t' or c == '\v'
+ or c == '\n' or c == '\f' or c == '\r';
+ }
+
+ // Return true if the character `c' introduces a delimiter.
+ static bool
+ is_delimiter(char c) {
+ return is_blank(c)
+ or c == '(' or c == ')' or c == '\''
+ or c == '`' or c == '#';
+ }
+
+ // Move `cur' past all consecutive blank characters, and
+ // return the new position.
+ static const Byte*
+ skip_blank(const Byte*& cur, const Byte* end) {
+ while (cur < end and is_blank(*cur))
+ ++cur;
+ return cur;
+ }
+
+ // Move `cur' to end-of-line marker.
+ static const Byte*
+ skip_to_eol(const Byte*& cur, const Byte* end) {
+ // FIXME: properly handle CR+LF.
+ while (cur < end and *cur != '\n')
+ ++cur;
+ return cur;
+ }
+
+ // Move `cur' until a word boundary is reached.
+ static const Byte*
+ skip_to_word_boundary(const Byte*& cur, const Byte* end) {
+ bool saw_escape = false;
+ for (; cur < end; ++cur) {
+ if (saw_escape)
+ saw_escape = false;
+ else if (*cur == '\\')
+ saw_escape = true;
+ else if (is_delimiter(*cur))
+ break;
+ }
+ return cur;
+ }
+
+ // Move `cur' one-past a non-esacaped character `c'.
+ // Return true if the character was seen.
+ static bool
+ skip_to_nonescaped_char(const Byte*& cur, const Byte* end, char c) {
+ bool saw_escape = false;
+ for (; cur < end; ++cur)
+ if (saw_escape)
+ saw_escape = false;
+ else if (*cur == '\\')
+ saw_escape = true;
+ else if (*cur == c) {
+ ++cur;
+ return true;
+ }
+ return false;
+ }
+
+ // Move `cur' past the closing quote of string literal.
+ // Return true if the closing fence was effectively seen.
+ static inline bool
+ skip_to_quote(const Byte*& cur, const Byte* end) {
+ return skip_to_nonescaped_char(cur, end, '"');
+ }
+
+ // Return true if the character `c' be part of a non-absolute
+ // identifier.
+ static bool
+ identifier_part(char c) {
+ switch (c) {
+ case '+': case '-': case '*': case '/': case '%': case '^':
+ case '~': case '@': case '$': case '&': case '=':
+ case '<': case '>': case '?': case '!': case '_':
+ case '[': case ']': case '{': case '}':
+ return true;
+ default:
+ return isalnum(c);
+ }
+ }
+
+ // Return true if the character `c' has a special meaning after
+ // the sharp character.
+ static bool
+ special_after_sharp(char c) {
+ return c == '(' or c == '\'' or c == ':'
+ or c == '+' or c == '-' or c == '.';
+ }
+
+ // Return true if the sequence `[cur, end)' has a prefix that is
+ // an integer followrd by the equal sign or the sharp sign.
+ // `cur' is moved along the way.
+ static bool
+ only_digits_before_equal_or_shap(const Byte*& cur, const Byte* end) {
+ while (cur < end and isdigit(*cur))
+ ++cur;
+ return cur < end and (*cur == '#' or *cur == '=');
+ }
+
+ // The token `t' was thought to designate an identifier.
+ // Reclassify it as an integer if, in fact, its lexeme consists
+ // entirely of digits.
+ static void
+ maybe_reclassify(Token& t) {
+ const Byte* cur = t.lexeme->begin();
+ const Byte* end = t.lexeme->end();
+ while (cur < end and isdigit(*cur))
+ ++cur;
+ if (cur == end)
+ t.type = Token::integer;
+ }
+
+ // Returns true if the first characters in the range
+ // [cur, last) start an identifier.
+ static bool
+ start_symbol(const Byte* cur, const Byte* last) {
+ if (cur >= last)
+ return false;
+ return identifier_part(*cur)
+ or *cur == '|' or *cur == ':';
+ }
+
+ // We are processing a symbol token. Accumulate all
+ // legitimate characters till the end of the token.
+ static void
+ skip_to_end_of_symbol(const Byte*& cur, const Byte* end) {
+ const char c = *cur;
+ if (*cur == '|')
+ skip_to_nonescaped_char(++cur, end, c);
+ else
+ skip_to_word_boundary(cur, end);
+ if (cur < end and *cur == ':')
+ skip_to_end_of_symbol(cur, end);
+ }
+
+ static Token
+ match_maybe_symbol(Lexer* lexer, const Byte*& cur, const Byte* end) {
+ Token t = { Token::identifier, 0 };
+ const Byte* start = cur;
+ skip_to_end_of_symbol(cur, end);
+ t.lexeme = lexer->intern(start, cur - start);
+ maybe_reclassify(t);
+ return t;
+ }
+
+ const Byte*
+ Lexer::tokenize(const Byte* cur, const Byte* end) {
+ while (skip_blank(cur, end) < end) {
+ Token t = { Token::unknown, 0 };
+ switch (*cur) {
+ case ';': {
+ const Byte* start = cur;
+ t.type = Token::semicolon;
+ skip_to_eol(cur, end);
+ t.lexeme = intern(start, cur - start);
+ break;
+ }
+
+ case '.': case '(': case ')': case '\'': case '`':
+ t.type = Token::Type(token::value(*cur));
+ t.lexeme = intern(cur, 1);
+ ++cur;
+ break;
+
+ case ',': {
+ const Byte* start = cur;
+ if (++cur < end and *cur == '@') {
+ t.type = Token::comma_at;
+ ++cur;
+ }
+ else
+ t.type = Token::comma;
+ t.lexeme = intern(start, cur - start);
+ break;
+ }
+
+ case '\\':
+ t = match_maybe_symbol(this, cur, end);
+ break;
+
+ case '#': {
+ const Byte* start = cur;
+ if (cur + 1 < end and special_after_sharp(cur[1])) {
+ t.type = Token::Type(token::value(cur[0], cur[1]));
+ t.lexeme = intern(cur, 2);
+ cur += 2;
+ }
+ else if (cur + 1 < end and cur[1] == '\\') {
+ start = cur += 2;
+ if (not isalnum(*cur))
+ ++cur;
+ else
+ skip_to_word_boundary(cur, end);
+ t.type = Token::character;
+ t.lexeme = intern(start, cur - start);
+ }
+ else if (only_digits_before_equal_or_shap(++cur, end)) {
+ t.type = *cur == '#'
+ ? Token::sharp_integer_sharp
+ : Token::sharp_integer_equal;
+ t.lexeme = intern(start, cur - start + 1);
+ ++cur;
+ }
+ else {
+ skip_to_word_boundary(cur, end);
+ t.lexeme = intern(start, cur - start);
+ }
+ break;
+ }
+
+ case '"': {
+ const Byte* start = cur;
+ skip_to_quote(++cur, end);
+ t.type = Token::string;
+ t.lexeme = intern(start, cur - start);
+ break;
+ }
+
+ default:
+ if (start_symbol(cur, end))
+ t = match_maybe_symbol(this, cur, end);
+ else {
+ const Byte* start = cur;
+ skip_to_word_boundary(++cur, end);
+ t.lexeme = intern(start, cur - start);
+ }
+ break;
+ }
+ tokens.push_back(t);
+ }
+ return cur;
+ }
+
+ // ----------
+ // -- Atom --
+ // ----------
+ Atom::Atom(const Token& t) : tok(t) { }
+
+ void
+ Atom::accept(Visitor& v) const {
+ v.visit(*this);
+ }
+
+ // -------------
+ // -- Integer --
+ // -------------
+ Integer::Integer(const Token& t) : Atom(t) { }
+
+ void
+ Integer::accept(Visitor& v) const {
+ v.visit(*this);
+ }
+
+ // ---------------
+ // -- Character --
+ // ---------------
+ Character::Character(const Token& t) : Atom(t) { }
+
+ void
+ Character::accept(Visitor& v) const {
+ v.visit(*this);
+ }
+
+ // ------------
+ // -- String --
+ // ------------
+ String::String(const Token& t) : Atom(t) { }
+
+ void
+ String::accept(Visitor& v) const {
+ v.visit(*this);
+ }
+
+ // ------------
+ // -- Symbol --
+ // ------------
+ Symbol::Symbol(const Token& t, Kind k) : Atom(t), sort(k) { }
+
+ void
+ Symbol::accept(Visitor& v) const {
+ v.visit(*this);
+ }
+
+ // ------------
+ // -- Anchor --
+ // ------------
+ Anchor::Anchor(size_t t, const Syntax* s) : tag(t), val(s) { }
+
+ void
+ Anchor::accept(Visitor& v) const {
+ v.visit(*this);
+ }
+
+ // ---------------
+ // -- Reference --
+ // ---------------
+ Reference::Reference(const Token& t, size_t v) : Atom(t), pos(v) { }
+
+ void
+ Reference::accept(Visitor& v) const {
+ v.visit(*this);
+ }
+
+ // -----------
+ // -- Quote --
+ // -----------
+ Quote::Quote(const Syntax* s) : unary_form<Quote>(s) { }
+
+ // ---------------
+ // -- Antiquote --
+ // ---------------
+ Antiquote::Antiquote(const Syntax* s) : unary_form<Antiquote>(s) { }
+
+ // ------------
+ // -- Expand --
+ // ------------
+ Expand::Expand(const Syntax* s) : unary_form<Expand>(s) { }
+
+ // ----------
+ // -- Eval --
+ // ----------
+ Eval::Eval(const Syntax* s) : unary_form<Eval>(s) { }
+
+ // ------------
+ // -- Splice --
+ // ------------
+ Splice::Splice(const Syntax* s) : unary_form<Splice>(s) { }
+
+ // --------------
+ // -- Function --
+ // --------------
+ Function::Function(const Syntax* s) : unary_form<Function>(s) { }
+
+ // -------------
+ // -- Include --
+ Include::Include(const Syntax* s) : unary_form<Include>(s) { }
+
+ // -------------
+ // -- Exclude --
+ Exclude::Exclude(const Syntax* s) : unary_form<Exclude>(s) { }
+
+ // -------------
+ // -- DotTail --
+ // -------------
+ DotTail::DotTail(const Syntax* f) : unary_form<DotTail>(f) { }
+
+ // ----------
+ // -- List --
+ // ----------
+ List::List() { }
+
+ List::List(const base& elts) : base(elts) { }
+
+ List::~List() { }
+
+ void
+ List::accept(Visitor& v) const {
+ v.visit(*this);
+ }
+
+ // ------------
+ // -- Vector --
+ // ------------
+ Vector::Vector() { }
+
+ Vector::Vector(const base& elts) : base(elts) { }
+
+ Vector::~Vector() { }
+
+ void
+ Vector::accept(Visitor& v) const {
+ v.visit(*this);
+ }
+
+ // ---------------------
+ // -- Syntax::Visitor --
+ // ---------------------
+
+ // implicitly convert a reference to `T' to a reference to `S'.
+ template<typename S, typename T>
+ inline const S&
+ as(const T& t) {
+ return t;
+ }
+
+ void
+ Syntax::Visitor::visit(const Integer& i) {
+ visit(as<Atom>(i));
+ }
+
+ void
+ Syntax::Visitor::visit(const Character& c) {
+ visit(as<Atom>(c));
+ }
+
+ void
+ Syntax::Visitor::visit(const String& s) {
+ visit(as<Atom>(s));
+ }
+
+ void
+ Syntax::Visitor::visit(const Symbol& s) {
+ visit(as<Atom>(s));
+ }
+
+ void
+ Syntax::Visitor::visit(const Reference& r) {
+ visit(as<Atom>(r));
+ }
+
+ // ---------------
+ // -- Allocator --
+ // ---------------
+ Allocator::Allocator() { }
+
+ // This destructor is defined here so that it provides
+ // a single instantiation point for destructors of all
+ // used templates floating around.
+ Allocator::~Allocator() { }
+
+ const Character*
+ Allocator::make_character(const Token& t) {
+ return chars.make(t);
+ }
+
+ const Integer*
+ Allocator::make_integer(const Token& t) {
+ return ints.make(t);
+ }
+
+ const String*
+ Allocator::make_string(const Token& t) {
+ return strs.make(t);
+ }
+
+ const Symbol*
+ Allocator::make_symbol(const Token& t, Symbol::Kind k) {
+ return syms.make(t, k);
+ }
+
+ const Anchor*
+ Allocator::make_anchor(size_t t, const Syntax* s) {
+ return ancs.make(t, s);
+ }
+
+ const Reference*
+ Allocator::make_reference(const Token& t, size_t i) {
+ return refs.make(t, i);
+ }
+
+ const Quote*
+ Allocator::make_quote(const Syntax* s) {
+ return quotes.make(s);
+ }
+
+ const Antiquote*
+ Allocator::make_antiquote(const Syntax* s) {
+ return antis.make(s);
+ }
+
+ const Expand*
+ Allocator::make_expand(const Syntax* s) {
+ return exps.make(s);
+ }
+
+ const Eval*
+ Allocator::make_eval(const Syntax* s) {
+ return evls.make(s);
+ }
+
+ const Splice*
+ Allocator::make_splice(const Syntax* s) {
+ return spls.make(s);
+ }
+
+ const Function*
+ Allocator::make_function(const Syntax* s) {
+ return funs.make(s);
+ }
+
+ const Include*
+ Allocator::make_include(const Syntax* s) {
+ return incs.make(s);
+ }
+
+ const Exclude*
+ Allocator::make_exclude(const Syntax* s) {
+ return excs.make(s);
+ }
+
+ const DotTail*
+ Allocator::make_dot_tail(const Syntax* f) {
+ return tails.make(f);
+ }
+
+ const List*
+ Allocator::make_list(const std::vector<const Syntax*>& elts) {
+ if (elts.empty())
+ return &empty_list;
+ return lists.make(elts);
+ }
+
+ const Vector*
+ Allocator::make_vector(const std::vector<const Syntax*>& elts) {
+ if (elts.empty())
+ return &empty_vector;
+ return vectors.make(elts);
+ }
+
+ // ------------
+ // -- Parser --
+ // ------------
+
+ // Signal a parse error
+ static void
+ parse_error(const std::string& s) {
+ throw BasicError(s);
+ }
+
+ // Signal that an expected syntax object was missing
+ static void
+ expected_syntax(const std::string& s) {
+ parse_error("expected " + s);
+ }
+
+ // Signal an abrupt end of input
+ static void
+ unexpected_end_of_input(const std::string& s) {
+ parse_error("unexpected end of input after " + s);
+ }
+
+ // Signal a missing closing parenthesis
+ static void
+ missing_closer_for(const std::string& s) {
+ parse_error("missing closing parenthesis for " + s);
+ }
+
+ // The sequence of characters in [cur, last) consists
+ // entirely of digits. Return the corresponding natural value.
+ static size_t
+ natural_value(const Byte* cur, const Byte* last) {
+ size_t n = 0;
+ for (; cur < last; ++cur)
+ // FIXME: check for overflow.
+ n = 10 * n + (*cur - '0');
+ return n;
+ }
+
+ // Parse a plain identifier or a Lisp-style keyword identifier.
+ const Symbol*
+ Parser::parse_symbol(const Token*& cur, const Token* last) {
+ Symbol::Kind kind = *cur->lexeme->begin() == ':'
+ ? Symbol::keyword
+ : Symbol::ordinary;
+ return alloc.make_symbol(*cur++, kind);
+ }
+
+ // List of lower case character names
+ static const char* charname[] = {
+ "newline", "space", "page", "tab",
+ "backspace", "return", "linefeed"
+ };
+
+ static bool
+ equal_character_name(BasicString lhs, const char* rhs) {
+ if (lhs->size() != strlen(rhs))
+ return false;
+ for (const Byte* cur = lhs->begin(); cur != lhs->end(); ++cur)
+ if (tolower(*cur) != *rhs++)
+ return false;
+ return true;
+ }
+
+ static bool
+ valid_character_name(BasicString s) {
+ for (int i = 0; i < length(charname); ++i)
+ if (equal_character_name(s, charname[i]))
+ return true;
+ return false;
+ }
+
+ const Character*
+ Parser::parse_character(const Token*& cur, const Token* last) {
+ if (cur->lexeme->size() != 1
+ and not valid_character_name(cur->lexeme))
+ parse_error("invalid literal character syntax");
+ return alloc.make_character(*cur++);
+ }
+
+ // Parse an anchor definition of the form #n=<syntax>
+ const Anchor*
+ Parser::parse_anchor(const Token*& cur, const Token* last) {
+ const size_t n = natural_value(cur->lexeme->begin() + 1,
+ cur->lexeme->end() - 1);
+ if (++cur == last)
+ unexpected_end_of_input("sharp-integer-equal sign");
+ return alloc.make_anchor(n, parse_syntax(cur, last));
+ }
+
+ // Parse a reference to an anchor, #n#
+ const Reference*
+ Parser::parse_reference(const Token*& cur, const Token* last) {
+ const size_t n = natural_value(cur->lexeme->begin() + 1,
+ cur->lexeme->end() - 1);
+ return alloc.make_reference(*cur++, n);
+ }
+
+ // Parse an uninterned symbol #:<identifier>
+ const Symbol*
+ Parser::parse_uninterned(const Token*& cur, const Token* last) {
+ if (cur == last or cur->type != Token::identifier)
+ expected_syntax("symbol after sharp-colon sign");
+ // FIXME: check that the identifier is not a keyword.
+ return alloc.make_symbol(*cur++, Symbol::uninterned);
+ }
+
+ // Parse a function syntax: #'<syntax>
+ const Function*
+ Parser::parse_function(const Token*& cur, const Token* last) {
+ if (cur == last)
+ unexpected_end_of_input("sharp-quote sign");
+ return alloc.make_function(parse_syntax(cur, last));
+ }
+
+ // Parse a quotation
+ const Quote*
+ Parser::parse_quote(const Token*& cur, const Token* last) {
+ if (cur == last)
+ unexpected_end_of_input("quote sign");
+ return alloc.make_quote(parse_syntax(cur, last));
+ }
+
+ // Parse an antiquotation
+ const Antiquote*
+ Parser::parse_antiquote(const Token*& cur, const Token* last) {
+ if (cur == last)
+ unexpected_end_of_input("backquote sign");
+ return alloc.make_antiquote(parse_syntax(cur, last));
+ }
+
+ // Parse an expansion request form
+ const Expand*
+ Parser::parse_expand(const Token*& cur, const Token* last) {
+ const Syntax* s = parse_syntax(cur, last);
+ if (s == 0)
+ unexpected_end_of_input("comma sign");
+ return alloc.make_expand(s);
+ }
+
+ // Parse conditional inclusions
+ const Include*
+ Parser::parse_include(const Token*& cur, const Token* last) {
+ const Syntax* s = parse_syntax(cur, last);
+ if (s == 0)
+ unexpected_end_of_input("sharp-plus sign");
+ return alloc.make_include(s);
+ }
+
+ const Exclude*
+ Parser::parse_exclude(const Token*& cur, const Token* last) {
+ const Syntax* s = parse_syntax(cur, last);
+ if (s == 0)
+ unexpected_end_of_input("sharp-minus sign");
+ return alloc.make_exclude(s);
+ }
+
+ const Eval*
+ Parser::parse_eval(const Token*& cur, const Token* last) {
+ const Syntax* s = parse_syntax(cur, last);
+ if (s == 0)
+ unexpected_end_of_input("sharp-dot sign");
+ return alloc.make_eval(s);
+ }
+
+ const Splice*
+ Parser::parse_splice(const Token*& cur, const Token* last) {
+ const Syntax* s = parse_syntax(cur, last);
+ if (s == 0)
+ unexpected_end_of_input("comma-at sign");
+ return alloc.make_splice(s);
+ }
+
+ // Skip tokens that are semantically blanks, e.g. comments.
+ // Return true if not at end of tokens.
+ static bool
+ skip_ignorable_tokens(const Token*& cur, const Token* last) {
+ while (cur < last and cur->type == Token::semicolon)
+ ++cur;
+ return cur != last;
+ }
+
+ // Parse a vector of syntax objects: #(s .. s)
+ const Vector*
+ Parser::parse_vector(const Token*& cur, const Token* last) {
+ std::vector<const Syntax*> elts;
+ while (skip_ignorable_tokens(cur, last)
+ and cur->type != Token::close_paren)
+ elts.push_back(parse_syntax(cur, last));
+ if (cur == last)
+ missing_closer_for("vector");
+ ++cur;
+ return alloc.make_vector(elts);
+ }
+
+ // Constructs a pair or a list syntax object.
+ const List*
+ Parser::parse_list(const Token*& cur, const Token* last) {
+ std::vector<const Syntax*> elts;
+ while (skip_ignorable_tokens(cur, last)
+ and cur->type != Token::close_paren) {
+ if (cur->type == Token::dot) {
+ skip_ignorable_tokens(++cur, last);
+ if (const Syntax* s = parse_syntax(cur, last)) {
+ elts.push_back(alloc.make_dot_tail(s));
+ break;
+ }
+ }
+ elts.push_back(parse_syntax(cur, last));
+ }
+ if (cur == last or cur->type != Token::close_paren)
+ missing_closer_for("list");
+ ++cur;
+ return alloc.make_list(elts);
+ }
+
+ Parser::Parser(Allocator& a, std::vector<const Syntax*>& v)
+ : alloc(a), syns(v) { }
+
+ static std::string
+ to_string(BasicString s) {
+ return { s->begin(), s->end() };
+ }
+
+ const Syntax*
+ Parser::parse_syntax(const Token*& cur, const Token* last) {
+ if (not skip_ignorable_tokens(cur, last))
+ return 0;
+
+ switch (cur->type) {
+ case Token::integer:
+ return alloc.make_integer(*cur++);
+
+ case Token::character:
+ return parse_character(cur, last);
+
+ case Token::string:
+ return alloc.make_string(*cur++);
+
+ case Token::identifier:
+ return parse_symbol(cur, last);
+
+ case Token::sharp_integer_equal:
+ return parse_anchor(cur, last);
+
+ case Token::sharp_integer_sharp:
+ return parse_reference(cur, last);
+
+ case Token::sharp_colon:
+ return parse_uninterned(++cur, last);
+
+ case Token::sharp_apostrophe:
+ return parse_function(++cur, last);
+
+ case Token::sharp_open_paren:
+ return parse_vector(++cur, last);
+
+ case Token::apostrophe:
+ return parse_quote(++cur, last);
+
+ case Token::open_paren:
+ return parse_list(++cur, last);
+
+ case Token::sharp_plus:
+ return parse_include(++cur, last);
+
+ case Token::sharp_minus:
+ return parse_exclude(++cur, last);
+
+ case Token::sharp_dot:
+ return parse_eval(++cur, last);
+
+ case Token::backquote:
+ return parse_antiquote(++cur, last);
+
+ case Token::comma:
+ return parse_expand(++cur, last);
+
+ case Token::comma_at:
+ return parse_splice(++cur, last);
+
+ default:
+ parse_error(std::string("parse error before ")
+ + to_string(cur->lexeme));
+ return 0; // never executed
+ }
+ }
+
+ const Token*
+ Parser::parse(const Token* cur, const Token* last) {
+ while (cur < last)
+ if (const Syntax* s = parse_syntax(cur, last))
+ syns.push_back(s);
+ return cur;
+ }
+
+ Module::Module(const std::string& s) : nm(s) {
+ std::vector<Token> tokens;
+ Memory::FileMapping input(s);
+ Lexer lexer(raw_strs, tokens);
+ const Byte* rest = lexer.tokenize(input.begin(), input.end());
+ if (rest != input.end())
+ syntax_error("syntax error");
+ Parser parser(allocator, *this);
+ const Token* tok = parser.parse(begin_ptr(tokens), end_ptr(tokens));
+ if (tok != end_ptr(tokens))
+ parse_error("parse error");
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-23 15:34:18 +0000