git.cworth.org Git - glenv/blob - glenv.c

   1 /* Copyright © 2013, Intel Corporation
   2  *
   3  * Permission is hereby granted, free of charge, to any person obtaining a copy
   4  * of this software and associated documentation files (the "Software"), to deal
   5  * in the Software without restriction, including without limitation the rights
   6  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   7  * copies of the Software, and to permit persons to whom the Software is
   8  * furnished to do so, subject to the following conditions:
   9  *
  10  * The above copyright notice and this permission notice shall be included in
  11  * all copies or substantial portions of the Software.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  18  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  19  * THE SOFTWARE.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <stdbool.h>
  25 #include <limits.h>
  26 #include <getopt.h>
  27
  28 #include <glaze.h>
  29
  30 typedef struct options {
  31         bool query;
  32         char *vendor;
  33         char *renderer;
  34         char *version;
  35         char *shading_language_version;
  36         char *extensions;
  37         char *extensions_whitelist;
  38         char *extensions_blacklist;
  39 } options_t;
  40
  41 static void
  42 export_options (options_t *options)
  43 {
  44         if (options->query)
  45                 setenv ("GLENV_QUERY", "1", 1);
  46         else
  47                 unsetenv ("GLENV_QUERY");
  48
  49         if (options->vendor)
  50                 setenv ("GLENV_GL_VENDOR", options->vendor, 1);
  51         else
  52                 unsetenv ("GLENV_GL_VENDOR");
  53
  54         if (options->renderer)
  55                 setenv ("GLENV_GL_RENDERER", options->renderer, 1);
  56         else
  57                 unsetenv ("GLENV_GL_RENDERER");
  58
  59         if (options->version)
  60                 setenv ("GLENV_GL_VERSION", options->version, 1);
  61         else
  62                 unsetenv ("GLENV_GL_VERSION");
  63
  64         if (options->shading_language_version)
  65                 setenv ("GLENV_GL_SHADING_LANGUAGE_VERSION",
  66                         options->shading_language_version, 1);
  67         else
  68                 unsetenv ("GLENV_GL_SHADING_LANGUAGE_VERSION");
  69
  70         if (options->extensions)
  71                 setenv ("GLENV_GL_EXTENSIONS", options->extensions, 1);
  72         else
  73                 unsetenv ("GLENV_GL_EXTENSIONS");
  74
  75         if (options->extensions_whitelist)
  76                 setenv ("GLENV_GL_EXTENSIONS_WHITELIST", options->extensions_whitelist, 1);
  77         else
  78                 unsetenv ("GLENV_GL_EXTENSIONS_WHITELIST");
  79
  80         if (options->extensions_blacklist)
  81                 setenv ("GLENV_GL_EXTENSIONS_BLACKLIST", options->extensions_blacklist, 1);
  82         else
  83                 unsetenv ("GLENV_GL_EXTENSIONS_BLACKLIST");
  84 }
  85
  86 static void
  87 usage (void)
  88 {
  89         printf ("Usage: glenv [OPTIONS...] <program> [program args...]\n"
  90                 "\n"
  91                 "Execute <program> with alternate OpenGL environment.\n"
  92                 "\n"
  93                 "Options:\n"
  94                 "       -h, --help                      Show this help message.\n"
  95                 "       -q, --query                     Query and report current environment\n"
  96                 "                                       then terminate program.\n"
  97                 "       --vendor=STR                    Set GL_VENDOR to STR.\n"
  98                 "       --renderer=STR                  Set GL_RENDERER to STR.\n"
  99                 "       --version=STR                   Set GL_VERSION to STR.\n"
 100                 "       --shading-language-version=STR  Set GL_SHADING_LANGUAGE_VERSION to STR.\n"
 101                 "       --extensions=STR                Set GL_EXTENSIONS to STR.\n"
 102                 "       --extensions-whitelist=STR      Remove from GL_EXTENSIONS all names\n"
 103                 "                                       not appearing in STR (space-separated).\n"
 104                 "       --extensions-blacklist=STR      Remove from GL_EXTENSIONS any names\n"
 105                 "                                       appearing in STR (space-separated).\n");
 106 }
 107
 108 enum {
 109         VENDOR_OPT = CHAR_MAX + 1,
 110         RENDERER_OPT,
 111         VERSION_OPT,
 112         SHADING_LANGUAGE_VERSION_OPT,
 113         EXTENSIONS_OPT,
 114         EXTENSIONS_WHITELIST_OPT,
 115         EXTENSIONS_BLACKLIST_OPT
 116 };
 117
 118 static void
 119 invalid_combination (const char *second, const char *first)
 120 {
 121         fprintf (stderr, "Error: Option %s cannot be specified after %s\n",
 122                  second, first);
 123         exit (1);
 124 }
 125
 126 int
 127 main (int argc, char *argv[])
 128 {
 129         int opt;
 130         options_t options = {
 131                 .query = false,
 132                 .vendor = NULL,
 133                 .renderer = NULL,
 134                 .version = NULL,
 135                 .shading_language_version = NULL,
 136                 .extensions = NULL,
 137                 .extensions_whitelist = NULL,
 138                 .extensions_blacklist = NULL
 139         };
 140
 141         const char *short_options="hq";
 142         const struct option long_options[] = {
 143                 {"help", no_argument, 0, 'h'},
 144                 {"query", no_argument, 0, 'q'},
 145                 {"vendor", required_argument, 0, VENDOR_OPT},
 146                 {"renderer", required_argument, 0, RENDERER_OPT},
 147                 {"version", required_argument, 0, VERSION_OPT},
 148                 {"shading-language-version", required_argument, 0, SHADING_LANGUAGE_VERSION_OPT},
 149                 {"extensions", required_argument, 0, EXTENSIONS_OPT},
 150                 {"extensions-whitelist", required_argument, 0, EXTENSIONS_WHITELIST_OPT},
 151                 {"extensions-blacklist", required_argument, 0, EXTENSIONS_BLACKLIST_OPT},
 152                 {0, 0, 0, 0}
 153         };
 154
 155         while (1)
 156         {
 157                 opt = getopt_long (argc, argv, short_options, long_options, NULL);
 158                 if (opt == -1)
 159                         break;
 160
 161                 switch (opt) {
 162                 case 'h':
 163                         usage ();
 164                         return 0;
 165                 case '?':
 166                         exit (1);
 167                         break;
 168                 case 'q':
 169                         options.query = true;
 170                         break;
 171                 case VENDOR_OPT:
 172                         options.vendor = optarg;
 173                         break;
 174                 case RENDERER_OPT:
 175                         options.renderer = optarg;
 176                         break;
 177                 case VERSION_OPT:
 178                         options.version = optarg;
 179                         break;
 180                 case SHADING_LANGUAGE_VERSION_OPT:
 181                         options.shading_language_version = optarg;
 182                         break;
 183                 case EXTENSIONS_OPT:
 184                         if (options.extensions_whitelist)
 185                                 invalid_combination ("--extensions", "--extensions-whitelist");
 186                         if (options.extensions_blacklist)
 187                                 invalid_combination ("--extensions", "--extensions-blacklist");
 188                         options.extensions = optarg;
 189                         break;
 190                 case EXTENSIONS_WHITELIST_OPT:
 191                         if (options.extensions)
 192                                 invalid_combination ("--extensions-whitelist", "--extensions");
 193                         if (options.extensions_blacklist)
 194                                 invalid_combination ("--extensions-whitelist", "--extensions-blacklist");
 195                         options.extensions_whitelist = optarg;
 196                         break;
 197                 case EXTENSIONS_BLACKLIST_OPT:
 198                         if (options.extensions)
 199                                 invalid_combination ("--extensions-blacklist", "--extensions");
 200                         if (options.extensions_whitelist)
 201                                 invalid_combination ("--extensions-blacklist", "--extensions-whitelist");
 202                         options.extensions_blacklist = optarg;
 203                         break;
 204                 default:
 205                         fprintf (stderr, "Internal error: "
 206                                  "unexpected getopt value: %d\n", opt);
 207                         exit (1);
 208                 }
 209         }
 210
 211         if (optind >= argc) {
 212                 fprintf (stderr, "Error: No program name provided, "
 213                          "see (glenv --help)\n");
 214                 exit (1);
 215         }
 216
 217         export_options (&options);
 218
 219         glaze_set_first_gl_call_callback ("glenv_first_gl_call");
 220
 221         glaze_execute (argc - optind, &argv[optind], "libglenv.so");
 222
 223         /* If glaze_execute returns then something went wrong. */
 224         return 1;
 225 }