drv_preproc_ifr.cpp

这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用于网络游戏医学图像网关的高qos要求.更详细的内容可阅读相应的材料

    if (slash_found) 
      {
        n += 1;
      }

    return n;
}

// File names
static char     tmp_file[128];
static char     tmp_ifile[128];

// Pass input through preprocessor
void
DRV_pre_proc (const char *myfile)
{
  long  readfromstdin = I_FALSE;

  // Macro to avoid "warning: unused parameter" type warning.
  ACE_UNUSED_ARG (readfromstdin);

  const char* tmpdir = idl_global->temp_dir ();

  ACE_OS::strcpy (tmp_file, tmpdir);
  ACE_OS::strcpy (tmp_ifile, tmpdir);

  ACE_OS::strcat (tmp_file, "idlf_XXXXXX");
  ACE_OS::strcat (tmp_ifile, "idli_XXXXXX");

  (void) ACE_OS::mktemp (tmp_file); ACE_OS::strcat (tmp_file, ".cc");
  (void) ACE_OS::mktemp (tmp_ifile); ACE_OS::strcat (tmp_ifile, ".cc");

  UTL_String *tmp = 0;

  be_global->filename (ACE_const_cast (char *, myfile));

  if (strcmp (myfile, "standard input") == 0)
    {
      ACE_NEW (tmp,
               UTL_String (tmp_ifile));
      idl_global->set_filename (tmp);

      ACE_NEW (tmp,
               UTL_String (tmp_ifile));
      idl_global->set_main_filename (tmp);

      ACE_NEW (tmp,
               UTL_String (DRV_stripped_name (tmp_ifile)));
      idl_global->set_stripped_filename (tmp);

      ACE_NEW (tmp,
               UTL_String (tmp_ifile));
      idl_global->set_real_filename (tmp);

      DRV_copy_input (stdin, 
                      tmp_ifile, 
                      "standard input");

      idl_global->set_read_from_stdin (I_TRUE);
    }
  else
    {
      FILE *fd = fopen (myfile, "r");
      DRV_copy_input (fd, 
                      tmp_ifile, 
                      myfile);
      fclose (fd);

      idl_global->set_read_from_stdin (I_FALSE);

      ACE_NEW (tmp,
               UTL_String (myfile));
      idl_global->set_filename (tmp);

      ACE_NEW (tmp,
               UTL_String (myfile));
      idl_global->set_main_filename (tmp);

      ACE_Auto_String_Free safety (ACE_OS::strdup (myfile));
      ACE_NEW (tmp,
               UTL_String (DRV_stripped_name (safety.get ())));
      idl_global->set_stripped_filename (tmp);

      ACE_NEW (tmp,
               UTL_String (tmp_ifile));
      idl_global->set_real_filename (tmp);
    }

  // We use ACE instead of the (low level) fork facilities, this also
  // works on NT.
  ACE_Process process;

  // For complex builds, the default command line buffer size of 1024
  // is sometimes not enough. We use 4096 here.
  ACE_Process_Options cpp_options (1,       // Inherit environment.
                                   TAO_IDL_COMMAND_LINE_BUFFER_SIZE);

  DRV_cpp_expand_output_arg (tmp_file);
  DRV_cpp_putarg (tmp_ifile);
  DRV_cpp_putarg (0); // Null terminate the arglist.

  cpp_options.command_line (arglist);
  
  /// Remove any existing output file.
  (void) ACE_OS::unlink (tmp_file);

  ACE_HANDLE fd = ACE_INVALID_HANDLE;

  if (output_arg_format == 0)
    {
      // If the following open() fails, then we're either being hit with a
      // symbolic link attack, or another process opened the file before
      // us.
      fd = ACE_OS::open (tmp_file,
                         O_WRONLY | O_CREAT | O_EXCL,
                         ACE_DEFAULT_FILE_PERMS);

      if (fd == ACE_INVALID_HANDLE)
        {
          ACE_ERROR ((LM_ERROR,
                      "%s%s%s%s",
                      idl_global->prog_name (),
                      ACE_TEXT (": cannot open temp file "),
                      tmp_file,
                      ACE_TEXT (" for writing\n")));

          return;
        }

      cpp_options.set_handles (ACE_INVALID_HANDLE, fd);
    }

  if (process.spawn (cpp_options) == ACE_INVALID_PID)
    {
      ACE_ERROR ((LM_ERROR,
                  "%s%s%s%s",
                  idl_global->prog_name (),
                  ACE_TEXT (": spawn of "),
                  arglist[0],
                  ACE_TEXT (" failed\n")));

      return;
    }

  if (fd != ACE_INVALID_HANDLE)
    {
      // Close the output file on the parent process.
      if (ACE_OS::close (fd) == -1)
        {
          ACE_ERROR ((LM_ERROR,
                      "%s%s%s%s",
                      idl_global->prog_name (),
                      ACE_TEXT (": cannot close temp file"),
                      tmp_file,
                      ACE_TEXT (" on parent\n")));

          return;
        }
    }

  // Remove the null termination and the input file from the arglist,
  // the next file will the previous args.
  argcount -= 2;

  ACE_exitcode status = 0;
  if (process.wait (&status) == ACE_INVALID_PID)
    {
      ACE_ERROR ((LM_ERROR,
                  "%s%s",
                  idl_global->prog_name (),
                  ACE_TEXT (": wait for child process failed\n")));

      return;
    }

  if (WIFEXITED ((status)))
    {
      // child terminated normally?
      if (WEXITSTATUS ((status)) != 0)
        {
          errno = WEXITSTATUS ((status));

          ACE_ERROR ((LM_ERROR,
                      "%s%s%s%s",
                      idl_global->prog_name (),
                      ACE_TEXT (": preprocessor "),
                      arglist[0],
                      ACE_TEXT (" returned with an error\n")));

          ACE_OS::exit (1);
        }
    }
  else
    {
      // child didn't call exit(); perhaps it received a signal?
      errno = EINTR;

      ACE_ERROR ((LM_ERROR,
                  "%s%s%s%s",
                  idl_global->prog_name (),
                  ACE_TEXT (": preprocessor "),
                  arglist[0],
                  ACE_TEXT (" appears to have been interrupted\n")));

      ACE_OS::exit (1);
    }
  // TODO: Manage problems in the pre-processor, in the previous
  // version the current process would exit if the pre-processor
  // returned with error.

  FILE *yyin = ACE_OS::fopen (tmp_file, "r");

  if (yyin == NULL) 
    {
      ACE_ERROR ((LM_ERROR,
                  "%s%s %s\n",
                  idl_global->prog_name (),
                  ACE_TEXT (": Could not open cpp output file"),
                  tmp_file));

      ACE_OS::exit (99);
    }

  FE_set_yyin (ACE_reinterpret_cast (File *, yyin));

  if (idl_global->compile_flags() & IDL_CF_ONLY_PREPROC) 
    {
      FILE *preproc = ACE_OS::fopen (tmp_file, "r");
      char buffer[ACE_MAXLOGMSGLEN];
      size_t bytes;

      if (preproc == NULL)
        {
          ACE_ERROR ((LM_ERROR,
                      "%s: Could not open cpp output file: %s\n",
                      idl_global->prog_name (),
                      tmp_file));

          ACE_OS::exit (99);
        }

      // ACE_DEBUG sends to stderr - we want stdout for this dump
      // of the preprocessor output. So we modify the singleton that
      // was created in this process. Since IDL_CF_ONLY_PREPROC causes
      // an (almost) immediate exit below, we don't have to restore
      // the singleton's default parameters.
      ACE_Log_Msg *out = ACE_Log_Msg::instance ();
      out->msg_ostream (&cout);
      out->clr_flags (ACE_Log_Msg::STDERR);
      out->set_flags (ACE_Log_Msg::OSTREAM);

      while ((bytes = ACE_OS::fread (buffer, 
                                     sizeof (char), 
                                     ACE_MAXLOGMSGLEN - 1, 
                                     preproc)) 
          != 0)
        {
          buffer[bytes] = 0;

          ACE_DEBUG ((LM_DEBUG, 
                      buffer));
        }

      ACE_OS::fclose (preproc);
  }

  if (ACE_OS::unlink (tmp_ifile) == -1) 
    {
      ACE_ERROR ((LM_ERROR,
                  "%s%s %s\n",
                  idl_global->prog_name (),
                  ACE_TEXT (": Could not remove cpp input file"),
                  tmp_ifile));

      ACE_OS::exit (99);
    }

#if !defined (ACE_WIN32) || defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0)
  if (ACE_OS::unlink (tmp_file) == -1) 
    {
      ACE_ERROR ((LM_ERROR,
                  "%s%s %s\n",
                  idl_global->prog_name (),
                  ACE_TEXT (": Could not remove cpp output file"),
                  tmp_file));

      ACE_OS::exit (99);
    }
#endif /* ACE_HAS_WINNT4 && ACE_HAS_WINNT4 != 0 */

  if (idl_global->compile_flags() & IDL_CF_ONLY_PREPROC)
    {
      ACE_OS::exit (0);
    }
}

