std::string bash_ast::get_dot_graph()
{
antlr_pointer<ANTLR3_COMMON_TREE_NODE_STREAM_struct> nodes(
antlr3CommonTreeNodeStreamNewTree(ast, ANTLR3_SIZE_HINT));
pANTLR3_STRING graph = nodes->adaptor->makeDot(nodes->adaptor, ast);
return std::string(reinterpret_cast<char*>(graph->chars));
}
/*! Read expressions from file or memory and Evaluate
*/
int EvaluateExpressions(const char *buffer, int buf_length, int is_filename)
{
pANTLR3_INPUT_STREAM input_stream = NULL;
pEvaLexer lxr = NULL;
pANTLR3_COMMON_TOKEN_STREAM token_stream = NULL;
pEvaParser psr = NULL;
pEvaTree treeParser = NULL;
pANTLR3_COMMON_TREE_NODE_STREAM nodes = NULL;
EvaParser_program_return eva_ast;
int error = 0;
ResetErrorString();
/*Is it a file or memory*/
if (is_filename) {
input_stream = antlr3AsciiFileStreamNew((pANTLR3_UINT8)buffer);
} else {
input_stream = antlr3NewAsciiStringCopyStream((pANTLR3_UINT8)buffer, (ANTLR3_UINT32)buf_length, NULL);
}
ABORT_IF(input_stream == NULL);
/*Invoke lexer and tokenzie*/
lxr = EvaLexerNew(input_stream);
ABORT_IF(lxr == NULL);
token_stream = antlr3CommonTokenStreamSourceNew(ANTLR3_SIZE_HINT, TOKENSOURCE(lxr));
ABORT_IF(token_stream == NULL);
/*Parse the expression*/
psr = EvaParserNew(token_stream);
ABORT_IF(psr == NULL);
//psr->pParser->rec->recoverFromMismatchedElement = recoverFromMismatchedElement;
psr->pParser->rec->displayRecognitionError = DisplayRecognitionError;
/*create ast from the parser*/
eva_ast = psr->program(psr);
/*check if there is parsing error*/
ABORT_IF(psr->pParser->rec->state->errorCount > 0);
nodes = antlr3CommonTreeNodeStreamNewTree(eva_ast.tree, ANTLR3_SIZE_HINT);
ABORT_IF(nodes == NULL);
/*Walk the tree and evaluate the expression*/
treeParser = EvaTreeNew(nodes);
ABORT_IF(treeParser == NULL);
/*Take action*/
treeParser->program(treeParser);
/*All done lets cleanup*/
clean_up:
FREE(treeParser);
FREE(nodes);
FREE(psr);
FREE(token_stream);
FREE(lxr);
FREE(input_stream);
return error;
}
std::string bash_ast::get_walker_tokens(std::function<std::string(ANTLR3_UINT32)> token_map)
{
std::stringstream result;
antlr_pointer<ANTLR3_COMMON_TREE_NODE_STREAM_struct> nodes(
antlr3CommonTreeNodeStreamNewTree(ast, ANTLR3_SIZE_HINT));
pANTLR3_INT_STREAM istream = nodes->tnstream->istream;
auto istream_size = istream->size(istream);
for(ANTLR3_UINT32 i = 1; i <= istream_size; ++i)
{
ANTLR3_UINT32 token = istream->_LA(istream, boost::numeric_cast<ANTLR3_INT32>(i));
if(token == 2)
result << "DOWN ";
else if(token == 3)
result << "UP ";
else
result << token_map(istream->_LA(istream, boost::numeric_cast<ANTLR3_INT32>(i))) << " ";
}
result << std::endl;
return result.str();
}
int main(int argc, char * argv[])
{
int i;
pANTLR3_VECTOR tlist;
pANTLR3_TOKEN_SOURCE tsource;
pANTLR3_COMMON_TOKEN_STREAM tstream;
pCFortranParser parser;
CFortranParser_main_program_return main_ast;
char * tok_file = argv[1];
char * src_file = argv[2];
if (argc < 3) {
printf("usage: ftokens token_file src_file\n");
exit(1);
}
/* Lexer phase
* - Call the token parser to read the tokens from the token file.
*/
tlist = get_tokens(tok_file);
/* print tokens
*/
// for (i = 0; i < tlist->size(tlist); i++) {
// print_token((pANTLR3_COMMON_TOKEN) tlist->get(tlist, i));
// }
/* Parser phase
* - Call the parser with the token source which uses the token
* list obtained from the token file.
*/
tsource = ofpTokenSourceNew ( (pANTLR3_UINT8) src_file, tlist );
tstream = antlr3CommonTokenStreamSourceNew ( ANTLR3_SIZE_HINT, tsource );
parser = CFortranParserNew ( tstream );
main_ast = parser->main_program(parser);
if (parser->pParser->rec->state->errorCount > 0)
{
fprintf(stderr, "The parser returned %d errors, tree walking aborted.\n", parser->pParser->rec->state->errorCount);
}
else
{
pANTLR3_COMMON_TREE_NODE_STREAM nodes;
pFTreeWalker tree_parser;
printf("Tree : %s\n", main_ast.tree->toStringTree(main_ast.tree)->chars);
nodes = antlr3CommonTreeNodeStreamNewTree(main_ast.tree, ANTLR3_SIZE_HINT);
tree_parser = FTreeWalkerNew(nodes);
tree_parser->main_program(tree_parser);
nodes ->free(nodes); nodes = NULL;
tree_parser ->free(tree_parser); tree_parser = NULL;
}
parser ->free(parser); parser = NULL;
tstream ->free(tstream); tstream = NULL;
// TODO tsource ->free(tsource); tsource = NULL;
return 0;
}
int main(int argc, char *argv[])
{
pANTLR3_UINT8 filename;
pANTLR3_INPUT_STREAM input=NULL;
pProtoJSLexer lxr;
pANTLR3_COMMON_TOKEN_STREAM tstream;
pProtoJSParser psr;
ProtoJSParser_protocol_return pbjAST;
if (argc < 2 || argv[1] == NULL)
filename = (pANTLR3_UINT8)"./input";
else
filename = (pANTLR3_UINT8)argv[1];
const char * outputFilename="output";
if (argc>=3) {
outputFilename=argv[2];
}
char * csOut=NULL;
char * cppOut=NULL;
char * cppInclude=NULL;
int argindex;
const char *outputInternalNamespace="_ProtoJS_Internal";
const char *outputExternalNamespace="";
for (argindex=3;argindex<argc;++argindex) {
if (strncmp(argv[argindex],"--cpp=",6)==0) {
cppOut=argv[argindex]+6;
}
if (strncmp(argv[argindex],"--cs=",5)==0) {
csOut=argv[argindex]+5;
}
if (strncmp(argv[argindex],"--include=",10)==0) {
cppInclude=argv[argindex]+10;
}
if (strncmp(argv[argindex],"--inamespace=",13)==0) {
outputInternalNamespace=argv[argindex]+13;
}
if (strncmp(argv[argindex],"--namespace=",12)==0) {
outputExternalNamespace=argv[argindex]+12;
}
}
char*package=parsePackage((const char*)filename,outputFilename,outputInternalNamespace,outputExternalNamespace);
pANTLR3_HASH_TABLE qualifiedTypes=antlr3HashTableNew(11);
parseTypes((const char*)filename,outputFilename,outputInternalNamespace,outputExternalNamespace,package,qualifiedTypes);
if(generateASTProto((const char*)filename,outputFilename,outputInternalNamespace,outputExternalNamespace,package,qualifiedTypes,&pbjAST,&lxr,&psr,&tstream,&input)) {
pANTLR3_COMMON_TREE_NODE_STREAM nodes;
nodes = antlr3CommonTreeNodeStreamNewTree(pbjAST.tree, ANTLR3_SIZE_HINT); // sIZE HINT WILL SOON BE DEPRECATED!!
pANTLR3_STRING s = nodes->stringFactory->newRaw(nodes->stringFactory);
grammarToString(nodes->tnstream,nodes->root,NULL,s);
FILE*fp=fopen(outputFilename,"w");
if (!fp) {
perror("Unable to open output file!");
exit(2);
}
if (s->size>1)
fwrite(s->chars,s->size-1,1,fp);
fclose(fp);
stringFree(s);
nodes ->free (nodes); nodes = NULL;
}
psr->free(psr);
psr = NULL;
tstream->free(tstream);
tstream = NULL;
lxr->free(lxr);
lxr = NULL;
input->close(input);
input = NULL;
return 0;
}
CompilerImpl(std::string const& filename, pANTLR3_BASE_TREE tree)
:filename(filename), tree(tree), stream(nullptr), compiler(nullptr){
stream = antlr3CommonTreeNodeStreamNewTree(tree, 0);
compiler = CompilerNew(stream);
}
int main(int argc, char **argv)
{
pANTLR3_INPUT_STREAM input;
pANTLR3_COMMON_TOKEN_STREAM tstream;
pANTLR3_COMMON_TREE_NODE_STREAM tnstream;
ParserParser_translationUnit_return parseTree;
pParserLexer lxr;
pParserParser psr;
pASTParser ASTp;
int ret = 1;
if (argc < 2)
goto err;
ret++;
input = antlr3FileStreamNew((pANTLR3_UINT8)argv[1], ANTLR3_ENC_8BIT);
if (!input)
goto err;
ret++;
lxr = ParserLexerNew(input);
if (!lxr)
goto err_input;
ret++;
tstream = antlr3CommonTokenStreamSourceNew(ANTLR3_SIZE_HINT, TOKENSOURCE(lxr));
if (!tstream)
goto err_lxr;
ret++;
psr = ParserParserNew(tstream);
if (!psr)
goto err_tstream;
parseTree = psr->translationUnit(psr);
puts((char *)parseTree.tree->toStringTree(parseTree.tree)->chars);
ret++;
tnstream = antlr3CommonTreeNodeStreamNewTree(parseTree.tree,
ANTLR3_SIZE_HINT);
if (!tnstream)
goto err_psr;
ret++;
ASTp = ASTParserNew(tnstream);
if (!ASTp)
goto err_tnstream;
ASTp->translationUnit(ASTp);
ret = 0;
ASTp->free(ASTp);
err_tnstream:
tnstream->free(tnstream);
err_psr:
psr->free(psr);
err_tstream:
tstream->free(tstream);
err_lxr:
lxr->free(lxr);
err_input:
input->close(input);
err:
return ret;
}
char *
rsp_query_parse_sql(const char *rsp_query)
{
/* Input RSP query, fed to the lexer */
pANTLR3_INPUT_STREAM query;
/* Lexer and the resulting token stream, fed to the parser */
pRSPLexer lxr;
pANTLR3_COMMON_TOKEN_STREAM tkstream;
/* Parser and the resulting AST, fed to the tree parser */
pRSPParser psr;
RSPParser_query_return qtree;
pANTLR3_COMMON_TREE_NODE_STREAM nodes;
/* Tree parser and the resulting SQL query string */
pRSP2SQL sqlconv;
pANTLR3_STRING sql;
char *ret = NULL;
DPRINTF(E_DBG, L_RSP, "Trying RSP query -%s-\n", rsp_query);
#if ANTLR3C_NEW_INPUT
query = antlr3StringStreamNew ((pANTLR3_UINT8)rsp_query, ANTLR3_ENC_8BIT, (ANTLR3_UINT64)strlen(rsp_query), (pANTLR3_UINT8)"RSP query");
#else
query = antlr3NewAsciiStringInPlaceStream ((pANTLR3_UINT8)rsp_query, (ANTLR3_UINT64)strlen(rsp_query), (pANTLR3_UINT8)"RSP query");
#endif
if (!query)
{
DPRINTF(E_DBG, L_RSP, "Could not create input stream\n");
return NULL;
}
lxr = RSPLexerNew(query);
if (!lxr)
{
DPRINTF(E_DBG, L_RSP, "Could not create RSP lexer\n");
goto lxr_fail;
}
tkstream = antlr3CommonTokenStreamSourceNew(ANTLR3_SIZE_HINT, TOKENSOURCE(lxr));
if (!tkstream)
{
DPRINTF(E_DBG, L_RSP, "Could not create RSP token stream\n");
goto tkstream_fail;
}
psr = RSPParserNew(tkstream);
if (!psr)
{
DPRINTF(E_DBG, L_RSP, "Could not create RSP parser\n");
goto psr_fail;
}
qtree = psr->query(psr);
/* Check for parser errors */
if (psr->pParser->rec->state->errorCount > 0)
{
DPRINTF(E_LOG, L_RSP, "RSP query parser terminated with %d errors\n", psr->pParser->rec->state->errorCount);
goto psr_error;
}
DPRINTF(E_SPAM, L_RSP, "RSP query AST:\n\t%s\n", qtree.tree->toStringTree(qtree.tree)->chars);
nodes = antlr3CommonTreeNodeStreamNewTree(qtree.tree, ANTLR3_SIZE_HINT);
if (!nodes)
{
DPRINTF(E_DBG, L_RSP, "Could not create node stream\n");
goto psr_error;
}
sqlconv = RSP2SQLNew(nodes);
if (!sqlconv)
{
DPRINTF(E_DBG, L_RSP, "Could not create SQL converter\n");
goto sql_fail;
}
sql = sqlconv->query(sqlconv);
/* Check for tree parser errors */
if (sqlconv->pTreeParser->rec->state->errorCount > 0)
{
DPRINTF(E_LOG, L_RSP, "RSP query tree parser terminated with %d errors\n", sqlconv->pTreeParser->rec->state->errorCount);
goto sql_error;
}
if (sql)
{
DPRINTF(E_DBG, L_RSP, "RSP SQL query: -%s-\n", sql->chars);
ret = strdup((char *)sql->chars);
}
else
{
DPRINTF(E_LOG, L_RSP, "Invalid RSP query\n");
ret = NULL;
}
sql_error:
sqlconv->free(sqlconv);
sql_fail:
nodes->free(nodes);
psr_error:
psr->free(psr);
psr_fail:
tkstream->free(tkstream);
tkstream_fail:
lxr->free(lxr);
lxr_fail:
query->close(query);
return ret;
}
static int
smartpl_parse_file(const char *file, struct playlist_info *pli)
{
pANTLR3_INPUT_STREAM input;
pSMARTPLLexer lxr;
pANTLR3_COMMON_TOKEN_STREAM tstream;
pSMARTPLParser psr;
SMARTPLParser_playlist_return qtree;
pANTLR3_COMMON_TREE_NODE_STREAM nodes;
pSMARTPL2SQL sqlconv;
SMARTPL2SQL_playlist_return plreturn;
int ret;
#if ANTLR3C_NEW_INPUT
input = antlr3FileStreamNew((pANTLR3_UINT8) file, ANTLR3_ENC_8BIT);
#else
input = antlr3AsciiFileStreamNew((pANTLR3_UINT8) file);
#endif
// The input will be created successfully, providing that there is enough memory and the file exists etc
if (input == NULL)
{
DPRINTF(E_LOG, L_SCAN, "Unable to open smart playlist file %s\n", file);
return -1;
}
lxr = SMARTPLLexerNew(input);
// Need to check for errors
if (lxr == NULL)
{
DPRINTF(E_LOG, L_SCAN, "Could not create SMARTPL lexer\n");
ret = -1;
goto lxr_fail;
}
tstream = antlr3CommonTokenStreamSourceNew(ANTLR3_SIZE_HINT, TOKENSOURCE(lxr));
if (tstream == NULL)
{
DPRINTF(E_LOG, L_SCAN, "Could not create SMARTPL token stream\n");
ret = -1;
goto tkstream_fail;
}
// Finally, now that we have our lexer constructed, we can create the parser
psr = SMARTPLParserNew(tstream); // CParserNew is generated by ANTLR3
if (tstream == NULL)
{
DPRINTF(E_LOG, L_SCAN, "Could not create SMARTPL parser\n");
ret = -1;
goto psr_fail;
}
qtree = psr->playlist(psr);
/* Check for parser errors */
if (psr->pParser->rec->state->errorCount > 0)
{
DPRINTF(E_LOG, L_SCAN, "SMARTPL query parser terminated with %d errors\n", psr->pParser->rec->state->errorCount);
ret = -1;
goto psr_error;
}
DPRINTF(E_DBG, L_SCAN, "SMARTPL query AST:\n\t%s\n", qtree.tree->toStringTree(qtree.tree)->chars);
nodes = antlr3CommonTreeNodeStreamNewTree(qtree.tree, ANTLR3_SIZE_HINT);
if (!nodes)
{
DPRINTF(E_LOG, L_SCAN, "Could not create node stream\n");
ret = -1;
goto psr_error;
}
sqlconv = SMARTPL2SQLNew(nodes);
if (!sqlconv)
{
DPRINTF(E_LOG, L_SCAN, "Could not create SQL converter\n");
ret = -1;
goto sql_fail;
}
plreturn = sqlconv->playlist(sqlconv);
/* Check for tree parser errors */
if (sqlconv->pTreeParser->rec->state->errorCount > 0)
{
DPRINTF(E_LOG, L_SCAN, "SMARTPL query tree parser terminated with %d errors\n", sqlconv->pTreeParser->rec->state->errorCount);
ret = -1;
goto sql_error;
}
if (plreturn.title && plreturn.query)
{
DPRINTF(E_DBG, L_SCAN, "SMARTPL SQL title '%s' query: -%s-\n", plreturn.title->chars, plreturn.query->chars);
if (pli->title)
free(pli->title);
pli->title = strdup((char *)plreturn.title->chars);
if (pli->query)
free(pli->query);
pli->query = strdup((char *)plreturn.query->chars);
ret = 0;
}
else
{
DPRINTF(E_LOG, L_SCAN, "Invalid SMARTPL query\n");
ret = -1;
}
sql_error:
sqlconv->free(sqlconv);
sql_fail:
nodes->free(nodes);
psr_error:
psr->free(psr);
psr_fail:
tstream->free(tstream);
tkstream_fail:
lxr->free(lxr);
lxr_fail:
input->close(input);
return ret;
}
