static bool newInputStream(const std::string& filename, pANTLR3_LEXER lexer) {
Debug("parser") << "Including " << filename << std::endl;
// Create a new input stream and take advantage of built in stream stacking
// in C target runtime.
//
pANTLR3_INPUT_STREAM in;
#ifdef CVC4_ANTLR3_OLD_INPUT_STREAM
in = antlr3AsciiFileStreamNew((pANTLR3_UINT8) filename.c_str());
#else /* CVC4_ANTLR3_OLD_INPUT_STREAM */
in = antlr3FileStreamNew((pANTLR3_UINT8) filename.c_str(), ANTLR3_ENC_8BIT);
#endif /* CVC4_ANTLR3_OLD_INPUT_STREAM */
if( in == NULL ) {
Debug("parser") << "Can't open " << filename << std::endl;
return false;
}
// Same thing as the predefined PUSHSTREAM(in);
lexer->pushCharStream(lexer, in);
// restart it
//lexer->rec->state->tokenStartCharIndex = -10;
//lexer->emit(lexer);
// Note that the input stream is not closed when it EOFs, I don't bother
// to do it here, but it is up to you to track streams created like this
// and destroy them when the whole parse session is complete. Remember that you
// don't want to do this until all tokens have been manipulated all the way through
// your tree parsers etc as the token does not store the text it just refers
// back to the input stream and trying to get the text for it will abort if you
// close the input stream too early.
//TODO what said before
return true;
}
ParserImpl& fromFile(std::string const& filename)
{
this->filename_ = filename;
stream = antlr3FileStreamNew((ANTLR3_UINT8*)filename.c_str(), ANTLR3_ENC_UTF8);
if(!stream){
DONUT_EXCEPTION(Exception, "Failed to create ANTLR3 File Stream for %s", filename.c_str());
}
setup();
return *this;
}
int main(int /*argc*/, char** /*argv*/)
{
pANTLR3_UINT8 fileName = (pANTLR3_UINT8)"test.mat";
pANTLR3_COMMON_TREE_NODE_STREAM treeNodes;
pANTLR3_INPUT_STREAM input = antlr3FileStreamNew(fileName, ANTLR3_ENC_UTF8);
if (input == nullptr)
{
ANTLR3_FPRINTF(stderr, "unable to open %s", (char *)fileName);
return ANTLR3_ERR_NOFILE;
}
pTalonMaterialLexer lexer = TalonMaterialLexerNew(input);
if (lexer == nullptr)
{
ANTLR3_FPRINTF(stderr, "unable to create lexer.");
return ANTLR3_ERR_NOMEM;
}
pANTLR3_COMMON_TOKEN_STREAM tokenStream = antlr3CommonTokenStreamSourceNew(ANTLR3_SIZE_HINT, TOKENSOURCE(lexer));
if (tokenStream == nullptr)
{
ANTLR3_FPRINTF(stderr, "unable to create tokenStream.");
return ANTLR3_ERR_NOMEM;
}
pTalonMaterialParser parser = TalonMaterialParserNew(tokenStream);
if (parser == nullptr)
{
ANTLR3_FPRINTF(stderr, "unable to create parser.");
return ANTLR3_ERR_NOMEM;
}
auto module = parser->module(parser);
auto errorCount = parser->pParser->rec->getNumberOfSyntaxErrors(parser->pParser->rec);
if (errorCount > 0)
{
ANTLR3_FPRINTF(stderr, "The parser returned %d errors, tree walking aborted.\n", errorCount);
}
else
{
ANTLR3_FPRINTF(stdout, "Parser found no errors.");
}
return 0;
}
// Main entry point for this example
//
int ANTLR3_CDECL
main(int argc, char *argv[]) {
pANTLR3_UINT8 fName;
pANTLR3_INPUT_STREAM input;
pJpVocabularyLexer lxr;
pANTLR3_COMMON_TOKEN_STREAM tstream;
pJpVocabularyParser psr;
if (argc < 2 || argv[1] == NULL) {
//fName = (pANTLR3_UINT8) "./input"; // Note in VS2005 debug, working directory must be configured
VocInfo vi;
initVocInfo(&vi);
short ret = parseJpVoc("あいかわらず（相変わらず）［副］照旧，依然", vi);
printf("pronun:%s\twriting:%s\tpartOfSpeech:%s\texpl:%s\n",
vi.pronun,vi.writing,
vi.partOfSpeech,vi.expl);
/*printf("pronun:%s\twriting:%s\tpartOfSpeech:%s\texpl:%s\n",
emptyIfNull(vi.pronun),emptyIfNull(vi.writing),
emptyIfNull(vi.partOfSpeech),emptyIfNull(vi.expl));*/
clearVocInfo(&vi);
return 0;
} else {
fName = (pANTLR3_UINT8) argv[1];
}
ANTLR3_FPRINTF(stdout,"\xE6\x85\x8C\xE3\x81\xA6\xE3\x81\xBE\xE3\x81\x99\n");
ANTLR3_FPRINTF(stdout,"input file name:%s\n",fName);
//ANTLR3_ENC_8BIT, ANTLR3_ENC_UTF8, ANTLR3_ENC_UTF16
input = antlr3FileStreamNew(fName, ANTLR3_ENC_UTF8);
initParser(&input,&lxr,&tstream,&psr);
psr->voclist(psr);
cleanParser(&input,&lxr,&tstream,&psr);
return 0;
}
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;
}
int open_file_stream( pParserComplect complect, pANTLR3_UINT8 file ) {
complect->stream = antlr3FileStreamNew( file, ANTLR3_ENC_UTF8 );
return check_opened_stream( complect );
}
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;
}
