Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright © 2010 Intel Corporation
  3.  *
  4.  * Permission is hereby granted, free of charge, to any person obtaining a
  5.  * copy of this software and associated documentation files (the "Software"),
  6.  * to deal in the Software without restriction, including without limitation
  7.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  8.  * and/or sell copies of the Software, and to permit persons to whom the
  9.  * Software is furnished to do so, subject to the following conditions:
  10.  *
  11.  * The above copyright notice and this permission notice (including the next
  12.  * paragraph) shall be included in all copies or substantial portions of the
  13.  * Software.
  14.  *
  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20.  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21.  * DEALINGS IN THE SOFTWARE.
  22.  */
  23.  
  24. #include <stdio.h>
  25. #include <string.h>
  26. #include <errno.h>
  27. #include <getopt.h>
  28.  
  29. #include "glcpp.h"
  30. #include "main/mtypes.h"
  31. #include "main/shaderobj.h"
  32.  
  33. extern int yydebug;
  34.  
  35. void
  36. _mesa_reference_shader(struct gl_context *ctx, struct gl_shader **ptr,
  37.                        struct gl_shader *sh)
  38. {
  39.    (void) ctx;
  40.    *ptr = sh;
  41. }
  42.  
  43. /* Read from fp until EOF and return a string of everything read.
  44.  */
  45. static char *
  46. load_text_fp (void *ctx, FILE *fp)
  47. {
  48. #define CHUNK 4096
  49.         char *text = NULL;
  50.         size_t text_size = 0;
  51.         size_t total_read = 0;
  52.         size_t bytes;
  53.  
  54.         while (1) {
  55.                 if (total_read + CHUNK + 1 > text_size) {
  56.                         text_size = text_size ? text_size * 2 : CHUNK + 1;
  57.                         text = reralloc_size (ctx, text, text_size);
  58.                         if (text == NULL) {
  59.                                 fprintf (stderr, "Out of memory\n");
  60.                                 return NULL;
  61.                         }
  62.                 }
  63.                 bytes = fread (text + total_read, 1, CHUNK, fp);
  64.                 total_read += bytes;
  65.  
  66.                 if (bytes < CHUNK) {
  67.                         break;
  68.                 }
  69.         }
  70.  
  71.         text[total_read] = '\0';
  72.  
  73.         return text;
  74. }
  75.  
  76. static char *
  77. load_text_file(void *ctx, const char *filename)
  78. {
  79.         char *text;
  80.         FILE *fp;
  81.  
  82.         if (filename == NULL || strcmp (filename, "-") == 0)
  83.                 return load_text_fp (ctx, stdin);
  84.  
  85.         fp = fopen (filename, "r");
  86.         if (fp == NULL) {
  87.                 fprintf (stderr, "Failed to open file %s: %s\n",
  88.                          filename, strerror (errno));
  89.                 return NULL;
  90.         }
  91.  
  92.         text = load_text_fp (ctx, fp);
  93.  
  94.         fclose(fp);
  95.  
  96.         return text;
  97. }
  98.  
  99. /* Initialize only those things that glcpp cares about.
  100.  */
  101. static void
  102. init_fake_gl_context (struct gl_context *gl_ctx)
  103. {
  104.         gl_ctx->API = API_OPENGL_COMPAT;
  105.         gl_ctx->Const.DisableGLSLLineContinuations = false;
  106. }
  107.  
  108. static void
  109. usage (void)
  110. {
  111.         fprintf (stderr,
  112.                  "Usage: glcpp [OPTIONS] [--] [<filename>]\n"
  113.                  "\n"
  114.                  "Pre-process the given filename (stdin if no filename given).\n"
  115.                  "The following options are supported:\n"
  116.                  "    --disable-line-continuations      Do not interpret lines ending with a\n"
  117.                  "                                      backslash ('\\') as a line continuation.\n");
  118. }
  119.  
  120. enum {
  121.         DISABLE_LINE_CONTINUATIONS_OPT = CHAR_MAX + 1
  122. };
  123.  
  124. const static struct option
  125. long_options[] = {
  126.         {"disable-line-continuations", no_argument, 0, DISABLE_LINE_CONTINUATIONS_OPT },
  127.         {0,                            0,           0, 0 }
  128. };
  129.  
  130. int
  131. main (int argc, char *argv[])
  132. {
  133.         char *filename = NULL;
  134.         void *ctx = ralloc(NULL, void*);
  135.         char *info_log = ralloc_strdup(ctx, "");
  136.         const char *shader;
  137.         int ret;
  138.         struct gl_context gl_ctx;
  139.         int c;
  140.  
  141.         init_fake_gl_context (&gl_ctx);
  142.  
  143.         while ((c = getopt_long(argc, argv, "", long_options, NULL)) != -1) {
  144.                 switch (c) {
  145.                 case DISABLE_LINE_CONTINUATIONS_OPT:
  146.                         gl_ctx.Const.DisableGLSLLineContinuations = true;
  147.                         break;
  148.                 default:
  149.                         usage ();
  150.                         exit (1);
  151.                 }
  152.         }
  153.  
  154.         if (optind + 1 < argc) {
  155.                 printf ("Unexpected argument: %s\n", argv[optind+1]);
  156.                 usage ();
  157.                 exit (1);
  158.         }
  159.         if (optind < argc) {
  160.                 filename = argv[optind];
  161.         }
  162.  
  163.         shader = load_text_file (ctx, filename);
  164.         if (shader == NULL)
  165.            return 1;
  166.  
  167.         ret = glcpp_preprocess(ctx, &shader, &info_log, NULL, &gl_ctx);
  168.  
  169.         printf("%s", shader);
  170.         fprintf(stderr, "%s", info_log);
  171.  
  172.         ralloc_free(ctx);
  173.  
  174.         return ret;
  175. }
  176.