pANTLR3_INPUT_STREAM SCsParser::createInputStream(const std::string &text)
{
pANTLR3_INPUT_STREAM input;
#if defined( __WIN32__ ) || defined( _WIN32 )
input = antlr3StringStreamNew((pANTLR3_UINT8)text.c_str(),ANTLR3_ENC_UTF8,text.length(),(pANTLR3_UINT8)"scs");
#elif defined( __APPLE_CC__)
input = antlr3StringStreamNew((pANTLR3_UINT8)text.c_str(),ANTLR3_ENC_UTF8,text.length(),(pANTLR3_UINT8)"scs");
#else
input = antlr3NewAsciiStringCopyStream((pANTLR3_UINT8)text.c_str(),text.length(),(pANTLR3_UINT8)"scs");
#endif
return input;
}
bool SCsTranslator::processString(const String &data)
{
pANTLR3_INPUT_STREAM input;
#if defined( __WIN32__ ) || defined( _WIN32 )
input = antlr3StringStreamNew((pANTLR3_UINT8)data.c_str(), ANTLR3_ENC_UTF8, (ANTLR3_UINT32)data.length(), (pANTLR3_UINT8)"scs");
#elif defined( __APPLE_CC__)
input = antlr3StringStreamNew((pANTLR3_UINT8)data.c_str(), ANTLR3_ENC_UTF8, data.length(), (pANTLR3_UINT8)"scs");
#else
input = antlr3NewAsciiStringCopyStream((pANTLR3_UINT8)data.c_str(), data.length(), (pANTLR3_UINT8)"scs");
#endif
pscsLexer lex;
pANTLR3_COMMON_TOKEN_STREAM tokens;
pscsParser parser;
lex = scsLexerNew(input);
tokens = antlr3CommonTokenStreamSourceNew(ANTLR3_SIZE_HINT,
TOKENSOURCE(lex));
parser = scsParserNew(tokens);
scsParser_syntax_return r;
pANTLR3_BASE_TREE tree;
try
{
r = parser->syntax(parser);
} catch (const Exception &e)
{
THROW_EXCEPT(Exception::ERR_PARSE, e.getDescription(), mParams.fileName, e.getLineNumber());
}
tree = r.tree;
//dumpDot(tree);
// translate
buildScText(tree);
//dumpScs("test.scsd");
parser->free(parser);
tokens->free(tokens);
lex->free(lex);
input->close(input);
return true;
}
bool uSQL::SQLParser::parse(const std::string &queryString)
{
clear();
pANTLR3_INPUT_STREAM input = antlr3StringStreamNew(
(pANTLR3_UINT8)queryString.c_str(),
ANTLR3_ENC_UTF8,
(ANTLR3_UINT32)queryString.length(),
(pANTLR3_UINT8)"");
pSQLLexer lexer = SQLLexerNew(input);
pANTLR3_COMMON_TOKEN_STREAM tokens = antlr3CommonTokenStreamSourceNew(ANTLR3_SIZE_HINT, TOKENSOURCE(lexer));
pSQLParser parser = SQLParserNew(tokens);
parser->uSqlParser = this;
parser->statement_list(parser, this);
bool parserResult = true;
if (0 < parser->pParser->rec->state->errorCount) {
parserResult = false;
}
parser->free(parser);
tokens->free(tokens);
lexer->free(lexer);
input->close(input);
return parserResult;
}
nx::color::RadialGradientColor::RadialGradientColor( const wchar_t *desc )
{
pANTLR3_UINT8 input_string = (pANTLR3_UINT8)desc;
ANTLR3_UINT32 size = static_cast<ANTLR3_UINT32>(wcslen(desc) * 2);
pANTLR3_INPUT_STREAM stream = antlr3StringStreamNew(
input_string,
ANTLR3_ENC_UTF16,
size,
(pANTLR3_UINT8)"RadialGradientColor");
pANTLR3_UINT8 fName;
pANTLR3_COMMON_TOKEN_STREAM tstream;
pRadialGradientColorLexer lxr = RadialGradientColorLexerNew(stream);
tstream = antlr3CommonTokenStreamSourceNew(ANTLR3_SIZE_HINT, TOKENSOURCE(lxr));
pRadialGradientColorParser psr = RadialGradientColorParserNew(tstream);
nx::color::RadialGradientColor *color = psr->radialColor(psr);
if (psr->pParser->rec->state->errorCount > 0) {
LOG(SEVERITY_LEVEL_ERROR) << L"Failed to parse radial color descriptor '" << desc << L"'";
throw std::invalid_argument("Failed to parse radial color descriptor");
}
m_offsetRatio = color->m_offsetRatio;
m_gradientStops = std::move(color->m_gradientStops);
delete color;
}
std::shared_ptr<nx::color::colorsetdef::ColorSetDO> nx::color::colorsetdef::Decode(const std::wstring &s)
{
pANTLR3_UINT8 input_string = (pANTLR3_UINT8)s.c_str();
ANTLR3_UINT32 size = static_cast<ANTLR3_UINT32>(s.size() * 2);
pANTLR3_INPUT_STREAM stream = antlr3StringStreamNew(
input_string,
ANTLR3_ENC_UTF16,
size,
(pANTLR3_UINT8)"colorsetdef");
pANTLR3_UINT8 fName;
pANTLR3_COMMON_TOKEN_STREAM tstream;
pColorSetDefLexer lxr = ColorSetDefLexerNew(stream);
tstream = antlr3CommonTokenStreamSourceNew(ANTLR3_SIZE_HINT, TOKENSOURCE(lxr));
pColorSetDefParser psr = ColorSetDefParserNew(tstream);
std::shared_ptr<nx::color::colorsetdef::ColorSetDO> pColorSetDO(psr->colorSetDef(psr));
if (pColorSetDO != nullptr) {
size_t n = pColorSetDO->colors.size();
std::wcout << n << std::endl;
for (size_t i = 0; i < n; ++i) {
std::shared_ptr<nx::color::colorsetdef::IColorDO> color = pColorSetDO->colors[i];
switch (color->GetColorType()) {
case COLOR_TYPE_SOLID: {
std::shared_ptr<nx::color::colorsetdef::SolidColorDO> solid =
std::dynamic_pointer_cast<nx::color::colorsetdef::SolidColorDO>(color);
std::wcout << *solid << std::endl;
}
break;
case COLOR_TYPE_LINEAR: {
std::shared_ptr<nx::color::colorsetdef::LinearColorDO> linear =
std::dynamic_pointer_cast<nx::color::colorsetdef::LinearColorDO>(color);
std::wcout << *linear << std::endl;
}
break;
case COLOR_TYPE_RADIAL: {
std::shared_ptr<nx::color::colorsetdef::RadialColorDO> radial =
std::dynamic_pointer_cast<nx::color::colorsetdef::RadialColorDO>(color);
std::wcout << *radial << std::endl;
}
break;
}
}
}
psr->free(psr);
psr = NULL;
tstream->free(tstream);
tstream = NULL;
lxr->free(lxr);
lxr = NULL;
stream->close(stream);
stream = NULL;
std::shared_ptr<nx::color::colorsetdef::ColorSetDO> p(pColorSetDO);
return p;
}
ParserImpl& fromString(std::string const& src, std::string const& filename, int line)
{
this->src = src;
this->filename_ = filename;
stream = antlr3StringStreamNew((pANTLR3_UINT8)this->src.c_str(), ANTLR3_ENC_UTF8, src.size(), (pANTLR3_UINT8)this->filename_.c_str());
if(!stream){
DONUT_EXCEPTION(Exception, "Failed to create ANTLR3 String Stream for %s", filename.c_str());
}
stream->line=line;
setup();
return *this;
}
void MySQLScanner::setup()
{
log_debug2("Lexer setup\n");
d->_input = antlr3StringStreamNew((pANTLR3_UINT8)d->_text, d->_input_encoding, (ANTLR3_UINT32)d->_text_length,
(pANTLR3_UINT8)"mysql-script");
d->_input->setUcaseLA(d->_input, ANTLR3_TRUE); // Make input case-insensitive. String literals must all be upper case in the grammar!
d->_lexer = MySQLLexerNew(d->_input);
d->_lexer->pLexer->rec->state->userp = &d->_context;
d->_token_source = TOKENSOURCE(d->_lexer);
log_debug2("Lexer setup ended\n");
}
CifFileParser( builder_base* builder, std::string const filename, bool const strict=true) {
// antlr3FileStreamNew doesn't know how to eat pipes properly, so I didn't use it evetually
// input = antlr3FileStreamNew(pANTLR3_UINT8(filename.c_str()), ANTLR3_ENC_8BIT);
std::stringstream data;
std::ifstream myfile(filename, std::ifstream::in);
if (!myfile.is_open()) {
std::cerr << "Error: could not open file " << filename << std::endl;
exit(1);
}
char * buf = new char[1024*1024+1];
while (true) {
myfile.read(buf, 1024*1024);
int bytes_read = myfile.gcount();
buf[bytes_read]='\0'; // null-terminate
data << buf;
if ( bytes_read < 1024*1024 ) {
break;
}
}
delete buf;
myfile.close();
// see http://stackoverflow.com/questions/1374468/stringstream-string-and-char-conversion-confusion
std::string const & data_string = data.str();
data.clear();
input = antlr3StringStreamNew(
pANTLR3_UINT8(data_string.c_str()),
ANTLR3_ENC_8BIT,
data_string.size(),
pANTLR3_UINT8(filename.c_str())
);
lxr = cifLexerNew(input);
tstream = antlr3CommonTokenStreamSourceNew(ANTLR3_SIZE_HINT, TOKENSOURCE(lxr));
psr = cifParserNew(tstream);
psr->pParser->rec->displayRecognitionError = parser_displayRecognitionError;
psr->errors = builder->new_array();
lxr->pLexer->rec->displayRecognitionError = lexer_displayRecognitionError;
lxr->errors = builder->new_array();
psr->parse(psr, builder, strict);
fflush(stderr);
}
// static
FilterParser* FilterParser::parse(const std::string& expression) throw(ParseException) {
Logger* log = getLogger(NULL);
BaseExpression* rootExpression = NULL;
std::list<Token*> lTokens;
std::set<std::string> xpathTokens;
int errorCode = -1;
const char* errorMessage;
if (expression.length() != 0) {
//throw (ParseException) {
pANTLR3_INPUT_STREAM input;
pfilter_expressionLexer lex;
pANTLR3_COMMON_TOKEN_STREAM tokens;
pfilter_expressionParser parser;
const char* filter = expression.c_str();
if (log->isDebug()) log->debug("filter expression: %s, len: %d, Size Hint: %d", filter, strlen(filter), ANTLR3_SIZE_HINT);
input = antlr3StringStreamNew((pANTLR3_UINT8)filter, 8, (ANTLR3_UINT32)strlen(filter), (pANTLR3_UINT8)"name");
lex = filter_expressionLexerNew (input);
tokens = antlr3CommonTokenStreamSourceNew (ANTLR3_SIZE_HINT, TOKENSOURCE(lex));
parser = filter_expressionParserNew (tokens);
rootExpression = parser ->start_point(parser);
xpathTokens = __parser_tokens();
if (parser->pParser->rec->state->exception != NULL) {
errorCode = D_ERROR_PARSEERROR;
errorMessage = (char*)parser->pParser->rec->state->exception->message;
}
// Must manually clean up
//
parser ->free(parser);
tokens ->free(tokens);
lex ->free(lex);
input ->close(input);
}
if (errorCode > -1) {
throw ParseException(errorCode, errorMessage);
}
FilterParser* filterparser = new FilterParser(expression, rootExpression, lTokens);
filterparser->setTokens(xpathTokens);
return filterparser;
}
short parseJpVoc(const char* str,VocInfo vi) {
pANTLR3_INPUT_STREAM input;
pJpVocabularyLexer lxr;
pANTLR3_COMMON_TOKEN_STREAM tstream;
pJpVocabularyParser psr;
ANTLR3_FPRINTF(stdout,"parseJpVoc:%s\n",str);
input = antlr3StringStreamNew((pANTLR3_UINT8)str, ANTLR3_ENC_UTF8,
strlen(str),(pANTLR3_UINT8)"jpVocabu");
initParser(&input,&lxr,&tstream,&psr);
psr->vocabulary(psr,vi.pronun,
vi.writing,vi.partOfSpeech,vi.expl);
ANTLR3_FPRINTF(stdout,"parseJpVoc:pronun:%s\twriting:%s\tpartOfSpeech:%s\texpl:%s\n",
vi.pronun,vi.writing,vi.partOfSpeech,vi.expl);
cleanParser(&input,&lxr,&tstream,&psr);
return 0;
}
/**
* A lightweight function to determine the type of the given query by scanning only the absolute
* minimum text to make a funded decision.
*/
MySQLQueryType MySQLQueryIdentifier::getQueryType(const char *text, size_t length, bool is_utf8)
{
log_debug2("Starting query type determination\n");
pANTLR3_INPUT_STREAM input = antlr3StringStreamNew((pANTLR3_UINT8)text, is_utf8 ? ANTLR3_ENC_UTF8 : ANTLR3_ENC_8BIT,
(ANTLR3_UINT32)length, (pANTLR3_UINT8)"type-check");
input->setUcaseLA(input, ANTLR3_TRUE);
pMySQLLexer lexer = MySQLLexerNew(input);
// Reset temp vars used during lexing. We may not have scanned the tokens that reset those
// as we do only a minimum number of token retrievals.
d->_context.inVersionComment = false;
d->_context.versionMatched = false;
lexer->pLexer->rec->state->userp = &d->_context;
MySQLQueryType result = determineQueryType(TOKENSOURCE(lexer));
lexer->free(lexer);
input->close(input);
log_debug2("Query type determination done\n");
return result;
}
BSONObj* BSONParser::parse(const std::string& sbson) {
Logger* log = getLogger(NULL);
BSONObj* root = NULL;
int errorCode = -1;
const char* errorMessage;
if (sbson.length() != 0) {
//throw (ParseException) {
pANTLR3_INPUT_STREAM input;
pbson_grammarLexer lex;
pANTLR3_COMMON_TOKEN_STREAM tokens;
pbson_grammarParser parser;
const char* bsonExpression = sbson.c_str();
input = antlr3StringStreamNew((pANTLR3_UINT8)bsonExpression, 8, (ANTLR3_UINT32)strlen(bsonExpression), (pANTLR3_UINT8)"name");
lex = bson_grammarLexerNew (input);
tokens = antlr3CommonTokenStreamSourceNew (ANTLR3_SIZE_HINT, TOKENSOURCE(lex));
parser = bson_grammarParserNew (tokens);
root = parser ->start_point(parser);
if (parser->pParser->rec->state->exception != NULL) {
errorCode = D_ERROR_PARSEERROR;
errorMessage = (char*)parser->pParser->rec->state->exception->message;
}
// Must manually clean up
//
parser ->free(parser);
tokens ->free(tokens);
lex ->free(lex);
input ->close(input);
}
if (errorCode > -1) {
//throw ParseException(errorCode, errorMessage);
}
return root;
}
bool CAdjustStock::ParseAdjustLogic(const char* logicExp, HASH_MAP< string, double >&signalMap)
{
pANTLR3_INPUT_STREAM input;
pExprLexer lexer;
pANTLR3_COMMON_TOKEN_STREAM tstream ;
pExprParser parser;
pANTLR3_BASE_TREE root ;
if( strlen(logicExp) == 0 )
return false ;
try
{
input = antlr3StringStreamNew( (pANTLR3_UINT8) logicExp, ANTLR3_ENC_UTF8, strlen(logicExp), (pANTLR3_UINT8)"Expr" );
SHOULD( input, "fail to create stream from string: " << logicExp );
lexer = ExprLexerNew( input );
SHOULD( input, "fail to create lexer" );
tstream = antlr3CommonTokenStreamSourceNew( ANTLR3_SIZE_HINT, TOKENSOURCE(lexer) );
SHOULD( tstream, "fail to create token stream" );
parser = ExprParserNew( tstream );
SHOULD( parser, "fail to create parser" );
ExprParser_expr_return statments = (ExprParser_expr_return)( parser->expr(parser) );
int errs = parser->pParser->rec->state->errorCount;
if( errs>0 ){
LOG_FILE(LOG_LEVEL::LOG_INFO,"[AdjustStock] The parser returned %d errors, tree walking aborted.\n", errs);
return false ;
}
root = statments.tree;
SHOULD( root, "fail to get tree" );
pANTLR3_TOKEN_STREAM stream = tstream->tstream;
m_adjustTree.tree_ = root;
m_adjustTree.stream_ = stream;
//根据语法树的节点得到叶子节点类型为VAR的变量,返给调仓查询
//修改叶子节点是变量的值，key用Value替换
getVARList( m_adjustTree, m_varVec );
HASH_MAP< string, double >::iterator mit;
//test: srcSingleMap[000407_alpha_7_indus_sort, 1.23]
for ( size_t i =0; i<m_varVec.size(); i++ )
{
mit = signalMap.find(m_varVec[i]);
if ( mit != signalMap.end() ) {
m_parseMap[m_varVec[i]] = mit->second;
} else {
ISM_LOG_ERR("[AdjustStock]","the signal value not founded in singal map!");
return false;
}
}
//calculate the result from the replaced tree
int result = calcExpr(m_adjustTree);
if( parser ) { parser->free( parser );}
if( tstream ) { tstream->free( tstream );}
if( lexer ) { lexer->free( lexer );}
if( input ) { input->close( input );}
return result==1 ;
}
catch( Exp& e )
{
RETHROW( e, "fail to parse. line: " << logicExp );
}
}
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;
}
int open_string_stream( pParserComplect complect, pANTLR3_UINT8 string ) {
complect->stream = antlr3StringStreamNew( string, ANTLR3_ENC_UTF8, strlen(string), (pANTLR3_UINT8)"(eval)" );
return check_opened_stream( complect );
}
