cl-wrapper.c

linux下电话本所依赖的库文件

	else if (strcmp (cpu, "i686") == 0 ||
		 strcmp (cpu, "pentiumpro") == 0 ||
		 strcmp (cpu, "pentium2") == 0 ||
		 strcmp (cpu, "pentium3") == 0 ||
		 strcmp (cpu, "pentium3") == 0 ||
		 strcmp (cpu, "pentium4") == 0)
	  strcat (cmdline, " -G6");
	else
	  fprintf (stderr, "Ignored CPU flag %s\n", argv[i]);
      }
    else if (strcmp (argv[i], "-mms-bitfields") == 0)
      ;				/* Obviously the default... */
    else if (strncmp (argv[i], "-W", 2) == 0)
      {
	if (strlen (argv[i]) > 3 && argv[i][3] == ',')
	  fprintf (stderr, "Ignored subprocess option %s\n", argv[i]);
	else if (strcmp (argv[i], "-Wall") == 0)
	  {
	    if (cl_version >= 13)
	      strcat (cmdline, " -Wall");
	    else
	      strcat (cmdline, " -W4");
	    for (k = 0; ignore_warnings_with_Wall[k] != 0; k++)
	      fprintf (force_header,
		       "#pragma warning(disable:%d)\n",
		       ignore_warnings_with_Wall[k]);
	  }
	else if (strcmp (argv[i], "-Werror") == 0)
	  strcat (cmdline, " -WX");
	else
	  {
	    for (k = 0;
		 (gcc_warnings[k].gcc != NULL &&
		  strcmp (argv[i]+2, gcc_warnings[k].gcc) != 0);
		 k++)
	      ;
	    if (gcc_warnings[k].gcc == NULL)
	      fprintf (stderr, "Ignored warning option %s\n", argv[i]);
	    else
	      {
		const char *p = gcc_warnings[k].cl;

		while (p)
		  {
		    const char *q = strchr (p, ',');
		    if (q == NULL)
		      q = p + strlen (p);
		    if (cl_version >= 13)
		      sprintf (cmdline + strlen (cmdline),
			       " -w2%.*s", q - p, p);
		    else
		      fprintf (force_header, "#pragma warning(2:%.*s)\n",
			       q - p, p);
		    if (*q)
		      p = q+1;
		    else
		      p = NULL;
		  }
	      }
	  }
      }
    else if (strcmp (argv[i], "-w") == 0)
      strcat (cmdline, " -w");
    else if (strcmp (argv[i], "-v") == 0)
      verbose++;
    else if (strcmp (argv[i], "--version") == 0)
      version = 1;
    else if (argv[i][0] == '-')
      fprintf (stderr, "Ignored flag %s\n", argv[i]);
    else
      {
	lastdot = strrchr (argv[i], '.');
	if (lastdot != NULL && (stricmp (lastdot, ".c") == 0
				|| stricmp (lastdot, ".cpp") == 0
				|| stricmp (lastdot, ".cc") == 0))
	  {
	    nsources++;
	    strcat (cmdline, " ");
	    if (stricmp (lastdot, ".cc") == 0)
	      strcat (cmdline, "-Tp");
	    source = argv[i];
	    strcat (cmdline, backslashify (argv[i]));
	  }
	else if (lastdot != NULL && (stricmp (lastdot, ".obj") == 0 ||
				     stricmp (lastdot, ".o") == 0))
	  objects[object_ix++] = argv[i];
	else if (lastdot != NULL && stricmp (lastdot, ".a") == 0)
	  {
	    /* Copy .a file to .lib. Or what? Rename temporarily?
	     * Nah, too risky. A symlink would of course be ideal, but
	     * this is Windows.
	     */
	    char *libfilename = malloc (strlen (argv[i]) + 20);
	    char *copy_command = malloc (strlen (argv[i]) * 2 + 20);

	    sprintf (libfilename, "%.*s",
		     lastdot - argv[i], backslashify (argv[i]));
	    strcat (libfilename, ".temp.lib");

	    sprintf (copy_command, "copy %s %s",
		     backslashify (argv[i]), libfilename);
	    fprintf (stderr, "%s\n", copy_command);
	    if (system (copy_command) != 0)
	      {
		fprintf (stderr, "Failed\n");
		exit (1);
	      }
	    strcat (cmdline, " ");
	    strcat (cmdline, libfilename);
	  }
	else if (lastdot != NULL && stricmp (lastdot, ".def") == 0)
	  def_file = argv[i];
	else
	  fprintf (stderr, "Ignored argument: %s\n", argv[i]);
      }
}

