lexeme_impl.cpp

   1 #include <vector>
   2 #include <string>
   3
   4 #include "lexeme_id.h"
   5 #include "lexeme_impl.h"
   6
   7 using namespace utakata::lexeme;
   8 using namespace utakata::utf8_string;
   9
  10 smart_ptr<ILexeme> utakata::lexeme::makeOpenParen()
  11 {
  12     return smart_ptr<ILexeme>(new OpenParen());
  13 }
  14
  15 smart_ptr<ILexeme> utakata::lexeme::makeEOS()
  16 {
  17     return smart_ptr<ILexeme>(new EOS());
  18 }
  19
  20 smart_ptr<ILexeme> utakata::lexeme::makeCloseParen()
  21 {
  22     return smart_ptr<ILexeme>(new CloseParen());
  23 }
  24
  25 smart_ptr<ILexeme> utakata::lexeme::makeBackQuote()
  26 {
  27     return smart_ptr<ILexeme>(new BackQuote());
  28 }
  29
  30 smart_ptr<ILexeme> utakata::lexeme::makeQuote()
  31 {
  32     return smart_ptr<ILexeme>(new Quote());
  33 }
  34
  35 smart_ptr<ILexeme> utakata::lexeme::makeDot()
  36 {
  37     return smart_ptr<ILexeme>(new Dot());
  38 }
  39
  40 smart_ptr<ILexeme> utakata::lexeme::makeIdentifier(const utakata::utf8_string::UTF8String& str)
  41 {
  42     return smart_ptr<ILexeme>(new Identifier(str));
  43 }
  44
  45 smart_ptr<ILexeme> utakata::lexeme::makeString(const utakata::utf8_string::UTF8String& str)
  46 {
  47     return smart_ptr<ILexeme>(new String(str));
  48 }
  49
  50 smart_ptr<ILexeme> utakata::lexeme::makeUnquoteSplicing(const utakata::utf8_string::UTF8String& str)
  51 {
  52     return smart_ptr<ILexeme>(new UnquoteSplicing());
  53 }
  54
  55 smart_ptr<ILexeme> utakata::lexeme::makeUnquote()
  56 {
  57     return smart_ptr<ILexeme>(new Unquote());
  58 }
  59
  60 smart_ptr<ILexeme> utakata::lexeme::makeByteVector()
  61 {
  62     return smart_ptr<ILexeme>(new ByteVector());
  63 }
  64
  65 smart_ptr<ILexeme> utakata::lexeme::makeVector()
  66 {
  67     return smart_ptr<ILexeme>(new Vector());
  68 }
  69
  70 smart_ptr<ILexeme> utakata::lexeme::makeSyntax()
  71 {
  72     return smart_ptr<ILexeme>(new Syntax());
  73 }
  74
  75 smart_ptr<ILexeme> utakata::lexeme::makeQuasiSyntax()
  76 {
  77     return smart_ptr<ILexeme>(new QuasiSyntax());
  78 }
  79
  80 smart_ptr<ILexeme> utakata::lexeme::makeUnsyntaxSplicing()
  81 {
  82     return smart_ptr<ILexeme>(new UnsyntaxSplicing());
  83 }
  84
  85 smart_ptr<ILexeme> utakata::lexeme::makeUnsyntax()
  86 {
  87     return smart_ptr<ILexeme>(new Unsyntax());
  88 }
  89
  90 smart_ptr<ILexeme> utakata::lexeme::makeCharactor(const utakata::utf8_string::UTF8String& str)
  91 {
  92     return smart_ptr<ILexeme>(new Charactor(str));
  93 }
  94
  95 smart_ptr<ILexeme> utakata::lexeme::makeBoolean(const smart_ptr<utakata::utf8_string::UTF8Char>& ch)
  96 {
  97     return smart_ptr<ILexeme>(new Boolean(ch));
  98 }
  99
 100 smart_ptr<ILexeme> utakata::lexeme::makeNanImaginary(const utakata::utf8_string::UTF8String& str,
 101                                                      bool exact)
 102 {
 103     return smart_ptr<ILexeme>(new Number(utakata::utf8_string::UTF8String(),
 104                                          str, exact, 10));
 105 }
 106
 107 smart_ptr<ILexeme> utakata::lexeme::makeInfImaginary(const utakata::utf8_string::UTF8String& str,
 108                                                      bool exact)
 109 {
 110     return smart_ptr<ILexeme>(new Number(utakata::utf8_string::UTF8String(),
 111                                          str, exact, 10));
 112 }
 113
 114 smart_ptr<ILexeme> utakata::lexeme::makeImaginaryOnly(const utakata::utf8_string::UTF8String& str,
 115                                                       bool exact)
 116 {
 117
 118     return smart_ptr<ILexeme>(new Number(utakata::utf8_string::UTF8String(),
 119                                          str, exact, 10));
 120 }
 121
 122 smart_ptr<ILexeme> utakata::lexeme::makeNumber(const utakata::utf8_string::UTF8String& real,
 123                                                const utakata::utf8_string::UTF8String& imagin,
 124                                                bool exact, int radix)
 125 {
 126     return smart_ptr<ILexeme>(new Number(real, imagin, exact, radix));
 127 }
 128
 129
 130 // 各lexemeの実装
 131
 132 ///////////////
 133 // OpenParen //
 134 ///////////////
 135
 136 const utakata::lexeme::LexemeID OpenParen::getID() const
 137 {
 138     return utakata::lexeme::LexemeID::openParenthesis;
 139 }
 140
 141 smart_ptr<utakata::utf8_string::UTF8String> OpenParen::toString() const
 142 {
 143     smart_ptr<utakata::utf8_string::UTF8String> p(new utf8_string::UTF8String);
 144     *p += std::string("(");
 145     return p;
 146 }
 147
 148 /////////
 149 // EOF //
 150 /////////
 151
 152 const utakata::lexeme::LexemeID EOS::getID() const
 153 {
 154     return utakata::lexeme::LexemeID::eos;
 155 }
 156
 157 smart_ptr<utakata::utf8_string::UTF8String> EOS::toString() const
 158 {
 159     smart_ptr<utakata::utf8_string::UTF8String> p(new utf8_string::UTF8String);
 160     *p += std::string("");
 161     return p;
 162 }
 163
 164
 165 ////////////////
 166 // CloseParen //
 167 ////////////////
 168
 169 const utakata::lexeme::LexemeID CloseParen::getID() const
 170 {
 171     return utakata::lexeme::LexemeID::closeParenthesis;
 172 }
 173
 174 smart_ptr<utakata::utf8_string::UTF8String> CloseParen::toString() const
 175 {
 176     smart_ptr<utakata::utf8_string::UTF8String> p(new utf8_string::UTF8String);
 177     *p += std::string(")");
 178     return p;
 179 }
 180
 181 ///////////////
 182 // BackQuote //
 183 ///////////////
 184
 185 const utakata::lexeme::LexemeID BackQuote::getID() const
 186 {
 187     return utakata::lexeme::LexemeID::backquote;
 188 }
 189
 190 smart_ptr<utakata::utf8_string::UTF8String> BackQuote::toString() const
 191 {
 192     smart_ptr<utakata::utf8_string::UTF8String> p(new utf8_string::UTF8String);
 193     *p += std::string("`");
 194     return p;
 195 }
 196
 197 ///////////
 198 // Quote //
 199 ///////////
 200
 201 const utakata::lexeme::LexemeID Quote::getID() const
 202 {
 203     return utakata::lexeme::LexemeID::quote;
 204 }
 205
 206 smart_ptr<utakata::utf8_string::UTF8String> Quote::toString() const
 207 {
 208     smart_ptr<utakata::utf8_string::UTF8String> p(new utf8_string::UTF8String);
 209     *p += std::string("'");
 210     return p;
 211 }
 212
 213 /////////
 214 // Dot //
 215 /////////
 216
 217 const utakata::lexeme::LexemeID Dot::getID() const
 218 {
 219     return utakata::lexeme::LexemeID::dot;
 220 }
 221
 222 smart_ptr<utakata::utf8_string::UTF8String> Dot::toString() const
 223 {
 224     smart_ptr<utakata::utf8_string::UTF8String> p(new utf8_string::UTF8String);
 225     *p += std::string(".");
 226     return p;
 227 }
 228
 229 /////////////////////
 230 // UnquoteSplicing //
 231 /////////////////////
 232
 233 const utakata::lexeme::LexemeID UnquoteSplicing::getID() const
 234 {
 235     return utakata::lexeme::LexemeID::unquoteSplicing;
 236 }
 237
 238 smart_ptr<utakata::utf8_string::UTF8String> UnquoteSplicing::toString() const
 239 {
 240     smart_ptr<utakata::utf8_string::UTF8String> p(new utf8_string::UTF8String);
 241     *p += std::string(",@");
 242     return p;
 243 }
 244
 245 ////////////////
 246 // ByteVector //
 247 ////////////////
 248
 249 const utakata::lexeme::LexemeID ByteVector::getID() const
 250 {
 251     return utakata::lexeme::LexemeID::byteVector;
 252 }
 253
 254 smart_ptr<utakata::utf8_string::UTF8String> ByteVector::toString() const
 255 {
 256     smart_ptr<utakata::utf8_string::UTF8String> p(new utf8_string::UTF8String);
 257     *p += std::string("#vu8(");
 258     return p;
 259 }
 260
 261 ////////////////
 262 // Vector //
 263 ////////////////
 264
 265 const utakata::lexeme::LexemeID Vector::getID() const
 266 {
 267     return utakata::lexeme::LexemeID::vector;
 268 }
 269
 270 smart_ptr<utakata::utf8_string::UTF8String> Vector::toString() const
 271 {
 272     smart_ptr<utakata::utf8_string::UTF8String> p(new utf8_string::UTF8String);
 273     *p += std::string("#vu8(");
 274     return p;
 275 }
 276
 277 /////////////
 278 // Unquote //
 279 /////////////
 280
 281 const utakata::lexeme::LexemeID Unquote::getID() const
 282 {
 283     return utakata::lexeme::LexemeID::unquote;
 284 }
 285
 286 smart_ptr<utakata::utf8_string::UTF8String> Unquote::toString() const
 287 {
 288     smart_ptr<utakata::utf8_string::UTF8String> p(new utf8_string::UTF8String);
 289     *p += std::string(",");
 290     return p;
 291 }
 292
 293 ////////////
 294 // Syntax //
 295 ////////////
 296
 297 const utakata::lexeme::LexemeID Syntax::getID() const
 298 {
 299     return utakata::lexeme::LexemeID::syntax;
 300 }
 301
 302 smart_ptr<utakata::utf8_string::UTF8String> Syntax::toString() const
 303 {
 304     smart_ptr<utakata::utf8_string::UTF8String> p(new utf8_string::UTF8String);
 305     *p += std::string("#'");
 306     return p;
 307 }
 308
 309 /////////////////
 310 // QuasiSyntax //
 311 /////////////////
 312
 313 const utakata::lexeme::LexemeID QuasiSyntax::getID() const
 314 {
 315     return utakata::lexeme::LexemeID::quasiSyntax;
 316 }
 317
 318 smart_ptr<utakata::utf8_string::UTF8String> QuasiSyntax::toString() const
 319 {
 320     smart_ptr<utakata::utf8_string::UTF8String> p(new utf8_string::UTF8String);
 321     *p += std::string("#`");
 322     return p;
 323 }
 324
 325 //////////////
 326 // Unsyntax //
 327 //////////////
 328
 329 const utakata::lexeme::LexemeID Unsyntax::getID() const
 330 {
 331     return utakata::lexeme::LexemeID::unsyntax;
 332 }
 333
 334 smart_ptr<utakata::utf8_string::UTF8String> Unsyntax::toString() const
 335 {
 336     smart_ptr<utakata::utf8_string::UTF8String> p(new utf8_string::UTF8String);
 337     *p += std::string("#,");
 338     return p;
 339 }
 340
 341 //////////////////////
 342 // UnsyntaxSplicing //
 343 //////////////////////
 344
 345 const utakata::lexeme::LexemeID UnsyntaxSplicing::getID() const
 346 {
 347     return utakata::lexeme::LexemeID::unsyntaxSplicing;
 348 }
 349
 350 smart_ptr<utakata::utf8_string::UTF8String> UnsyntaxSplicing::toString() const
 351 {
 352     smart_ptr<utakata::utf8_string::UTF8String> p(new utf8_string::UTF8String);
 353     *p += std::string("#,@");
 354     return p;
 355 }
 356
 357 ////////////////
 358 // Identifier //
 359 ////////////////
 360
 361 Identifier::Identifier(const utakata::utf8_string::UTF8String& str) :
 362     str_(new utakata::utf8_string::UTF8String(str))
 363 {}
 364
 365 const utakata::lexeme::LexemeID Identifier::getID() const
 366 {
 367     return utakata::lexeme::LexemeID::identifier;
 368 }
 369
 370 smart_ptr<utakata::utf8_string::UTF8String> Identifier::toString() const
 371 {
 372     return str_;
 373 }
 374
 375 /////////////
 376 // String  //
 377 /////////////
 378
 379 String::String(const utakata::utf8_string::UTF8String& str) :
 380     str_(new utakata::utf8_string::UTF8String(str))
 381 {}
 382
 383 const utakata::lexeme::LexemeID String::getID() const
 384 {
 385     return utakata::lexeme::LexemeID::string;
 386 }
 387
 388 smart_ptr<utakata::utf8_string::UTF8String> String::toString() const
 389 {
 390     return str_;
 391 }
 392
 393 ////////////
 394 // Number //
 395 ////////////
 396
 397 Number::Number(const UTF8String& real,
 398                const UTF8String& imagin,
 399                bool exact, int radix) :
 400     real_(new UTF8String(real)), imagin_(new UTF8String(imagin)),
 401     exact_(exact), radix_(radix)
 402 {
 403 }
 404
 405 const utakata::lexeme::LexemeID Number::getID() const
 406 {
 407     return utakata::lexeme::LexemeID::number;
 408 }
 409
 410 smart_ptr<utakata::utf8_string::UTF8String> Number::toString() const
 411 {
 412     return smart_ptr<UTF8String>(new UTF8String(*real_ + *imagin_));
 413 }
 414
 415 ///////////////
 416 // Charactor //
 417 ///////////////
 418
 419 Charactor::Charactor(const UTF8String& ch) : ch_(new UTF8String(ch))
 420 {}
 421
 422 const utakata::lexeme::LexemeID Charactor::getID() const
 423 {
 424     return utakata::lexeme::LexemeID::charactor;
 425 }
 426
 427 smart_ptr<utakata::utf8_string::UTF8String> Charactor::toString() const
 428 {
 429     return ch_;
 430 }
 431
 432 /////////////
 433 // Boolean //
 434 /////////////
 435
 436 Boolean::Boolean(const smart_ptr<UTF8Char>& ch) : str_(new UTF8String())
 437 {
 438     *str_ += *ch;
 439 }
 440
 441 const utakata::lexeme::LexemeID Boolean::getID() const
 442 {
 443     return utakata::lexeme::LexemeID::boolean;
 444 }
 445
 446 smart_ptr<utakata::utf8_string::UTF8String> Boolean::toString() const
 447 {
 448     return str_;
 449 }