From 388a4332860c39a19fedbe2bdc4dbc8b411115e6 Mon Sep 17 00:00:00 2001
From: dos-reis <gdr@axiomatics.org>
Date: Sun, 12 Sep 2010 01:37:50 +0000
Subject: 	* utils/sexpr.H (Token::character): New token type. 
 (Character): New. 	(Syntax::Visitor::visit): Overload for Character. 
 (Allocator::make_character): Declare. 	(Parser::parse_character): Likewise. 
 * utils/sexpr.cc (operator<<) [Token::character]: Print data for 
 character token. 	(Lexer::tokenize): Recognize a character literal. 
 (Parser::parse_character): Define.

---
 src/utils/sexpr.cc | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

(limited to 'src/utils/sexpr.cc')

diff --git a/src/utils/sexpr.cc b/src/utils/sexpr.cc
index 4910f053..db822410 100644
--- a/src/utils/sexpr.cc
+++ b/src/utils/sexpr.cc
@@ -52,6 +52,7 @@ namespace OpenAxiom {
          case Token::sharp_apostrophe: os << "SHARP_APOSTROPHE"; break;
          case Token::sharp_colon: os << "SHARP_COLON"; 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:
@@ -200,6 +201,12 @@ namespace OpenAxiom {
                   t.lexeme = strings.intern(start, cur - start + 1);
                   ++cur;
                }
+               else if (cur + 1 < end and cur[1] == '\\') {
+                  start = cur += 2;
+                  skip_to_word_boundary(cur, end);
+                  t.type = Token::character;
+                  t.lexeme = strings.intern(start, cur - start);
+               }
                else {
                   skip_to_word_boundary(cur, end);
                   t.lexeme = strings.intern(start, cur - start);
@@ -263,6 +270,16 @@ namespace OpenAxiom {
          v.visit(*this);
       }
 
+      // ---------------
+      // -- Character --
+      // ---------------
+      Character::Character(const Token& t) : Atom(t) { }
+
+      void
+      Character::accept(Visitor& v) const {
+         v.visit(*this);
+      }
+
       // ------------
       // -- String --
       // ------------
@@ -377,6 +394,11 @@ namespace OpenAxiom {
          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));
@@ -504,6 +526,14 @@ namespace OpenAxiom {
          return alloc.make_symbol(*cur++, kind);
       }
 
+      const Character*
+      Parser::parse_character(const Token*& cur, const Token* last) {
+         // NOTE: For the time being, accept only simple characters.
+         if (cur->lexeme->size() != 1)
+            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) {
@@ -596,6 +626,9 @@ namespace OpenAxiom {
          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++);
-- 
cgit v1.2.3