1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
|
/*****
* parser.cc
* Tom Prince 2004/01/10
*
*****/
#include <fstream>
#include <sstream>
#include <cstring>
#include <fcntl.h>
#include "common.h"
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#include "interact.h"
#include "locate.h"
#include "errormsg.h"
#include "parser.h"
#include "util.h"
// The lexical analysis and parsing functions used by parseFile.
void setlexer(size_t (*input) (char* bif, size_t max_size), string filename);
extern bool yyparse(void);
extern int yydebug;
extern int yy_flex_debug;
extern bool lexerEOF();
extern void reportEOF();
extern bool hangup;
static int fd;
namespace parser {
static FILE *fin=NULL;
namespace yy { // Lexers
std::streambuf *sbuf = NULL;
size_t stream_input(char *buf, size_t max_size)
{
return sbuf ? sbuf->sgetn(buf,max_size) : 0;
}
int fpeek(int fd)
{
int flags=fcntl(fd,F_GETFL,0);
fcntl(fd,F_SETFL,flags | O_NONBLOCK);
char c=fgetc(fin);
ungetc(c,fin);
fcntl(fd,F_SETFL,flags & ~O_NONBLOCK);
return c;
}
size_t pipe_input(char *buf, size_t max_size)
{
if(hangup && fpeek(fd) == EOF) {hangup=false; return 0;}
fgets(buf,max_size-1,fin);
return strlen(buf);
}
} // namespace yy
void debug(bool state)
{
// For debugging the machine-generated lexer and parser.
yy_flex_debug = yydebug = state;
}
namespace {
void error(const string& filename)
{
em.sync();
em << "error: could not load module '" << filename << "'\n";
em.sync();
throw handled_error();
}
}
absyntax::file *doParse(size_t (*input) (char* bif, size_t max_size),
const string& filename, bool extendable=false)
{
setlexer(input,filename);
absyntax::file *root = yyparse() == 0 ? absyntax::root : 0;
absyntax::root = 0;
yy::sbuf = 0;
if (!root) {
if (lexerEOF()) {
if (extendable) {
return 0;
} else {
// Have the lexer report the error.
reportEOF();
}
}
em.error(nullPos);
if(!interact::interactive)
error(filename);
else
throw handled_error();
}
return root;
}
absyntax::file *parseStdin()
{
debug(false);
if(!fin) {
fd=intcast(settings::getSetting<Int>("inpipe"));
if(fd >= 0)
fin=fdopen(fd,"r");
}
if(fin)
return doParse(yy::pipe_input,"-");
else {
yy::sbuf = cin.rdbuf();
return doParse(yy::stream_input,"-");
}
}
absyntax::file *parseFile(const string& filename,
const char *nameOfAction)
{
if(filename == "-")
return parseStdin();
string file = settings::locateFile(filename);
if(file.empty())
error(filename);
if(nameOfAction && settings::verbose > 1)
cerr << nameOfAction << " " << filename << " from " << file << endl;
debug(false);
std::filebuf filebuf;
if(!filebuf.open(file.c_str(),std::ios::in))
error(filename);
#ifdef HAVE_SYS_STAT_H
// Check that the file is not a directory.
static struct stat buf;
if(stat(file.c_str(),&buf) == 0) {
if(S_ISDIR(buf.st_mode))
error(filename);
}
#endif
// Check that the file can actually be read.
try {
filebuf.sgetc();
} catch (...) {
error(filename);
}
yy::sbuf = &filebuf;
return doParse(yy::stream_input,file);
}
absyntax::file *parseString(const string& code,
const string& filename,
bool extendable)
{
debug(false);
stringbuf buf(code);
yy::sbuf = &buf;
return doParse(yy::stream_input,filename,extendable);
}
} // namespace parser
|