Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | 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 <sys/types.h>
  25. #include <sys/stat.h>
  26. #include <fcntl.h>
  27. #include <unistd.h>
  28. #include <string.h>
  29. #include <errno.h>
  30. #include "glcpp.h"
  31. #include "main/mtypes.h"
  32. #include "main/shaderobj.h"
  33.  
  34. extern int yydebug;
  35.  
  36. void
  37. _mesa_reference_shader(struct gl_context *ctx, struct gl_shader **ptr,
  38.                        struct gl_shader *sh)
  39. {
  40.    *ptr = sh;
  41. }
  42.  
  43. /* Read from fd until EOF and return a string of everything read.
  44.  */
  45. static char *
  46. load_text_fd (void *ctx, int fd)
  47. {
  48. #define CHUNK 4096
  49.         char *text = NULL;
  50.         ssize_t text_size = 0;
  51.         ssize_t total_read = 0;
  52.         ssize_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 = read (fd, text + total_read, CHUNK);
  64.                 if (bytes < 0) {
  65.                         fprintf (stderr, "Error while reading: %s\n",
  66.                                  strerror (errno));
  67.                         ralloc_free (text);
  68.                         return NULL;
  69.                 }
  70.  
  71.                 if (bytes == 0) {
  72.                         break;
  73.                 }
  74.  
  75.                 total_read += bytes;
  76.         }
  77.  
  78.         text[total_read] = '\0';
  79.  
  80.         return text;
  81. }
  82.  
  83. static char *
  84. load_text_file(void *ctx, const char *filename)
  85. {
  86.         char *text;
  87.         int fd;
  88.  
  89.         if (filename == NULL || strcmp (filename, "-") == 0)
  90.                 return load_text_fd (ctx, STDIN_FILENO);
  91.  
  92.         fd = open (filename, O_RDONLY);
  93.         if (fd < 0) {
  94.                 fprintf (stderr, "Failed to open file %s: %s\n",
  95.                          filename, strerror (errno));
  96.                 return NULL;
  97.         }
  98.  
  99.         text = load_text_fd (ctx, fd);
  100.  
  101.         close(fd);
  102.  
  103.         return text;
  104. }
  105.  
  106. int
  107. main (int argc, char *argv[])
  108. {
  109.         char *filename = NULL;
  110.         void *ctx = ralloc(NULL, void*);
  111.         char *info_log = ralloc_strdup(ctx, "");
  112.         const char *shader;
  113.         int ret;
  114.  
  115.         if (argc) {
  116.                 filename = argv[1];
  117.         }
  118.  
  119.         shader = load_text_file (ctx, filename);
  120.         if (shader == NULL)
  121.            return 1;
  122.  
  123.         ret = preprocess(ctx, &shader, &info_log, NULL, API_OPENGL);
  124.  
  125.         printf("%s", shader);
  126.         fprintf(stderr, "%s", info_log);
  127.  
  128.         ralloc_free(ctx);
  129.  
  130.         return ret;
  131. }
  132.