Output.cpp

   1 #include "Parser.hpp"
   2
   3 #include <iostream>
   4 #include <iomanip>
   5
   6 #define CYPA 16
   7
   8 void CYAddressOf::Output(std::ostream &out) const {
   9     rhs_->Output(out, 1);
  10     out << ".$()";
  11 }
  12
  13 void CYArgument::Output(std::ostream &out) const {
  14     if (name_ != NULL) {
  15         out << *name_;
  16         if (value_ != NULL)
  17             out << ":";
  18     }
  19     if (value_ != NULL)
  20         value_->Output(out, false);
  21     if (next_ != NULL) {
  22         if (next_->name_ == NULL)
  23             out << ',';
  24         else
  25             out << ' ';
  26         next_->Output(out);
  27     }
  28 }
  29
  30 void CYArray::Output(std::ostream &out) const {
  31     out << '[';
  32     if (elements_ != NULL)
  33         elements_->Output(out);
  34     out << ']';
  35 }
  36
  37 void CYAssignment::Output(std::ostream &out) const {
  38     lhs_->Output(out, Precedence() - 1);
  39     out << Operator();
  40     rhs_->Output(out, Precedence());
  41 }
  42
  43 void CYBoolean::Output(std::ostream &out) const {
  44     out << (Value() ? "true" : "false");
  45 }
  46
  47 void CYBreak::Output(std::ostream &out) const {
  48     out << "break";
  49     if (label_ != NULL)
  50         out << ' ' << *label_;
  51     out << ';';
  52 }
  53
  54 void CYCall::Output(std::ostream &out) const {
  55     function_->Output(out, 2);
  56     out << '(';
  57     if (arguments_ != NULL)
  58         arguments_->Output(out);
  59     out << ')';
  60 }
  61
  62 void CYCatch::Output(std::ostream &out) const {
  63     out << "catch(" << *name_ << ')';
  64     code_->Output(out, true);
  65 }
  66
  67 void CYCondition::Output(std::ostream &out) const {
  68     test_->Output(out, Precedence() - 1);
  69     out << '?';
  70     if (true_ != NULL)
  71         true_->Output(out, CYPA);
  72     out << ':';
  73     false_->Output(out, CYPA);
  74 }
  75
  76 void CYContinue::Output(std::ostream &out) const {
  77     out << "continue";
  78     if (label_ != NULL)
  79         out << ' ' << *label_;
  80     out << ';';
  81 }
  82
  83 void CYClause::Output(std::ostream &out) const {
  84     if (case_ != NULL) {
  85         out << "case";
  86         case_->Output(out);
  87     } else
  88         out << "default";
  89     out << ':';
  90     if (code_ != NULL)
  91         code_->Output(out, false);
  92     out << *next_;
  93 }
  94
  95 void CYDeclaration::Part(std::ostream &out) const {
  96     out << "var ";
  97     Output(out);
  98 }
  99
 100 void CYDeclaration::Output(std::ostream &out) const {
 101     out << *identifier_;
 102     if (initialiser_ != NULL) {
 103         out << '=';
 104         initialiser_->Output(out, CYPA);
 105     }
 106 }
 107
 108 void CYDeclarations::Part(std::ostream &out) const {
 109     out << "var ";
 110
 111     const CYDeclarations *declaration(this);
 112   output:
 113     out << *declaration->declaration_;
 114     declaration = declaration->next_;
 115
 116     if (declaration != NULL) {
 117         out << ',';
 118         goto output;
 119     }
 120 }
 121
 122 void CYDeclarations::Output(std::ostream &out) const {
 123     Part(out);
 124     out << ';';
 125 }
 126
 127 void CYDoWhile::Output(std::ostream &out) const {
 128     out << "do ";
 129     code_->Output(out, false);
 130     out << "while(";
 131     test_->Output(out);
 132     out << ';';
 133 }
 134
 135 void CYElement::Output(std::ostream &out) const {
 136     if (value_ != NULL)
 137         value_->Output(out, CYPA);
 138     if (next_ != NULL || value_ == NULL)
 139         out << ',';
 140     if (next_ != NULL)
 141         next_->Output(out);
 142 }
 143
 144 void CYEmpty::Output(std::ostream &out) const {
 145     out << ';';
 146 }
 147
 148 void CYEmpty::Output(std::ostream &out, bool block) const {
 149     if (next_ != NULL)
 150         CYSource::Output(out, block);
 151     else
 152         out << "{}";
 153 }
 154
 155 void CYExpress::Output(std::ostream &out) const {
 156     expression_->Output(out);
 157     out << ';';
 158 }
 159
 160 void CYExpression::Part(std::ostream &out) const {
 161     // XXX: this should notice "in" expressions
 162     // XXX: this should handle LeftHandSideExpression
 163     Output(out);
 164 }
 165
 166 void CYCompound::Output(std::ostream &out) const {
 167     if (CYExpression *expression = expressions_)
 168         for (;;) {
 169             expression->Output(out);
 170             expression = expression->next_;
 171             if (expression == NULL)
 172                 break;
 173             out << ',';
 174         }
 175 }
 176
 177 void CYExpression::Output(std::ostream &out, unsigned precedence) const {
 178     bool protect(precedence < Precedence());
 179     if (protect)
 180         out << '(';
 181     Output(out);
 182     if (protect)
 183         out << ')';
 184 }
 185
 186 void CYFor::Output(std::ostream &out) const {
 187     out << "for(";
 188     if (initialiser_ != NULL)
 189         initialiser_->Part(out);
 190     out << ';';
 191     if (test_ != NULL)
 192         test_->Output(out);
 193     out << ';';
 194     if (increment_ != NULL)
 195         increment_->Output(out);
 196     out << ')';
 197     code_->Output(out, false);
 198 }
 199
 200 void CYForIn::Output(std::ostream &out) const {
 201     out << "for(";
 202     initialiser_->Part(out);
 203     out << " in ";
 204     set_->Output(out);
 205     out << ')';
 206     code_->Output(out, false);
 207 }
 208
 209 void CYFunction::Output(std::ostream &out) const {
 210     CYLambda::Output(out);
 211 }
 212
 213 void CYIf::Output(std::ostream &out) const {
 214     out << "if(";
 215     test_->Output(out);
 216     out << ')';
 217     true_->Output(out, true);
 218     if (false_ != NULL) {
 219         out << "else ";
 220         false_->Output(out, false);
 221     }
 222 }
 223
 224 void CYIndirect::Output(std::ostream &out) const {
 225     rhs_->Output(out, 1);
 226     out << "[0]";
 227 }
 228
 229 void CYInfix::Output(std::ostream &out) const {
 230     lhs_->Output(out, Precedence());
 231     out << Operator();
 232     rhs_->Output(out, Precedence() - 1);
 233 }
 234
 235 void CYLambda::Output(std::ostream &out) const {
 236     out << "function";
 237     if (name_ != NULL)
 238         out << ' ' << *name_;
 239     out << '(';
 240     if (parameters_ != NULL)
 241         out << *parameters_;
 242     out << ')';
 243     body_->Output(out, true);
 244 }
 245
 246 void CYMember::Output(std::ostream &out) const {
 247     object_->Output(out, Precedence());
 248     out << '[';
 249     property_->Output(out);
 250     out << ']';
 251 }
 252
 253 void CYMessage::Output(std::ostream &out) const {
 254     out << "objc_msgSend(";
 255     self_->Output(out, CYPA);
 256     out << ",\"";
 257     for (CYArgument *argument(arguments_); argument != NULL; argument = argument->next_)
 258         if (argument->name_ != NULL) {
 259             out << *argument->name_;
 260             if (argument->value_ != NULL)
 261                 out << ':';
 262         }
 263     out << "\"";
 264     for (CYArgument *argument(arguments_); argument != NULL; argument = argument->next_)
 265         if (argument->value_ != NULL) {
 266             out << ",";
 267             argument->value_->Output(out, CYPA);
 268         }
 269     out << ')';
 270 }
 271
 272 void CYNew::Output(std::ostream &out) const {
 273     out << "new";
 274     // XXX: I don't /always/ need this character
 275     out << ' ';
 276     constructor_->Output(out, Precedence());
 277     out << '(';
 278     if (arguments_ != NULL)
 279         arguments_->Output(out);
 280     out << ')';
 281 }
 282
 283 void CYNull::Output(std::ostream &out) const {
 284     CYWord::Output(out);
 285 }
 286
 287 void CYNumber::Output(std::ostream &out) const {
 288     // XXX: this is not a useful formatting
 289     out << Value();
 290 }
 291
 292 void CYObject::Output(std::ostream &out) const {
 293     out << '{';
 294     if (property_ != NULL)
 295         property_->Output(out);
 296     out << '}';
 297 }
 298
 299 void CYParameter::Output(std::ostream &out) const {
 300     out << *name_;
 301     if (next_ != NULL) {
 302         out << ',';
 303         out << *next_;
 304     }
 305 }
 306
 307 void CYPostfix::Output(std::ostream &out) const {
 308     lhs_->Output(out, Precedence());
 309     out << Operator();
 310 }
 311
 312 void CYPrefix::Output(std::ostream &out) const {
 313     out << Operator();
 314     rhs_->Output(out, Precedence());
 315 }
 316
 317 void CYProperty::Output(std::ostream &out) const {
 318     out << *name_ << ':';
 319     value_->Output(out, CYPA);
 320     if (next_ != NULL) {
 321         out << ',';
 322         next_->Output(out);
 323     }
 324 }
 325
 326 void CYReturn::Output(std::ostream &out) const {
 327     out << "return";
 328     if (value_ != NULL) {
 329         out << ' ';
 330         value_->Output(out);
 331     }
 332     out << ';';
 333 }
 334
 335 void CYSelector::Output(std::ostream &out) const {
 336     out << '"';
 337     if (name_ != NULL)
 338         name_->Output(out);
 339     out << '"';
 340 }
 341
 342 void CYSelectorPart::Output(std::ostream &out) const {
 343     if (name_ != NULL)
 344         out << *name_;
 345     if (value_)
 346         out << ':';
 347     if (next_ != NULL)
 348         next_->Output(out);
 349 }
 350
 351 void CYSource::Show(std::ostream &out) const {
 352     for (const CYSource *next(this); next != NULL; next = next->next_)
 353         next->Output(out, false);
 354 }
 355
 356 void CYSource::Output(std::ostream &out, bool block) const {
 357     if (!block && next_ == NULL)
 358         Output(out);
 359     else {
 360         out << '{';
 361         Show(out);
 362         out << '}';
 363     }
 364 }
 365
 366 void CYString::Output(std::ostream &out) const {
 367     out << '\"';
 368     for (const char *value(value_), *end(value_ + size_); value != end; ++value)
 369         switch (*value) {
 370             case '"': out << "\\\""; break;
 371             case '\\': out << "\\\\"; break;
 372             case '\b': out << "\\b"; break;
 373             case '\f': out << "\\f"; break;
 374             case '\n': out << "\\n"; break;
 375             case '\r': out << "\\r"; break;
 376             case '\t': out << "\\t"; break;
 377             case '\v': out << "\\v"; break;
 378
 379             default:
 380                 if (*value < 0x20 || *value >= 0x7f)
 381                     out << "\\x" << std::setbase(16) << std::setw(2) << std::setfill('0') << unsigned(*value);
 382                 else
 383                     out << *value;
 384         }
 385     out << '\"';
 386 }
 387
 388 void CYSwitch::Output(std::ostream &out) const {
 389     out << "switch(";
 390     value_->Output(out);
 391     out << "){";
 392     if (clauses_ != NULL)
 393         out << *clauses_;
 394     out << '}';
 395 }
 396
 397 void CYThis::Output(std::ostream &out) const {
 398     CYWord::Output(out);
 399 }
 400
 401 void CYThrow::Output(std::ostream &out) const {
 402     out << "throw";
 403     if (value_ != NULL) {
 404         out << ' ';
 405         value_->Output(out);
 406     }
 407     out << ';';
 408 }
 409
 410 void CYTry::Output(std::ostream &out) const {
 411     out << "try";
 412     try_->Output(out, true);
 413     if (catch_ != NULL)
 414         out << catch_;
 415     if (finally_ != NULL) {
 416         out << "finally";
 417         finally_->Output(out, true);
 418     }
 419 }
 420
 421 void CYVariable::Output(std::ostream &out) const {
 422     out << *name_;
 423 }
 424
 425 void CYWhile::Output(std::ostream &out) const {
 426     out << "while(";
 427     test_->Output(out);
 428     out << ')';
 429     code_->Output(out, false);
 430 }
 431
 432 void CYWith::Output(std::ostream &out) const {
 433     out << "with(";
 434     scope_->Output(out);
 435     out << ')';
 436     code_->Output(out, false);
 437 }
 438
 439 void CYWord::Output(std::ostream &out) const {
 440     out << Value();
 441 }