// We really need to know whether this line is a "#include ...". If
// so, we would like to separate the "file name" and keep that in the
// idl_global. We need them to produce "#include's in the stubs and
// skeletons.
void
DRV_check_for_include (const char* buf)
{
  const char* r = buf;
  const char* h;

  // Skip initial '#'.
  if (*r != '#')
    {
      return;
    }
  else
    {
      r++;
    }

  // Skip the tabs and spaces.
  while (*r == ' ' || *r == '\t')
    {
      r++;
    }

  // Probably we are at the word `include`. If not return.
  if (*r != 'i')
    {
      return;
    }

  // Check whether this word is `include` or no.
  const char* include_str = "include";

  for (size_t ii = 0; 
       ii < strlen ("include") && *r != '\0' && *r != ' ' && *r != '\t'; 
       r++, ii++)
    {
      // Return if it doesn't match.
      if (include_str [ii] != *r)
        {
          return;
        }
    }

  // Next thing is finding the file that has been `#include'd. Skip
  // all the blanks and tabs and reach the startng " or < character.
  for (; (*r != '"') && (*r != '<'); r++)
    {
      if (*r == '\n' || *r == '\0')
        {
          return;
        }
    }

  // Decide on the end char.
  char end_char = '"';

  if (*r == '<')
    {
      end_char = '>';
    }

  // Skip this " or <.
  r++;

  // Store this position.
  h = r;

  // Found this in idl.ll. Decides the file to be standard input.
  if (*h == '\0')
    {
      return;
    }

  // Find the closing " or < character.
  for (; *r != end_char; r++)
    {
      continue;
    }

  // Make a new string for this file name.
  char* file_name = 0;
  ACE_NEW (file_name,
           char [r - h + 1]);

  // Copy the char's.
  size_t fi = 0;

  for (; h != r; fi++, h++)
    {
      file_name [fi] = *h;
    }

  // Terminate the string.
  file_name [fi] = '\0';

  // Put Microsoft-style pathnames into a canonical form.
  size_t i = 0;

  for (size_t j = 0; file_name [j] != '\0'; i++, j++)
    {
      if (file_name [j] == '\\' && file_name [j + 1] == '\\')
        {
          j++;
        }

      file_name [i] = file_name [j];
    }

  // Terminate this string.
  file_name [i] = '\0';

  // Store in the idl_global, unless it's "orb.idl" -
  // we don't want to generate header includes for that.
  if (ACE_OS::strcmp (file_name, "orb.idl"))
    {
      idl_global->add_to_included_idl_files (file_name);
    }
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
  template class ACE_Env_Value<char*>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
# pragma instantiate  ACE_Env_Value<char*>
#endif