int
main (int argc,
      char **argv)
{
  FILE *pipe;
  char buf[100];

  int retval;

  int i, j, k;
  char *p;

  libraries = malloc (argc * sizeof (char *));
  libdirs = malloc ((argc+10) * sizeof (char *));
  objects = malloc (argc * sizeof (char *));

  for (k = 0, i = 1; i < argc; i++)
    k += strlen (argv[i]);

  k += 1000 + argc;
  cmdline = malloc (k);

  pipe = _popen ("cl 2>&1", "r");
  if (pipe == NULL)
    {
      fprintf (stderr, "Could not open pipe from cl, is Microsoft Visual C installed?\n");
      exit (-1);
    }

  fgets (buf, sizeof (buf), pipe);
  p = strstr (buf, "Version ");

  if (p == NULL ||
      sscanf (p + strlen ("Version "), "%f", &cl_version) != 1)
    {
      fprintf (stderr,
	       "Could not deduce version of Microsoft compiler, "
	       "assuming 12\n");
      cl_version = 12;
    }

  /* -MD: Use msvcrt.dll runtime */
  strcpy (cmdline, "cl");
  
  cmdline_compiler = strdup (cmdline);
  cmdline_args = cmdline + strlen (cmdline);
  strcat (cmdline, " -MD -Zm500");

  /* Make cl more like gcc. */
  open_force_header ();
  for (k = 0; error_warnings[k] != 0; k++)
    fprintf (force_header,
	     "#pragma warning(error:%d)\n", error_warnings[k]);
  for (k = 0; disable_warnings[k] != 0; k++)
    fprintf (force_header,
	     "#pragma warning(disable:%d)\n", disable_warnings[k]);

  process_argv (argc, (const char **) argv);

  fclose (force_header);
      
  if (version)
    strcat (cmdline, " -c nul.c");
  else
    {
      if (!verbose)
	strcat (cmdline, " -nologo");

      if (output_executable != NULL)
	{
	  if (stricmp (executable_type, ".dll") == 0)
	    strcat (cmdline, " -LD");
	}

      if (debug)
	strcat (cmdline, " -Zi");

      if (nsources == 0)
	{
	  FILE *dummy = fopen (DUMMY_C_FILE, "w");
	  fprintf (dummy, "static int foobar = 42;\n");
	  fclose (dummy);

	  strcat (cmdline, " " DUMMY_C_FILE);
	}

      strcat (cmdline, " -FI" FORCE_HEADER);

      if (!output && !compileonly)
	strcat (cmdline, " -Fea.exe");

      if (!compileonly)
	{
	  strcat (cmdline, " -link");

	  for (i = 0; i < object_ix; i++)
	    {
	      strcat (cmdline, " ");
	      strcat (cmdline, backslashify (objects[i]));
	    }

	  for (i = 0; i < lib_ix; i++)
	    {
	      for (j = 0; j < libdir_ix; j++)
		{
		  char b[1000];

		  sprintf (b, "%s\\%s.lib", libdirs[j], libraries[i]);
		  if (access (b, 4) == 0)
		    {
		      strcat (cmdline, " ");
		      strcat (cmdline, b);
		      break;
		    }
		  sprintf (b, "%s\\lib%s.lib", libdirs[j], libraries[i]);
		  if (access (b, 4) == 0)
		    {
		      strcat (cmdline, " ");
		      strcat (cmdline, b);
		      break;
		    }
		}

	      if (j == libdir_ix)
		{
		  strcat (cmdline, " ");
		  strcat (cmdline, libraries[i]);
		  strcat (cmdline, ".lib");
		}
	    }

	  for (k = 0; default_libs[k]; k++)
	    {
	      strcat (cmdline, " ");
	      strcat (cmdline, default_libs[k]);
	      strcat (cmdline, ".lib");
	    }
	}
    }
  
  fprintf (stderr, "%s\n", cmdline);

  if (strlen (cmdline) >= 200)	/* Real limit unknown */
    {
      FILE *atfile = fopen (INDIRECT_CMDLINE_FILE, "wt");
      char *indirect_cmdline = malloc (strlen (cmdline_compiler) +
				       strlen (INDIRECT_CMDLINE_FILE) + 10);

      if (atfile == NULL)
	{
	  fprintf (stderr, "Could not open %s for writing: %s\n",
		   INDIRECT_CMDLINE_FILE, strerror (errno));
	  exit (-1);
	}

      fprintf (atfile, "%s\n", cmdline_args);
      fclose (atfile);

      sprintf (indirect_cmdline, "%s @" INDIRECT_CMDLINE_FILE,
	       cmdline_compiler);
      retval = system (indirect_cmdline);
#if 0
      remove (INDIRECT_CMDLINE_FILE);
#endif
    }
  else
    {
      retval = system (cmdline);
    }

  if (nsources == 0)
    remove (DUMMY_C_FILE);

#if 0
  remove (FORCE_HEADER);
#endif

  /* Produce a dummy make dependency file if asked to... Perhaps it
   * would be feasible to look for this info from the object file, to
   * produce a real dependency file?
   */
  if (retval == 0 && MD_flag && MF_file != NULL)
    {
      FILE *MF = fopen (MF_file, "wt");

      if (MF == NULL)
	{
	  fprintf (stderr, "Could not open %s for writing: %s\n",
		   MF_file, strerror (errno));
	  exit (-1);
	}

      if (MT_file != NULL)
	fprintf (MF, "%s ", MT_file);

      fprintf (MF, "%s: %s\n", output_object, source);

      fclose (MF);
    }

  exit (retval);
}