uspace/app/sbi/src/input.c

   1 /*
   2  * Copyright (c) 2010 Jiri Svoboda
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /** @file Input module
  30  *
  31  * Reads source code. Currently input can be read from a file (standard
  32  * case), from a string literal (when parsing builtin code) or interactively
  33  * from the user.
  34  */
  35
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include "mytypes.h"
  39 #include "os/os.h"
  40 #include "strtab.h"
  41
  42 #include "input.h"
  43
  44 /** Size of input buffer. XXX This limits the maximum line length. */
  45 #define INPUT_BUFFER_SIZE 256
  46
  47 static errno_t input_init_file(input_t *input, const char *fname);
  48 static void input_init_interactive(input_t *input);
  49 static void input_init_string(input_t *input, const char *str);
  50
  51 /** Create new input object for reading from file.
  52  *
  53  * @param input         Place to store pointer to new input object.
  54  * @param fname         Name of file to read from.
  55  *
  56  * @return              EOK on success, ENOMEM when allocation fails,
  57  *                      ENOENT when opening file fails.
  58  */
  59 errno_t input_new_file(input_t **input, const char *fname)
  60 {
  61         *input = malloc(sizeof(input_t));
  62         if (*input == NULL)
  63                 return ENOMEM;
  64
  65         return input_init_file(*input, fname);
  66 }
  67
  68 /** Create new input object for reading from interactive input.
  69  *
  70  * @param input         Place to store pointer to new input object.
  71  * @return              EOK on success, ENOMEM when allocation fails.
  72  */
  73 errno_t input_new_interactive(input_t **input)
  74 {
  75         *input = malloc(sizeof(input_t));
  76         if (*input == NULL)
  77                 return ENOMEM;
  78
  79         input_init_interactive(*input);
  80         return EOK;
  81 }
  82
  83 /** Create new input object for reading from string.
  84  *
  85  * @param input         Place to store pointer to new input object.
  86  * @param str           String literal from which to read input.
  87  * @return              EOK on success, ENOMEM when allocation fails.
  88  */
  89 errno_t input_new_string(input_t **input, const char *str)
  90 {
  91         *input = malloc(sizeof(input_t));
  92         if (*input == NULL)
  93                 return ENOMEM;
  94
  95         input_init_string(*input, str);
  96         return EOK;
  97 }
  98
  99 /** Initialize input object for reading from file.
 100  *
 101  * @param input         Input object.
 102  * @param fname         Name of file to read from.
 103  *
 104  * @return              EOK on success, ENOENT when opening file fails.
 105 */
 106 static errno_t input_init_file(input_t *input, const char *fname)
 107 {
 108         FILE *f;
 109
 110         f = fopen(fname, "rt");
 111         if (f == NULL)
 112                 return ENOENT;
 113
 114         input->buffer = malloc(INPUT_BUFFER_SIZE);
 115         if (input->buffer == NULL) {
 116                 printf("Memory allocation failed.\n");
 117                 exit(1);
 118         }
 119
 120         input->name = os_str_dup(fname);
 121         input->str = NULL;
 122         input->line_no = 0;
 123         input->fin = f;
 124         return EOK;
 125 }
 126
 127 /** Initialize input object for reading from interactive input.
 128  *
 129  * @param input         Input object.
 130  */
 131 static void input_init_interactive(input_t *input)
 132 {
 133         input->buffer = malloc(INPUT_BUFFER_SIZE);
 134         if (input->buffer == NULL) {
 135                 printf("Memory allocation failed.\n");
 136                 exit(1);
 137         }
 138
 139         input->name = "<user-input>";
 140         input->str = NULL;
 141         input->line_no = 0;
 142         input->fin = NULL;
 143 }
 144
 145 /** Initialize input object for reading from string.
 146  *
 147  * @param input         Input object.
 148  * @param str           String literal from which to read input.
 149  */
 150 static void input_init_string(input_t *input, const char *str)
 151 {
 152         input->buffer = malloc(INPUT_BUFFER_SIZE);
 153         if (input->buffer == NULL) {
 154                 printf("Memory allocation failed.\n");
 155                 exit(1);
 156         }
 157
 158         input->name = "<builtin>";
 159         input->str = str;
 160         input->line_no = 0;
 161         input->fin = NULL;
 162 }
 163
 164 /** Get next line of input.
 165  *
 166  * The pointer stored in @a line is owned by @a input and is valid until the
 167  * next call to input_get_line(). The caller is not to free it. The returned
 168  * line is terminated with '\n' if another line is coming (potentially empty).
 169  * An empty line ("") signals end of input.
 170  *
 171  * @param input         Input object.
 172  * @param line          Place to store pointer to next line.
 173  *
 174  * @return              EOK on success, EIO on failure.
 175  */
 176 errno_t input_get_line(input_t *input, char **line)
 177 {
 178         const char *prompt;
 179         const char *sp;
 180         char *dp;
 181         char *line_p;
 182         size_t cnt;
 183
 184         if (input->fin != NULL) {
 185                 /* Reading from file. */
 186                 if (fgets(input->buffer, INPUT_BUFFER_SIZE, input->fin) == NULL)
 187                         input->buffer[0] = '\0';
 188
 189                 if (ferror(input->fin))
 190                         return EIO;
 191
 192                 *line = input->buffer;
 193         } else if (input->str != NULL) {
 194                 /* Reading from a string constant. */
 195
 196                 /* Copy one line. */
 197                 sp = input->str;
 198                 dp = input->buffer;
 199                 cnt = 0;
 200                 while (*sp != '\n' && *sp != '\0' &&
 201                     cnt < INPUT_BUFFER_SIZE - 2) {
 202                         *dp++ = *sp++;
 203                 }
 204
 205                 /* Advance to start of next line. */
 206                 if (*sp == '\n')
 207                         *dp++ = *sp++;
 208
 209                 *dp = '\0';
 210                 input->str = sp;
 211                 *line = input->buffer;
 212         } else {
 213                 /* Interactive mode */
 214                 if (input->line_no == 0)
 215                         prompt = "sbi> ";
 216                 else
 217                         prompt = "...  ";
 218
 219                 fflush(stdout);
 220                 if (os_input_line(prompt, &line_p) != EOK)
 221                         return EIO;
 222
 223                 *line = line_p;
 224         }
 225
 226         ++input->line_no;
 227         return EOK;
 228 }
 229
 230 /** Get number of the last provided line of input.
 231  *
 232  * @param input         Input object.
 233  * @return              Line number of the last provided input line (counting
 234  *                      from 1 up).
 235  */
 236 int input_get_line_no(input_t *input)
 237 {
 238         return input->line_no;
 239 }