lexeme_impl.cpp

   1 #include <vector>
   2 #include <string>
   3
   4 #include "lexeme_impl.h"
   5 #include "lexeme_id.h"
   6 #include "data.h"
   7
   8 using namespace utakata::lexeme;
   9 using namespace utakata::utf8_string;
  10 using namespace utakata::interpreter;
  11
  12
  13 smart_ptr<ILexeme> utakata::lexeme::makeOpenParen()
  14 {
  15     smart_ptr<UTF8String> tmp(new UTF8String());
  16     *tmp += "(";
  17     return smart_ptr<ILexeme>(new PureLexeme(tmp, LexemeID::openParenthesis));
  18 }
  19
  20 smart_ptr<ILexeme> utakata::lexeme::makeEOS()
  21 {
  22     return smart_ptr<ILexeme>(new PureLexeme(smart_ptr<UTF8String>(), LexemeID::eos));
  23 }
  24
  25 smart_ptr<ILexeme> utakata::lexeme::makeCloseParen()
  26 {
  27     smart_ptr<UTF8String> tmp(new UTF8String(utf8_string::convert(")")));
  28     return smart_ptr<ILexeme>(new PureLexeme(tmp,
  29                                              LexemeID::closeParenthesis));
  30 }
  31
  32 smart_ptr<ILexeme> utakata::lexeme::makeBackQuote()
  33 {
  34     smart_ptr<UTF8String> tmp(new UTF8String(utf8_string::convert("`")));
  35     return smart_ptr<ILexeme>(new PureLexeme(tmp,
  36                                              LexemeID::backquote));
  37 }
  38
  39 smart_ptr<ILexeme> utakata::lexeme::makeQuote()
  40 {
  41     smart_ptr<UTF8String> tmp(new UTF8String(utf8_string::convert("'")));
  42     return smart_ptr<ILexeme>(new PureLexeme(tmp,
  43                                              LexemeID::quote));
  44 }
  45
  46 smart_ptr<ILexeme> utakata::lexeme::makeDot()
  47 {
  48     smart_ptr<UTF8String> tmp(new UTF8String(utf8_string::convert(".")));
  49     return smart_ptr<ILexeme>(new PureLexeme(tmp,
  50                                              LexemeID::dot));
  51 }
  52
  53 smart_ptr<ILexeme> utakata::lexeme::makeIdentifier(const utakata::utf8_string::UTF8String& str)
  54 {
  55     return smart_ptr<ILexeme>(new Identifier(str));
  56 }
  57
  58 smart_ptr<ILexeme> utakata::lexeme::makeString(const utakata::utf8_string::UTF8String& str)
  59 {
  60     return smart_ptr<ILexeme>(new String(str));
  61 }
  62
  63 smart_ptr<ILexeme> utakata::lexeme::makeUnquoteSplicing(const utakata::utf8_string::UTF8String& str)
  64 {
  65     smart_ptr<UTF8String> tmp(new UTF8String(utf8_string::convert(",@")));
  66     return smart_ptr<ILexeme>(new PureLexeme(tmp,
  67                                              LexemeID::unquoteSplicing));
  68 }
  69
  70 smart_ptr<ILexeme> utakata::lexeme::makeUnquote()
  71 {
  72     smart_ptr<UTF8String> tmp(new UTF8String(utf8_string::convert(",")));
  73     return smart_ptr<ILexeme>(new PureLexeme(tmp,
  74                                              LexemeID::unsyntax));
  75 }
  76
  77 smart_ptr<ILexeme> utakata::lexeme::makeByteVector()
  78 {
  79     smart_ptr<UTF8String> tmp(new UTF8String(utf8_string::convert("#vu(")));
  80     return smart_ptr<ILexeme>(new PureLexeme(tmp,
  81                                              LexemeID::byteVector));
  82 }
  83
  84 smart_ptr<ILexeme> utakata::lexeme::makeVector()
  85 {
  86     smart_ptr<UTF8String> tmp(new UTF8String(utf8_string::convert("#(")));
  87     return smart_ptr<ILexeme>(new PureLexeme(tmp,
  88                                              LexemeID::vector));
  89 }
  90
  91 smart_ptr<ILexeme> utakata::lexeme::makeSyntax()
  92 {
  93     smart_ptr<UTF8String> tmp(new UTF8String(utf8_string::convert("#'")));
  94     return smart_ptr<ILexeme>(new PureLexeme(tmp,
  95                                              LexemeID::syntax));
  96 }
  97
  98 smart_ptr<ILexeme> utakata::lexeme::makeQuasiSyntax()
  99 {
 100     smart_ptr<UTF8String> tmp(new UTF8String(utf8_string::convert("#`")));
 101     return smart_ptr<ILexeme>(new PureLexeme(tmp,
 102                                              LexemeID::quasiSyntax));
 103 }
 104
 105 smart_ptr<ILexeme> utakata::lexeme::makeUnsyntaxSplicing()
 106 {
 107     smart_ptr<UTF8String> tmp(new UTF8String(utf8_string::convert("#,@")));
 108     return smart_ptr<ILexeme>(new PureLexeme(tmp,
 109                                              LexemeID::unsyntaxSplicing));
 110 }
 111
 112 smart_ptr<ILexeme> utakata::lexeme::makeUnsyntax()
 113 {
 114     smart_ptr<UTF8String> tmp(new UTF8String(utf8_string::convert(",#")));
 115     return smart_ptr<ILexeme>(new PureLexeme(tmp,
 116                                              LexemeID::unsyntax));
 117 }
 118
 119 smart_ptr<ILexeme> utakata::lexeme::makeCharactor(const utakata::utf8_string::UTF8String& str)
 120 {
 121     return smart_ptr<ILexeme>(new Charactor(str));
 122 }
 123
 124 smart_ptr<ILexeme> utakata::lexeme::makeBoolean(const smart_ptr<utakata::utf8_string::UTF8Char>& ch)
 125 {
 126     return smart_ptr<ILexeme>(new Boolean(ch));
 127 }
 128
 129 smart_ptr<ILexeme> utakata::lexeme::makeNanImaginary(const utakata::utf8_string::UTF8String& str,
 130                                                      bool exact)
 131 {
 132     return smart_ptr<ILexeme>(new Number(utakata::utf8_string::UTF8String(),
 133                                          str, exact, 10));
 134 }
 135
 136 smart_ptr<ILexeme> utakata::lexeme::makeInfImaginary(const utakata::utf8_string::UTF8String& str,
 137                                                      bool exact)
 138 {
 139     return smart_ptr<ILexeme>(new Number(utakata::utf8_string::UTF8String(),
 140                                          str, exact, 10));
 141 }
 142
 143 smart_ptr<ILexeme> utakata::lexeme::makeImaginaryOnly(const utakata::utf8_string::UTF8String& str,
 144                                                       bool exact)
 145 {
 146
 147     return smart_ptr<ILexeme>(new Number(utakata::utf8_string::UTF8String(),
 148                                          str, exact, 10));
 149 }
 150
 151 smart_ptr<ILexeme> utakata::lexeme::makeNumber(const utakata::utf8_string::UTF8String& real,
 152                                                const utakata::utf8_string::UTF8String& imagin,
 153                                                bool exact, int radix)
 154 {
 155     return smart_ptr<ILexeme>(new Number(real, imagin, exact, radix));
 156 }
 157
 158 ////////////////
 159 // PureLexeme //
 160 ////////////////
 161 PureLexeme::PureLexeme(const smart_ptr<UTF8String>& str,
 162                        const LexemeID id) : str_(str), id_(id)
 163 {}
 164
 165 const LexemeID PureLexeme::getID() const
 166 {
 167     return id_;
 168 }
 169
 170 smart_ptr<UTF8String> PureLexeme::toString() const
 171 {
 172     return str_;
 173 }
 174
 175 smart_ptr<utakata::interpreter::LiteralData> PureLexeme::getData() const
 176 {
 177     return smart_ptr<utakata::interpreter::LiteralData>();
 178 }
 179
 180 ////////////////
 181 // Identifier //
 182 ////////////////
 183
 184 Identifier::Identifier(const utakata::utf8_string::UTF8String& str) :
 185     str_(new utakata::utf8_string::UTF8String(str))
 186 {
 187 }
 188
 189 const utakata::lexeme::LexemeID Identifier::getID() const
 190 {
 191     return utakata::lexeme::LexemeID::identifier;
 192 }
 193
 194 smart_ptr<utakata::utf8_string::UTF8String> Identifier::toString() const
 195 {
 196     return str_;
 197 }
 198
 199 smart_ptr<utakata::interpreter::LiteralData> Identifier::getData() const
 200 {
 201     smart_ptr<utakata::interpreter::LiteralData> data(new utakata::interpreter::LiteralData);
 202
 203     data->string.add(new utakata::interpreter::StringData);
 204     data->string->str.add(new utakata::utf8_string::UTF8String(*str_));
 205     return data;
 206 }
 207
 208 /////////////
 209 // String  //
 210 /////////////
 211
 212 String::String(const utakata::utf8_string::UTF8String& str) :
 213     str_(new utakata::utf8_string::UTF8String(str))
 214 {
 215 }
 216
 217 const utakata::lexeme::LexemeID String::getID() const
 218 {
 219     return utakata::lexeme::LexemeID::identifier;
 220 }
 221
 222 smart_ptr<utakata::utf8_string::UTF8String> String::toString() const
 223 {
 224     return str_;
 225 }
 226
 227 smart_ptr<utakata::interpreter::LiteralData> String::getData() const
 228 {
 229     smart_ptr<utakata::interpreter::LiteralData> data(new utakata::interpreter::LiteralData);
 230
 231     data->string.add(new utakata::interpreter::StringData);
 232     data->string->str.add(new utakata::utf8_string::UTF8String(*str_));
 233     return data;
 234 }
 235
 236 ////////////
 237 // Number //
 238 ////////////
 239
 240 Number::Number(const UTF8String& real,
 241                const UTF8String& imagin,
 242                bool exact, int radix) :
 243     data_(new LiteralData)
 244 {
 245     data_->number = utakata::interpreter::makeNumberData(real, imagin, exact, radix);
 246 }
 247
 248 const utakata::lexeme::LexemeID Number::getID() const
 249 {
 250     return utakata::lexeme::LexemeID::number;
 251 }
 252
 253 smart_ptr<utakata::utf8_string::UTF8String> Number::toString() const
 254 {
 255     return smart_ptr<UTF8String>(new UTF8String(*data_->number->real + *data_->number->imagin));
 256 }
 257
 258 smart_ptr<utakata::interpreter::LiteralData> Number::getData() const
 259 {
 260     return data_;
 261 }
 262
 263 ///////////////
 264 // Charactor //
 265 ///////////////
 266
 267 Charactor::Charactor(const UTF8String& ch) : ch_(new UTF8String(ch))
 268 {
 269 }
 270
 271 const utakata::lexeme::LexemeID Charactor::getID() const
 272 {
 273     return utakata::lexeme::LexemeID::charactor;
 274 }
 275
 276 smart_ptr<utakata::utf8_string::UTF8String> Charactor::toString() const
 277 {
 278     return ch_;
 279 }
 280
 281 smart_ptr<utakata::interpreter::LiteralData> Charactor::getData() const
 282 {
 283     smart_ptr<utakata::interpreter::LiteralData> data(new utakata::interpreter::LiteralData);
 284
 285     data->string.add(new utakata::interpreter::StringData);
 286     data->string->str.add(new utakata::utf8_string::UTF8String(*ch_));
 287     return data;
 288 }
 289
 290
 291 /////////////
 292 // Boolean //
 293 /////////////
 294
 295 Boolean::Boolean(const smart_ptr<UTF8Char>& ch) : bool_(new UTF8String())
 296 {
 297     *bool_ += *ch;
 298 }
 299
 300 const utakata::lexeme::LexemeID Boolean::getID() const
 301 {
 302     return utakata::lexeme::LexemeID::boolean;
 303 }
 304
 305 smart_ptr<utakata::utf8_string::UTF8String> Boolean::toString() const
 306 {
 307     return bool_;
 308 }
 309
 310 smart_ptr<utakata::interpreter::LiteralData> Boolean::getData() const
 311 {
 312     smart_ptr<utakata::interpreter::LiteralData> data(new utakata::interpreter::LiteralData);
 313
 314     data->string.add(new utakata::interpreter::StringData);
 315     data->string->str.add(new utakata::utf8_string::UTF8String(*bool_));
 316     return data;
 317 }