src/pre-html/pushback.cpp

   1 /*@
   2  * Copyright (c) 2014 - 2017 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
   3  *
   4  * Copyright (C) 2000, 2001, 2003 - 2005 Free Software Foundation, Inc.
   5  *      Written by Gaius Mulley (gaius@glam.ac.uk).
   6  *
   7  * This is free software; you can redistribute it and/or modify it under
   8  * the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2, or (at your option) any later
  10  * version.
  11  *
  12  * This is distributed in the hope that it will be useful, but WITHOUT ANY
  13  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15  * for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with groff; see the file COPYING.  If not, write to the Free Software
  19  * Foundation, 51 Franklin St - Fifth Floor, Boston, MA 02110-1301, USA.
  20  */
  21
  22 #include "config.h"
  23 #include "html-config.h"
  24
  25 #include <sys/types.h>
  26
  27 #include <assert.h>
  28 #include <ctype.h>
  29 #include <errno.h>
  30 #include <signal.h>
  31 #include <stdlib.h>
  32
  33 #include "errarg.h"
  34 #include "error.h"
  35 #include "lib.h"
  36 #include "nonposix.h"
  37 #include "posix.h"
  38 #include "stringclass.h"
  39
  40 #include "pushback.h"
  41 #include "pre-html.h"
  42
  43 #define ERROR(X) \
  44   (void)(fprintf(stderr, "%s:%d error %s\n", __FILE__, __LINE__, X) &&\
  45    (fflush(stderr)) && localexit(1))
  46
  47 pushBackBuffer::pushBackBuffer (char *filename)
  48 {
  49   charStack = (char *)malloc(MAXPUSHBACKSTACK);
  50   if (charStack == 0) {
  51     sys_fatal("malloc");
  52   }
  53   stackPtr = 0;   /* index to push back stack        */
  54   debug    = 0;
  55   verbose  = 0;
  56   eofFound = false;
  57   lineNo   = 1;
  58   if (strcmp(filename, "") != 0) {
  59     if ((stdIn = dup(0)) == -1)
  60       sys_fatal("cannot dup(2)licate standard input");
  61     close(0);
  62     if (open(filename, O_RDONLY) != 0) {
  63       sys_fatal("when trying to open file");
  64     } else {
  65       fileName = filename;
  66     }
  67   }
  68 }
  69
  70 pushBackBuffer::~pushBackBuffer ()
  71 {
  72   if (charStack != 0) {
  73     free(charStack);
  74   }
  75   close(0);
  76   /* restore stdin in file descriptor 0 */
  77   if (dup(stdIn) == -1) /* FIXME use dup2() if possible, not close(0)+dup(2)! */
  78     sys_fatal("cannot restore dup(2)licated standard input");
  79   close(stdIn);
  80 }
  81
  82 /*
  83  *  localexit - wraps exit with a return code to aid the ERROR macro.
  84  */
  85
  86 int localexit (int i)
  87 {
  88   exit(i);
  89   return( 1 );
  90 }
  91
  92 /*
  93  *  getPB - returns a character, possibly a pushed back character.
  94  */
  95
  96 char pushBackBuffer::getPB (void)
  97 {
  98   if (stackPtr>0) {
  99     stackPtr--;
 100     return( charStack[stackPtr] );
 101   } else {
 102     char ch;
 103
 104     if (read(0, &ch, 1) == 1) {
 105       if (verbose) {
 106         printf("%c", ch);
 107       }
 108       if (ch == '\n') {
 109         lineNo++;
 110       }
 111       return( ch );
 112     } else {
 113       eofFound = true;
 114       return( eof );
 115     }
 116   }
 117 }
 118
 119 /*
 120  *  putPB - pushes a character onto the push back stack.
 121  *          The same character is returned.
 122  */
 123
 124 char pushBackBuffer::putPB (char ch)
 125 {
 126   if (stackPtr<MAXPUSHBACKSTACK) {
 127     charStack[stackPtr] = ch ;
 128     stackPtr++;
 129   } else {
 130     ERROR("max push back stack exceeded, increase MAXPUSHBACKSTACK constant");
 131   }
 132   return( ch );
 133 }
 134
 135 /*
 136  *  isWhite - returns true if a white character is found. This character is NOT consumed.
 137  */
 138
 139 static int isWhite (char ch)
 140 {
 141   return( (ch==' ') || (ch == '\t') || (ch == '\n') );
 142 }
 143
 144 /*
 145  *  skipToNewline - skips characters until a newline is seen.
 146  */
 147
 148 void pushBackBuffer::skipToNewline (void)
 149 {
 150   while ((putPB(getPB()) != '\n') && (! eofFound)) {
 151     getPB();
 152   }
 153 }
 154
 155 /*
 156  *  skipUntilToken - skips until a token is seen
 157  */
 158
 159 void pushBackBuffer::skipUntilToken (void)
 160 {
 161   char ch;
 162
 163   while ((isWhite(putPB(getPB())) || (putPB(getPB()) == '#')) && (! eofFound)) {
 164     ch = getPB();
 165     if (ch == '#') {
 166       skipToNewline();
 167     }
 168   }
 169 }
 170
 171 /*
 172  *  isString - returns true if the string, s, matches the pushed back string.
 173  *             if true is returned then this string is consumed, otherwise it is
 174  *             left alone.
 175  */
 176
 177 int pushBackBuffer::isString (const char *s)
 178 {
 179   int length=strlen(s);
 180   int i=0;
 181
 182   while ((i<length) && (putPB(getPB())==s[i])) {
 183     if (getPB() != s[i]) {
 184       ERROR("assert failed");
 185     }
 186     i++;
 187   }
 188   if (i==length) {
 189     return true;
 190   } else {
 191     i--;
 192     while (i>=0) {
 193       if (putPB(s[i]) != s[i]) {
 194         ERROR("assert failed");
 195       }
 196       i--;
 197     }
 198   }
 199   return false;
 200 }
 201
 202 /*
 203  *  isDigit - returns true if the character, ch, is a digit.
 204  */
 205
 206 static int isDigit (char ch)
 207 {
 208   return( ((ch>='0') && (ch<='9')) );
 209 }
 210
 211 /*
 212  *  isHexDigit - returns true if the character, ch, is a hex digit.
 213  */
 214
 215 #if 0
 216 static int isHexDigit (char ch)
 217 {
 218   return( (isDigit(ch)) || ((ch>='a') && (ch<='f')) );
 219 }
 220 #endif
 221
 222 /*
 223  *  readInt - returns an integer from the input stream.
 224  */
 225
 226 int pushBackBuffer::readInt (void)
 227 {
 228   int  c =0;
 229   int  i =0;
 230   int  s =1;
 231   char ch=getPB();
 232
 233   while (isWhite(ch)) {
 234     ch=getPB();
 235   }
 236   // now read integer
 237
 238   if (ch == '-') {
 239     s = -1;
 240     ch = getPB();
 241   }
 242   while (isDigit(ch)) {
 243     i *= 10;
 244     if ((ch>='0') && (ch<='9')) {
 245       i += (int)(ch-'0');
 246     }
 247     ch = getPB();
 248     c++;
 249   }
 250   if (ch != putPB(ch)) {
 251     ERROR("assert failed");
 252   }
 253   return( i*s );
 254 }
 255
 256 /*
 257  *  convertToFloat - converts integers, a and b into a.b
 258  */
 259
 260 static double convertToFloat (int a, int b)
 261 {
 262   int c=10;
 263   double f;
 264
 265   while (b>c) {
 266     c *= 10;
 267   }
 268   f = ((double)a) + (((double)b)/((double)c));
 269   return( f );
 270 }
 271
 272 /*
 273  *  readNumber - returns a float representing the word just read.
 274  */
 275
 276 double pushBackBuffer::readNumber (void)
 277 {
 278   int i;
 279   char ch;
 280
 281   i = readInt();
 282   if ((ch = getPB()) == '.') {
 283     return convertToFloat(i, readInt());
 284   }
 285   putPB(ch);
 286   return (double)i;
 287 }
 288
 289 /*
 290  *  readString - reads a string terminated by white space
 291  *               and returns a malloced area of memory containing
 292  *               a copy of the characters.
 293  */
 294
 295 char *pushBackBuffer::readString (void)
 296 {
 297   char  buffer[MAXPUSHBACKSTACK];
 298   char *str = 0;
 299   int   i=0;
 300   char ch=getPB();
 301
 302   while (isWhite(ch)) {
 303     ch=getPB();
 304   }
 305   while ((i < MAXPUSHBACKSTACK) && (! isWhite(ch)) && (! eofFound)) {
 306     buffer[i] = ch;
 307     i++;
 308     ch = getPB();
 309   }
 310   if (i < MAXPUSHBACKSTACK) {
 311     buffer[i] = (char)0;
 312     str = (char *)malloc(strlen(buffer)+1);
 313     strcpy(str, buffer);
 314   }
 315   return( str );
 316 }
 317
 318 // s-it2-mode