TAO/TAO_IDL/be/be_helper.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    be_helper.cpp
   5  *
   6  * Provides helper classes to print generated code to the output
   7  *
   8  *  @author Aniruddha Gokhale Improvements by Carlos O'Ryan
   9  */
  10 //=============================================================================
  11
  12 #include "be_helper.h"
  13 #include "be_codegen.h"
  14 #include "be_extern.h"
  15 #include "ast_expression.h"
  16 #include "idl_defines.h"
  17 #include "utl_identifier.h"
  18 #include "utl_idlist.h"
  19 #include "utl_string.h"
  20 #include "ace/OS_NS_string.h"
  21 #include "ace/OS_NS_ctype.h"
  22 #include "../../tao/Version.h"
  23
  24 static const char copyright[] =
  25 "// -*- C++ -*-\n"
  26 "/**\n"
  27 " * Code generated by the The ACE ORB (TAO) IDL Compiler v" TAO_VERSION "\n"
  28 " * TAO and the TAO IDL Compiler have been developed by:\n"
  29 " *       Center for Distributed Object Computing\n"
  30 " *       Washington University\n"
  31 " *       St. Louis, MO\n"
  32 " *       USA\n"
  33 " * and\n"
  34 " *       Distributed Object Computing Laboratory\n"
  35 " *       University of California at Irvine\n"
  36 " *       Irvine, CA\n"
  37 " *       USA\n"
  38 " * and\n"
  39 " *       Institute for Software Integrated Systems\n"
  40 " *       Vanderbilt University\n"
  41 " *       Nashville, TN\n"
  42 " *       USA\n"
  43 " *       https://www.isis.vanderbilt.edu/\n"
  44 " *\n"
  45 " * Information about TAO is available at:\n"
  46 " *     https://www.dre.vanderbilt.edu/~schmidt/TAO.html\n"
  47 " **/";
  48
  49 TAO_NL::TAO_NL (void)
  50 {
  51   ACE_UNUSED_ARG (copyright);
  52 }
  53
  54 TAO_NL_2::TAO_NL_2 (void)
  55 {
  56   ACE_UNUSED_ARG (copyright);
  57 }
  58
  59 TAO_INDENT::TAO_INDENT (int do_now)
  60   :  do_now_ (do_now)
  61 {
  62 }
  63
  64 TAO_UNINDENT::TAO_UNINDENT (int do_now)
  65   :  do_now_ (do_now)
  66 {
  67 }
  68
  69 const TAO_NL be_nl;
  70 const TAO_NL_2 be_nl_2;
  71 const TAO_INDENT be_idt;
  72 const TAO_INDENT be_idt_nl (1);
  73 const TAO_UNINDENT be_uidt;
  74 const TAO_UNINDENT be_uidt_nl (1);
  75
  76 // Methods of the TAO_OutStream class.
  77
  78 TAO_OutStream::TAO_OutStream (void)
  79   : fp_ (0),
  80     st_ (TAO_CLI_HDR),
  81     indent_level_ (0)
  82 {
  83   for (unsigned long i = 0; i < be_global->tab_size (); ++i)
  84     {
  85       this->tab_unit_str_ += ' ';
  86     }
  87 }
  88
  89 TAO_OutStream::~TAO_OutStream (void)
  90 {
  91   // Close the underlying I/O handle only if it exists.
  92   if (this->fp_ != 0)
  93     {
  94       ACE_OS::fclose (this->fp_);
  95       this->fp_ = 0;
  96     }
  97
  98   indent_level_ = 0;
  99 }
 100
 101 int
 102 TAO_OutStream::open (const char *fname,
 103                      TAO_OutStream::STREAM_TYPE st)
 104 {
 105   if (fname != 0)
 106     {
 107       // File name exists, open an I/O file handle.
 108       this->fp_ = ACE_OS::fopen (fname, "w");
 109
 110       if (this->fp_ != 0)
 111         {
 112           this->st_ = st;
 113           // Put the copyright notice.  Not for the gperf's temp input
 114           // file.
 115           if (st != TAO_OutStream::TAO_GPERF_INPUT)
 116             {
 117               ACE_OS::fprintf (this->fp_,
 118                                "%s\n",
 119                                copyright);
 120             }
 121
 122           return 0;
 123         }
 124       else
 125         {
 126           return -1;
 127         }
 128     }
 129   else
 130     {
 131       return -1;
 132     }
 133 }
 134
 135 // Set and get the stream type.
 136 void
 137 TAO_OutStream::stream_type (TAO_OutStream::STREAM_TYPE st)
 138 {
 139   this->st_ = st;
 140 }
 141
 142 TAO_OutStream::STREAM_TYPE
 143 TAO_OutStream::stream_type (void)
 144 {
 145   return this->st_;
 146 }
 147
 148 // Return the underlying lowlevel file pointer.
 149 // indentation.
 150 FILE *&
 151 TAO_OutStream::file (void)
 152 {
 153   return this->fp_;
 154 }
 155
 156 int
 157 TAO_OutStream::incr_indent (unsigned short flag)
 158 {
 159   ++indent_level_;
 160
 161   if (flag != 0)
 162     {
 163       return this->indent ();
 164     }
 165   else
 166     {
 167       // Do not indent output.
 168       return 0;
 169     }
 170 }
 171
 172 // Indentation
 173 int
 174 TAO_OutStream::decr_indent (unsigned short flag)
 175 {
 176   --this->indent_level_;
 177   // Just in case somebody gets "unindent happy".
 178   if (this->indent_level_ < 0)
 179     {
 180       // ACE_DEBUG ((LM_DEBUG, "negative indentation?\n"));
 181       this->indent_level_ = 0;
 182     }
 183   if (flag != 0)
 184     {
 185       return this->indent ();
 186     }
 187   else
 188     {
 189       // Do not indent output.
 190       return 0;
 191     }
 192 }
 193
 194 int
 195 TAO_OutStream::reset (void)
 196 {
 197   this->indent_level_ = 0;
 198   return 0;
 199 }
 200
 201 // Indented print.
 202 int
 203 TAO_OutStream::indent (void)
 204 {
 205   // Based on the current indentation level, leave appropriate number of blank
 206   // spaces in the output.
 207   if (this->indent_level_ > 0)
 208     {
 209       for (int i = 0; i < this->indent_level_; i++)
 210         {
 211           ACE_OS::fprintf (this->fp_, "%s", this->tab_unit_str_.c_str ());
 212         }
 213     }
 214
 215   return 0;
 216 }
 217
 218 int
 219 TAO_OutStream::nl (void)
 220 {
 221   ACE_OS::fprintf (this->fp_, "\n");
 222   this->indent ();
 223   return 0;
 224 }
 225
 226 // Macro generation.
 227 int
 228 TAO_OutStream::gen_ifdef_macro (const char *flat_name,
 229                                 const char *suffix,
 230                                 bool add_stream_type_suffix)
 231 {
 232   static char macro [NAMEBUFSIZE];
 233
 234   ACE_OS::memset (macro,
 235                   '\0',
 236                   NAMEBUFSIZE);
 237
 238   ACE_OS::sprintf (macro,
 239                    "_%s_",
 240                    tao_cg->upcase (flat_name));
 241
 242   if (suffix != 0)
 243     {
 244       ACE_OS::strcat (macro, "_");
 245       ACE_OS::strcat (macro, tao_cg->upcase (suffix));
 246       ACE_OS::strcat (macro, "_");
 247     }
 248
 249   // Append a suffix representing the stream type.
 250   if (add_stream_type_suffix)
 251     {
 252       switch (this->st_)
 253         {
 254           case TAO_OutStream::TAO_CLI_HDR:
 255             ACE_OS::strcat (macro, "CH_");
 256             break;
 257           case TAO_OutStream::TAO_CLI_INL:
 258             ACE_OS::strcat (macro, "CI_");
 259             break;
 260           case TAO_OutStream::TAO_CLI_IMPL:
 261             ACE_OS::strcat (macro, "CS_");
 262             break;
 263           case TAO_OutStream::TAO_SVR_HDR:
 264             ACE_OS::strcat (macro, "SH_");
 265             break;
 266           case TAO_OutStream::TAO_IMPL_HDR:
 267             ACE_OS::strcat (macro, "IH_");
 268             break;
 269           case TAO_OutStream::TAO_IMPL_SKEL:
 270             ACE_OS::strcat (macro, "IS_");
 271             break;
 272           case TAO_OutStream::TAO_SVR_INL:
 273             ACE_OS::strcat (macro, "SI_");
 274             break;
 275           case TAO_OutStream::TAO_SVR_IMPL:
 276             ACE_OS::strcat (macro, "SS_");
 277             break;
 278           default:
 279             return -1;
 280         }
 281     }
 282
 283   *this << "\n\n#if !defined (" << macro << ")\n";
 284   *this << "#define " << macro;
 285
 286   return 0;
 287 }
 288
 289 int
 290 TAO_OutStream::gen_endif (void)
 291 {
 292   *this << "\n\n#endif /* end #if !defined */";
 293
 294   return 0;
 295 }
 296
 297 // Printf style variable argument print.
 298 int
 299 TAO_OutStream::print (const char *format, ...)
 300 {
 301   int result = 0;
 302   va_list ap;
 303   va_start (ap, format);
 304   ACE_OSCALL (::vfprintf (this->fp_,
 305                           format,
 306                           ap),
 307               int,
 308               -1,
 309               result);
 310   va_end (ap);
 311
 312   return result;
 313 }
 314
 315 TAO_OutStream &
 316 TAO_OutStream::operator<< (const char *str)
 317 {
 318   ACE_OS::fprintf (this->fp_, "%s", str);
 319   return *this;
 320 }
 321
 322 TAO_OutStream &
 323 TAO_OutStream::operator<< (char ch)
 324 {
 325   ACE_OS::fprintf (this->fp_, "%c", ch);
 326   return *this;
 327 }
 328
 329 TAO_OutStream &
 330 TAO_OutStream::operator<< (const ACE_CString &str)
 331 {
 332   ACE_OS::fprintf (this->fp_, "%s", str.c_str ());
 333   return *this;
 334 }
 335
 336 TAO_OutStream &
 337 TAO_OutStream::operator<< (const ACE_CDR::UShort num)
 338 {
 339   ACE_OS::fprintf (this->fp_,
 340                    "%hu",
 341                    num);
 342
 343   return *this;
 344 }
 345
 346 TAO_OutStream &
 347 TAO_OutStream::operator<< (const ACE_CDR::Short num)
 348 {
 349   ACE_OS::fprintf (this->fp_,
 350                    "%hd",
 351                    num);
 352
 353   return *this;
 354 }
 355
 356 TAO_OutStream &
 357 TAO_OutStream::operator<< (const ACE_CDR::ULong num)
 358 {
 359   ACE_OS::fprintf (this->fp_,
 360                    "%lu",
 361                    (unsigned long) num);
 362
 363   return *this;
 364 }
 365
 366 TAO_OutStream &
 367 TAO_OutStream::operator<< (const ACE_CDR::Long num)
 368 {
 369   ACE_OS::fprintf (this->fp_,
 370                    "%ld",
 371                    (long) num);
 372
 373   return *this;
 374 }
 375
 376 TAO_OutStream &
 377 TAO_OutStream::operator<< (const ACE_CDR::ULongLong num)
 378 {
 379   ACE_OS::fprintf (this->fp_,
 380                    ACE_UINT64_FORMAT_SPECIFIER_ASCII,
 381                    num);
 382
 383   return *this;
 384 }
 385
 386 TAO_OutStream &
 387 TAO_OutStream::operator<< (const ACE_CDR::LongLong num)
 388 {
 389   ACE_OS::fprintf (this->fp_,
 390                    ACE_INT64_FORMAT_SPECIFIER_ASCII,
 391                    num);
 392
 393   return *this;
 394 }
 395
 396 TAO_OutStream &
 397 TAO_OutStream::operator<< (const TAO_NL&)
 398 {
 399   ACE_OS::fprintf (this->fp_ ,
 400                    "\n");
 401   this->indent ();
 402
 403   return *this;
 404 }
 405
 406 TAO_OutStream &
 407 TAO_OutStream::operator<< (const TAO_NL_2&)
 408 {
 409   ACE_OS::fprintf (this->fp_ ,
 410                    "\n");
 411   ACE_OS::fprintf (this->fp_ ,
 412                    "\n");
 413   this->indent ();
 414   return *this;
 415 }
 416
 417 TAO_OutStream &
 418 TAO_OutStream::operator<< (const TAO_INDENT& i)
 419 {
 420   this->incr_indent (0);
 421
 422   if (i.do_now_)
 423     {
 424       this->nl ();
 425     }
 426
 427   return *this;
 428 }
 429
 430 TAO_OutStream &
 431 TAO_OutStream::operator<< (const TAO_UNINDENT& i)
 432 {
 433   this->decr_indent (0);
 434
 435   if (i.do_now_)
 436     {
 437       this->nl ();
 438     }
 439
 440   return *this;
 441 }
 442
 443 TAO_OutStream &
 444 TAO_OutStream::operator<< (Identifier *id)
 445 {
 446   return this->print (id);
 447 }
 448
 449 TAO_OutStream &
 450 TAO_OutStream::operator<< (UTL_IdList *id)
 451 {
 452   return this->print (id);
 453 }
 454
 455 TAO_OutStream &
 456 TAO_OutStream::operator<< (AST_Expression *expr)
 457 {
 458   return this->print (expr);
 459 }
 460
 461 TAO_OutStream &
 462 TAO_OutStream::print (Identifier *id)
 463 {
 464   ACE_OS::fprintf (this->fp_, "%s", id->get_string ());
 465
 466   return *this;
 467 }
 468
 469 TAO_OutStream &
 470 TAO_OutStream::print (UTL_IdList *idl)
 471 {
 472   bool first = true;
 473   bool second = false;
 474   Identifier *id = 0;
 475
 476   for (UTL_IdListActiveIterator i (idl); !i.is_done (); i.next ())
 477     {
 478       if (!first)
 479         {
 480           *this << "::";
 481         }
 482       else if (second)
 483         {
 484           first = second = false;
 485         }
 486
 487       // Print the identifier.
 488       id = i.item ();
 489       *this << id;
 490
 491       if (first)
 492         {
 493           if (ACE_OS::strcmp (id->get_string (), "") != 0
 494               && ACE_OS::strcmp (id->get_string (), "::") != 0)
 495             {
 496               // Does not start with a "".
 497               first = false;
 498             }
 499           else
 500             {
 501               second = true;
 502             }
 503         }
 504     }
 505
 506   return *this;
 507 }
 508
 509 template <typename IntType>
 510 void
 511 signed_int_helper (TAO_OutStream &os, IntType value, IntType min, const char *specifier)
 512 {
 513   /*
 514    * It seems that in C/C++ the minus sign and the bare number are parsed
 515    * separately for negative integer literals. This can cause compilers
 516    * to complain when using the minimum value of a signed integer because
 517    * the number without the minus sign is 1 past the max signed value.
 518    *
 519    * https://stackoverflow.com/questions/65007935
 520    *
 521    * Apparently the workaround is to write it as `VALUE_PLUS_ONE - 1`.
 522    */
 523   const bool min_value = value == min;
 524   if (min_value) ++value;
 525   os.print (specifier, value);
 526   if (min_value) os.print (" - 1");
 527 }
 528
 529 TAO_OutStream&
 530 TAO_OutStream::print (AST_Expression *expr)
 531 {
 532   AST_Expression::AST_ExprValue *ev = expr->ev ();
 533
 534   /// Never happens as far as I know, but just in case...
 535   if (ev == 0)
 536     {
 537       ACE_ERROR ((LM_ERROR,
 538                   ACE_TEXT ("TAO_OutStream::print() - ")
 539                   ACE_TEXT ("expression not evaluated\n")));
 540
 541       return *this;
 542     }
 543
 544   switch (ev->et)
 545     {
 546     case AST_Expression::EV_short:
 547       this->TAO_OutStream::print (ACE_INT32_FORMAT_SPECIFIER_ASCII, ev->u.sval);
 548       break;
 549     case AST_Expression::EV_ushort:
 550       this->TAO_OutStream::print (ACE_INT32_FORMAT_SPECIFIER_ASCII "%c", ev->u.usval, 'U');
 551       break;
 552     case AST_Expression::EV_long:
 553       signed_int_helper<ACE_CDR::Long> (
 554         *this, ev->u.lval, ACE_INT32_MIN, ACE_INT32_FORMAT_SPECIFIER_ASCII);
 555       break;
 556     case AST_Expression::EV_ulong:
 557       this->TAO_OutStream::print (ACE_UINT32_FORMAT_SPECIFIER_ASCII "%c", ev->u.ulval, 'U');
 558       break;
 559     case AST_Expression::EV_longlong:
 560       this->TAO_OutStream::print ("ACE_INT64_LITERAL (");
 561       signed_int_helper<ACE_CDR::LongLong> (
 562         *this, ev->u.llval, ACE_INT64_MIN, ACE_INT64_FORMAT_SPECIFIER_ASCII);
 563       this->TAO_OutStream::print (")");
 564       break;
 565     case AST_Expression::EV_ulonglong:
 566       this->TAO_OutStream::print ("ACE_UINT64_LITERAL (");
 567       this->TAO_OutStream::print (ACE_UINT64_FORMAT_SPECIFIER_ASCII,
 568                                   ev->u.ullval);
 569       this->TAO_OutStream::print (")");
 570       break;
 571     case AST_Expression::EV_float:
 572       this->TAO_OutStream::print ("%f%c", ev->u.fval, 'F');
 573       break;
 574     case AST_Expression::EV_double:
 575       this->TAO_OutStream::print ("%24.16G", ev->u.dval);
 576       break;
 577     case AST_Expression::EV_longdouble:
 578       break;
 579     case AST_Expression::EV_char:
 580       // isprint() sees \ and ' as printable characters
 581       // so we have to test for them first.
 582       if (ev->u.cval == '\\')
 583         this->TAO_OutStream::print ("'\\\\'");
 584       else if (ev->u.cval == '\'')
 585         this->TAO_OutStream::print ("'\\''");
 586
 587       // This handles hex and octal escape sequences
 588       // that would print out as weird characters.
 589       else if (ACE_OS::ace_isprint (ev->u.cval))
 590         this->TAO_OutStream::print ("'%c'", ev->u.cval);
 591       else if (ACE_OS::ace_iscntrl (ev->u.cval))
 592         switch (ev->u.cval)
 593           {
 594             case '\n':
 595               this->TAO_OutStream::print ("'\\n'");
 596               break;
 597             case '\t':
 598               this->TAO_OutStream::print ("'\\t'");
 599               break;
 600             case '\r':
 601               this->TAO_OutStream::print ("'\\r'");
 602               break;
 603             case '\v':
 604               this->TAO_OutStream::print ("'\\v'");
 605               break;
 606             case '\f':
 607               this->TAO_OutStream::print ("'\\f'");
 608               break;
 609             case '\b':
 610               this->TAO_OutStream::print ("'\\b'");
 611               break;
 612             case '\a':
 613               this->TAO_OutStream::print ("'\\a'");
 614               break;
 615             case '\?':
 616               this->TAO_OutStream::print ("'?'");
 617               break;
 618           default:
 619             this->TAO_OutStream::print ("'\\x%x'", ev->u.oval);
 620           }
 621        else
 622         this->TAO_OutStream::print ("'\\x%x'", ev->u.oval);
 623       break;
 624     case AST_Expression::EV_wchar:
 625       this->TAO_OutStream::print ("L'%lc'", ev->u.wcval);
 626       break;
 627     case AST_Expression::EV_octet:
 628       this->TAO_OutStream::print ("0x%02x", ev->u.oval);
 629       break;
 630     case AST_Expression::EV_bool:
 631       this->TAO_OutStream::print ("%s", ev->u.bval ? "true" : "false");
 632       break;
 633     case AST_Expression::EV_string:
 634       this->TAO_OutStream::print ("\"%s\"", ev->u.strval->get_string ());
 635       break;
 636     case AST_Expression::EV_wstring:
 637       this->TAO_OutStream::print ("L\"%s\"", ev->u.wstrval);
 638       break;
 639     case AST_Expression::EV_enum:
 640       this->print (expr->n ());
 641       break;
 642     case AST_Expression::EV_int8:
 643       this->TAO_OutStream::print ("%d", ev->u.int8val);
 644       break;
 645     case AST_Expression::EV_uint8:
 646       this->TAO_OutStream::print ("%uu", ev->u.uint8val);
 647       break;
 648     default:
 649       break;
 650     }
 651
 652   return *this;
 653 }
 654
 655 void TAO_OutStream::insert_comment (const char *file, int line)
 656 {
 657   *this << be_nl << "// TAO_IDL - Generated from" << be_nl
 658         << "// " << file << ':' << static_cast<ACE_CDR::ULong> (line)
 659         << be_nl_2;
 660 }