jsgf_t *
jsgf_parse_string(const char *string, jsgf_t * parent)
{
yyscan_t yyscanner;
jsgf_t *jsgf;
int yyrv;
YY_BUFFER_STATE buf;
yylex_init(&yyscanner);
buf = yy_scan_string(string, yyscanner);
jsgf = jsgf_grammar_new(parent);
if (!parent)
jsgf_set_search_path(jsgf, NULL);
yyrv = yyparse(yyscanner, jsgf);
if (yyrv != 0) {
E_ERROR("Failed to parse JSGF grammar from input string\n");
jsgf_grammar_free(jsgf);
yy_delete_buffer(buf, yyscanner);
yylex_destroy(yyscanner);
return NULL;
}
yy_delete_buffer(buf, yyscanner);
yylex_destroy(yyscanner);
return jsgf;
}
int yywrap() {
if (!include_app) { /* all input files and strings get a newline appended to them */
include_app = 1;
yy_scan_string("\n");
return 0;
} else {
include_app = 0;
if (inpfile) { /* (this is just an informal input text for printing-out...) */
FREE(inpfile); inpfile = NULL;
}
/* delete the input buffer, and possibly close the input file */
yy_delete_buffer(YY_CURRENT_BUFFER);
#if CLOSE_AFTER_FLEX>0
if (include_stack_file[include_stack_ptr])
fclose(include_stack_file[include_stack_ptr]);
#endif
/* pop the previous saved state from the stack */
if (--include_stack_ptr>=0) {
yy_switch_to_buffer(include_stack[include_stack_ptr]);
inpfile = include_stack_fn[include_stack_ptr];
inpline = include_stack_ln[include_stack_ptr];
yy_pop_state();
return 0;
} /*** else yyterminate(); does not work ??? ***/
}
return 1; /* (means the end of current input) */
}
void Text::CreateFromXML(const string& XML)
{
::pText = this;
YY_BUFFER_STATE buffer = yy_scan_bytes(XML.c_str(), XML.size());
yyparse();
yy_delete_buffer(buffer);
}
int source_parse_file(source *src, const char *filename, const char *modname)
{
YY_BUFFER_STATE bufstate;
int r;
if (NULL == (yyin = fopen(filename,"r"))) {
perror(filename);
return -1;
}
yyfilename = filename;
yyfileno = add_parsedfile(src,filename); ////yyfileno is the index in the src->parsedfiles
yylloc.first_line = 1;
bufstate = yy_create_buffer(yyin,YY_BUF_SIZE);
yy_switch_to_buffer(bufstate);
parse_src = src;
parse_modname = modname ? modname : "";
r = yyparse();
yy_delete_buffer(bufstate);
#if HAVE_YYLEX_DESTROY
yylex_destroy();
#endif
if (yyin)
fclose(yyin);
return r;
}
t_sip_message *t_parser::parse(const string &s, list<string> &parse_errors_) {
t_mutex_guard guard(mtx_parser);
int ret;
struct yy_buffer_state *b;
msg = NULL;
parse_errors.clear();
string x = unfold(s);
b = yy_scan_string(x.c_str());
ret = yyparse();
yy_delete_buffer(b);
if (ret != 0) {
if (msg) {
MEMMAN_DELETE(msg);
delete msg;
msg = NULL;
}
throw ret;
}
parse_errors_ = parse_errors;
return msg;
}
ModuleNode *getAST(const char *expr)
{
ModuleNode *expression;
yyscan_t scanner;
YY_BUFFER_STATE state;
if (yylex_init(&scanner)) {
// couldn't initialize
return NULL;
}
state = yy_scan_string(expr, scanner);
yydebug = 0;
if (yyparse(&expression, scanner)) {
// error parsing
return NULL;
}
yy_delete_buffer(state, scanner);
yylex_destroy(scanner);
return expression;
}
pt_node *buildAST(const char *expr) {
extern int yyparse(pt_node **, yyscan_t);
FILE *file;
yyscan_t scanner;
pt_node *node = NULL;
YY_BUFFER_STATE state;
if(yylex_init(&scanner)) {
fprintf(stderr, "Failed to initialize parser.\n");
exit(-1);
}
file = fopen(expr, "r");
if(file == NULL) {
perror("fopen");
exit(-1);
}
state = yy_create_buffer(file, 1024, scanner);
yy_switch_to_buffer(state, scanner);
if(yyparse(&node, scanner)) {
fprintf(stderr, "Error parsing input.\n");
exit(-1);
}
yy_delete_buffer(state, scanner);
yylex_destroy(scanner);
return node;
}
//////////////////////////////////////////////////////////////////////////
// EXPORTED FUNCTIONS
//////////////////////////////////////////////////////////////////////////
__declspec(dllexport) BYTE* CompileBuffer(BYTE* Buffer, char* Source, DWORD BufferSize, DWORD* CompiledSize){
YY_BUFFER_STATE state;
BYTE* ret = NULL;
if(Buffer==NULL){
if(CompiledSize)*CompiledSize = 0;
return NULL;
}
state = yy_scan_bytes(Buffer, BufferSize);
lineno=1;
yyparse();
yy_delete_buffer(state);
if(errorCheck()) goto finish_error;
weedSCRIPTCOLLECTION(thescriptcollection);
if(errorCheck()) goto finish_error;
symSCRIPTCOLLECTION(thescriptcollection);
if(errorCheck()) goto finish_error;
ret = opcodeSCRIPTCOLLECTION(thescriptcollection, Source, CompiledSize);
if(errorCheck()) goto finish_error;
FinalCleanup();
return ret;
finish_error:
if(ret!=NULL) free(ret);
*CompiledSize = 0;
FinalCleanup();
return NULL;
}
int como_ast_create(const char *filename)
{
ast_node* statements;
yyscan_t scanner;
YY_BUFFER_STATE state;
char* text;
text = file_get_contents(filename);
if(!text) {
printf("file '%s' not found\n", filename);
return 1;
}
if(yylex_init(&scanner)) {
como_error_noreturn("yylex_init returned NULL");
}
state = yy_scan_string(text, scanner);
if(yyparse(&statements, scanner)) {
como_error_noreturn("yyparse returned NULL");
}
yy_delete_buffer(state, scanner);
yylex_destroy(scanner);
como_compile_ast(statements, filename);
return 0;
}
int ne_parse(const char *formula)
{
int err;
struct symbol_table *sym;
ne.buf = yy_scan_string(formula, ne.scanner);
yyset_lineno(1, ne.scanner);
yyset_column(1, ne.scanner);
__ne_clear_error(&ne);
err = yyparse(&ne);
if (!err) {
__ne_put_result(&ne, eval(&ne, ne.root));
sym = get_sym(&ne, "y");
if (sym && sym->dirty) {
__ne_put_result(&ne, __ne_get_y(&ne));
clean_output_sym(&ne);
}
}
if (ne.error != 0)
err = ne.error;
else if (ne.warrning != 0)
err = ne.warrning;
free_ast(ne.root);
ne.root = NULL;
ne.stop = 0;
yy_delete_buffer(ne.buf, ne.scanner);
return err;
}
ltl_formula *
getAST (const char *input)
{
ltl_formula *formula;
yyscan_t scanner;
YY_BUFFER_STATE state;
if (yylex_init (&scanner))
{
// couldn't initialize
return NULL;
}
state = yy_scan_string (input, scanner);
if (yyparse (&formula, scanner))
{
// error parsing
return NULL;
}
yy_delete_buffer (state, scanner);
yylex_destroy (scanner);
return formula;
}
// -----------------------------------------------------------------------
int dbg_parse(char *c)
{
YY_BUFFER_STATE yb = yy_scan_string(c);
int res = yyparse();
yy_delete_buffer(yb);
return res;
}
/**
* @function runCommand
*
* @abstract Parses and executes a command given a NULL terminated string.
* @discussion Parses the command and adds it to the history if it is
* nontrivial.
*
* @param cmd_buffer Pointer to NULL terminated string containing
* the user input.
* @result Returns nothing, but runs a command, most likely printing to
* the terminal.
*/
void runCommand(char* cmd_buffer) {
Command *command = NULL;
yyscan_t scanner;
YY_BUFFER_STATE state;
// Check if there is anything in the line. It is useless to store
// a history of empty lines. If it is not empty, then add it to our
// history. Also don't want to record line rerun calls.
if ((cmd_buffer[0] != 0) && (cmd_buffer[0] != '!')) {
add_history(cmd_buffer);
}
state = yy_scan_string(cmd_buffer);
if (yyparse(&command, scanner)) {
printf("Error in parsing command.\n");
deleteCommand(command);
return;
}
executeCommand(command, -1);
deleteCommand(command);
// Wait on all child processes
while (wait(NULL) > 0) {}
yy_delete_buffer(state);
yylex_destroy();
return;
}
char *PCCloseentity(void) {
char * pc;
PEntRec per;
#ifdef DEBUGGING
FILESTATUS(stdout,"stdout");
MsgKwS(msgTRACE,"Closing the current entity ...",NULL);
MsgKwS(msgTRACE,"PCCloseentity() called ...",NULL);
FILESTATUS(stdout,"stdout");
FILESTATUS(stdin,"stdin");
FILESTATUS(stderr,"stderr");
FILESTATUS(yyin,"yyin");
#endif
if (cEntCur > 0) {
per = rgEntities[cEntCur];
pc = per->pcEntname;
if (per->fExtern)
fclose(yyin);
/* close yyin. We don't need to reset it,
that happens in yy_switch_to_buffer, below */
yy_delete_buffer(YY_CURRENT_BUFFER);
yy_switch_to_buffer(rgBuffers[--cEntCur]);
/* reset pcEntpos and fRdexternal */
if (cEntCur > 0) {
per = rgEntities[cEntCur];
if (per->fExtern) {
fRdexternal = 1;
pcEntpos = "";
} else {
fRdexternal = 0;
pcEntpos = rgPCPos[cEntCur];
}
} else { /* back to stdin */
fRdexternal = 1;
pcEntpos = "";
}
cLinecount = rgILine[cEntCur];
fnCurrent = rgPCFn[cEntCur];
#ifdef DEBUGGING
FILESTATUS(stdout,"stdout");
FILESTATUS(stdin,"stdin");
FILESTATUS(stderr,"stderr");
FILESTATUS(yyin,"yyin");
#endif
return pc;
} else {
#ifdef DEBUGGING
FILESTATUS(stdout,"stdout");
FILESTATUS(stdin,"stdin");
FILESTATUS(stderr,"stderr");
FILESTATUS(yyin,"yyin");
#endif
return NULL;
}
}
int command_parse_string( const char *buffer )
{
typedef struct yy_buffer_state* YY_BUFFER_STATE;
extern YY_BUFFER_STATE yy_scan_string( const char *yy_str );
extern void yy_delete_buffer( YY_BUFFER_STATE state );
int rv = 1;
YY_BUFFER_STATE state = yy_scan_string( (char*)buffer );
switch ( yylex() ) {
case SET:
/* get the next token */
rv = command_parse_set();
break;
case UNSET:
case BIND:
case MACRO:
/* ignore this stuff for now. */
rv = 1;
break;
case NUMBER: {
const char *number = get_token();
if ( number[0] == '+' ) {
source_vscroll( if_get_sview(), atoi( number+1 ));
rv = 0;
} else if ( number[0] == '-' ) {
source_vscroll( if_get_sview(), -atoi( number+1 ));
rv = 0;
} else {
source_set_sel_line(if_get_sview(), atoi( number ));
rv = 0;
}
if_draw();
} break;
case IDENTIFIER: {
COMMANDS *command = get_command( get_token() );
if ( command ) {
command->action(command->param);
rv = 0;
} else {
rv = 1;
}
} break;
case EOL:
/* basically just an empty line, don't do nothin. */
rv = 0;
break;
default:
rv = 1;
break;
}
yy_delete_buffer( state );
return rv;
}
int main(int argc, char *argv[])
{
char *str, *str0;
size_t str0_sz;
char *url;
FILE *fout;
uint suc_cnt = 0, fail_cnt = 0;
if (argc != 2) {
printf("invalid argument format. \n");
return 0;
}
url = argv[1];
fout = fopen("parser.output", "w");
fprintf(fout, "%s\n", url);
/* disable auto-complete */
rl_bind_key('\t', rl_abort);
while (1) {
str = readline("edit: ");
if (str == NULL) {
printf("\n");
break;
}
/* user can use UP and DOWN key to
search through the history. */
add_history(str);
str0 = to_scan_str(str, &str0_sz);
YY_BUFFER_STATE buffer =
yy_scan_buffer(str0, str0_sz);
yyparse();
if (parser_error_flag) {
fail_cnt ++;
parser_error_flag = 0;
printf("[ %s ]\n", parser_error_dscr);
} else {
suc_cnt ++;
fprintf(fout, "%s\n", str);
parser_out(fout);
}
yy_delete_buffer(buffer);
free(str);
free(str0);
}
fclose(fout);
printf("[ %d successfully parsed, %d fail(s) ]\n",
suc_cnt, fail_cnt);
return suc_cnt;
}
void val_parse_forall(char *s, val_callback_t callback) {
yyscan_t scanner;
if (yylex_init(&scanner)) die("yylex_init error");
YY_BUFFER_STATE buf = s ? yy_scan_string(s, scanner) : 0;
if (yyparse(scanner, callback)) die("parse error");
yy_delete_buffer(buf, scanner);
yylex_destroy(scanner);
}
void
lexer_restore_buffer(RemarkFile *rf)
{
file = rf;
yy_delete_buffer(YY_CURRENT_BUFFER);
if (rf != NULL)
yy_switch_to_buffer(rf->lex_buffer);
}
LispObj *read_from_string(char *str)
{
YY_BUFFER_STATE yy_buf = yy_scan_string(str);
LispObj *obj = read_from_yybuf(yy_buf);
yy_delete_buffer(yy_buf);
return obj;
}
LispObj *read_from_stream(FILE *stream)
{
YY_BUFFER_STATE yy_buf = yy_create_buffer(stream, YY_BUF_SIZE);
LispObj *obj = read_from_yybuf(yy_buf);
yy_delete_buffer(yy_buf);
return obj;
}
int parse(const char *input, cmd *cmds[], int size)
{
elementType type;
redirectMode redir;
int cmd_count = -1, fd;
int valid_pipe = 0;
char *str;
YY_BUFFER_STATE buf = yy_scan_string(input);
while ((type = yylex()) != 0) {
if (cmd_count == -1) cmd_count = 0;
fd = -1;
str = NULL;
switch (type) {
case SEMICOLON:
cmd_count++; valid_pipe = 0; break;
case PIPE:
if (!valid_pipe) {
fprintf(stderr, "shell: invalid pipe\n");
yy_delete_buffer(buf);
return -1;
}
cmd_add_pcmd(&cmds[cmd_count]); break;
case CMD:
valid_pipe = 1;
case STRING:
str = handle_escaped_chs(yytext);
//fprintf(stderr, "%s %s\n", yytext, str);
cmd_addarg(cmds[cmd_count], str); break;
case FD_IN_RED: case FD_OUT_RED: case FD_APPEND:
fd = get_fd(yytext, type);
case IN_RED: case OUT_RED: case OUT_APPEND: case OUT_ERR_RED: case OUT_ERR_APPEND:
yylex();
str = handle_escaped_chs(yytext);
cmd_redirect(cmds[cmd_count], fd, type, str); break;
case BACKGROUND:
cmd_set_bg(cmds[cmd_count]); break;
default:
fprintf(stderr, "Unknown type: %d, %s\n", type, yytext);
}
free(str);
}
yy_delete_buffer(buf);
return cmd_count + 1;
}
int compileST (char *pgm) {
extern char *yy_scan_bytes();
char *my_string_buffer = yy_scan_bytes (pgm, strlen(pgm)+1);
int my_parse_result = yyparse ();
if (my_parse_result)
return -1;
yy_delete_buffer (my_string_buffer);
yylex_destroy();
return 0;
}
void parseFile(FILE* in)
{
YY_BUFFER_STATE* tmp = new YY_BUFFER_STATE;
*tmp = yy_create_buffer(in, YY_BUF_SIZE);
yy_switch_to_buffer(*tmp);
if(buffer)
yy_delete_buffer(*buffer);
delete buffer;
buffer = tmp;
}
static VALUE
parse_string(VALUE self, VALUE code) {
VALUE lineno = rb_funcall(self, rb_intern("lineno"), 0);
char *str = StringValueCStr(code);
YY_BUFFER_STATE buffstate = yy_scan_string(str);
yy_switch_to_buffer(buffstate);
yylineno = NUM2INT(lineno);
yyparse(self);
yy_delete_buffer(buffstate);
return self;
}
void close_stemmer() {
//fclose(morpha_instream);
//free(morpha_instream_buff_ptr);
//fclose(morpha_outstream);
//free(morpha_outstream_buff_ptr);
yy_delete_buffer(yy_current_buffer);
int i;
for (i=0; i<verbstem_n; i++) {
free(verbstem_list[i]);
}
free(verbstem_list);
}
void Compile(const char* pBuffer, uint32_t Length, Buffer* NsbBuffer, Buffer* MapBuffer)
{
Counter = 1;
SymCounter = 1;
Output = NsbBuffer;
MapOutput = MapBuffer;
YY_BUFFER_STATE buffer = yy_scan_bytes(pBuffer, Length);
yyparse();
pRoot->Compile();
yy_delete_buffer(buffer);
delete pRoot;
}
// tokenizes and adds everything under a single field
wp_error* wp_entry_add_string(wp_entry* entry, const char* field, const char* string) {
yyscan_t scanner;
lexinfo charpos = {0, 0};
yylex_init_extra(&charpos, &scanner);
YY_BUFFER_STATE state = yy_scan_string(string, scanner);
RELAY_ERROR(add_from_lexer(entry, &scanner, field));
yy_delete_buffer(state, scanner);
yylex_destroy(scanner);
return NO_ERROR;
}
int parse_filter_string(char *filter)
{
YY_BUFFER_STATE buffer_state = yy_scan_string(filter);
int status = yyparse();
yy_delete_buffer(buffer_state);
if (status) {
// Error
log_error("zmap", "Unable to parse filter string: '%s'", filter);
return 0;
}
zconf.filter.expression = zfilter;
return 1;
}
ASTNode* Compiler::parse(std::string code) {
ASTNode* root;
yyscan_t scanner;
YY_BUFFER_STATE buffer;
if (yylex_init(&scanner)) {
return NULL;
}
buffer = yy_scan_string(code.c_str(), scanner);
yyparse(&root, scanner);
yy_delete_buffer(buffer, scanner);
yylex_destroy(scanner);
return root;
}
param_ret_t *do_ST_interpreter (void *userctx, char *pgm) {
extern char *yy_scan_bytes();
char *my_string_buffer = yy_scan_bytes (pgm, strlen(pgm)+1);
int my_parse_result = yyparse ();
if (my_parse_result)
return NULL;
yy_delete_buffer (my_string_buffer);
yylex_destroy();
param_ret_t *pret = codeGen (programBlock, userctx);
cleanUp (programBlock);
return pret;
}