///////////////////////////////////////////////////////////////////////
// Class : CRenderer
// Method : declareVariable
// Description : Define a new variable
// Return Value : The new variable if successful, NULL otherwise
// Comments :
CVariable *CRenderer::declareVariable(const char *name,const char *type,int marker) {
CVariable cVariable,*nVariable;
assert(declaredVariables != NULL);
if (parseVariable(&cVariable,name,type)) {
// Parse successful, insert the variable into the dictionary
CVariable *oVariable;
if (declaredVariables->find(cVariable.name,oVariable)) {
if ( (cVariable.numFloats != oVariable->numFloats) ||
(cVariable.numItems != oVariable->numItems)) {
error(CODE_SYSTEM,"Variable \"%s\" was previously defined differently\n",cVariable.name);
} else {
if (cVariable.type != oVariable->type) {
if ((cVariable.type == TYPE_STRING) || (oVariable->type == TYPE_STRING)) {
error(CODE_SYSTEM,"Variable \"%s\" was previously defined differently\n",cVariable.name);
}
}
}
// Overwrite the container
oVariable->container = cVariable.container;
// If we're overwriting "st" make sure to overwrite the s and t too
if (oVariable->usageMarker == (PARAMETER_S | PARAMETER_T)) {
if (declaredVariables->find("s",nVariable)) {
nVariable->container = cVariable.container;
} else assert(FALSE);
if (declaredVariables->find("t",nVariable)) {
nVariable->container = cVariable.container;
} else assert(FALSE);
}
return oVariable;
}
// Add the new variable into the variables list
nVariable = new CVariable;
nVariable[0] = cVariable;
nVariable->next = variables;
nVariable->usageMarker = marker;
nVariable->defaultValue = NULL;
nVariable->accessor = -1;
variables = nVariable;
// Insert the variable into the variables trie
declaredVariables->insert(nVariable->name,nVariable);
// Make the variable global if it needs to be global
if (nVariable->storage == STORAGE_GLOBAL) {
makeGlobalVariable(nVariable);
}
return nVariable;
} else {
return NULL;
}
}
void GPUProgram::BindingTable::parse(const std::string& code) {
bindingArray.resize(0);
TextInput ti(TextInput::FROM_STRING, code);
while (ti.hasMore()) {
Token t = ti.read();
// Scan for "#"
while (! symbolMatch(t, "#") && ti.hasMore()) {
t = ti.read();
}
if (ti.hasMore()) {
// Read the comment line
Token t = ti.peek();
if (t.type() == Token::SYMBOL) {
ti.readSymbol();
if (t.string() == "var") {
parseVariable(ti);
} else if (t.string() == "const") {
parseConstant(ti);
}
}
}
}
}
static QString updateVariable(const QString &varStr, const QString &varsToAdd,
const QString &varsToRemove)
{
QSet<QString> var = parseVariable(varStr);
QSet<QString> ss = parseVariable(varsToAdd);
foreach (QString s, ss)
var << s;
ss = parseVariable(varsToRemove);
foreach (QString s, ss)
var.remove(s);
QStringList sl = QStringList::fromSet(var);
return sl.join(QLatin1String(" "));
}
///////////////////////////////////////////////////////////////////////
// Class : CTexture3d
// Method : defineChannels
// Description : Define the channels
// Return Value : -
// Comments : used by ptcapi, does not require RiBegin()
void CTexture3d::defineChannels(int n,char **channelNames,char **channelTypes) {
// determinte the channels
dataSize = 0;
channels = new CChannel[n];
// parse the channels / sample types
numChannels = 0;
for (int i=0;i<n;i++) {
// parse to next comma, remove spaces
CVariable var;
if (parseVariable(&var,channelNames[i],channelTypes[i]) == TRUE) {
// it's a predefined / already seen channel
strcpy(channels[numChannels].name,channelNames[i]);
channels[numChannels].sampleStart = dataSize;
channels[numChannels].numSamples = var.numFloats;
channels[numChannels].fill = NULL;
channels[numChannels].type = var.type;
//GSHTODO: deal with fill
dataSize += var.numFloats;
numChannels++;
} else {
error(CODE_BADTOKEN,"Failed to interpret display channel name \"%s\"\n",channelNames[i]);
}
}
}
///////////////////////////////////////////////////////////////////////
// Class : CRenderer
// Method : declareDisplayChannel
// Description : Define a new displayChannel
// Return Value : The new display channel, NULL otherwise
// Comments :
CDisplayChannel *CRenderer::declareDisplayChannel(const char *type) {
CDisplayChannel *oChannel;
CVariable cVariable,*oVariable;
assert(declaredChannels != NULL);
if (parseVariable(&cVariable,NULL,type) == FALSE) {
return NULL;
}
if (declaredChannels->find(cVariable.name,oChannel) == TRUE) {
if ((oChannel->numSamples == cVariable.numFloats) &&
((cVariable.storage != STORAGE_GLOBAL) || oChannel->outType == cVariable.entry)) {
return oChannel;
} else {
error(CODE_SYSTEM,"Channel \"%s\" was previously defined differently\n",cVariable.name);
return NULL;
}
} else {
oVariable = declareVariable(NULL,type);
if (oVariable == NULL) {
error(CODE_SYSTEM,"Channel definition \"%s\" is ill formed\n",type);
} else {
const int samples = oVariable->numFloats;
const int outType = (oVariable->storage == STORAGE_GLOBAL) ? oVariable->entry : -1;
oChannel = new CDisplayChannel(oVariable->name,oVariable,samples,-1,outType);
declaredChannels->insert(oChannel->name,oChannel);
displayChannels->push(oChannel);
return oChannel;
}
}
return NULL;
}
Lvk::Nlp::Predicate * Lvk::Nlp::Parser::parsePredicate(const QString &c1, const QString &c2,
const QString &comp)
{
QString varName1;
QString varName2;
Nlp::CompType op = parseCompType(comp);
if (parseVariable(c1, &varName1) != -1) {
if (parseVariable(c2, &varName2) != -1) {
return make_comp(Nlp::Variable(varName1), Nlp::Variable(varName2), op);
} else {
return make_comp(Nlp::Variable(varName1), c2, op);
}
} else {
if (parseVariable(c2, &varName2) != -1) {
return make_comp(c1, Nlp::Variable(varName2), op);
} else {
return make_comp(c1, c2, op);
}
}
}
bool LessParser::parseAtRuleOrVariable (LessStylesheet &stylesheet) {
Token token;
TokenList value, rule;
AtRule* atrule = NULL;
if (tokenizer->getTokenType() != Token::ATKEYWORD)
return false;
token = tokenizer->getToken();
tokenizer->readNextToken();
CssParser::skipWhitespace();
#ifdef WITH_LIBGLOG
VLOG(2) << "Parse: keyword: " << token;
#endif
if (parseVariable(value)) {
#ifdef WITH_LIBGLOG
VLOG(2) << "Parse: variable";
#endif
stylesheet.putVariable(token, value);
} else {
if (token == "@media") {
parseLessMediaQuery(token, stylesheet);
return true;
}
while(parseAny(rule)) {};
if (!parseBlock(rule)) {
if (tokenizer->getTokenType() != Token::DELIMITER) {
throw new ParseException(tokenizer->getToken(),
"delimiter (';') at end of @-rule");
}
tokenizer->readNextToken();
skipWhitespace();
}
// parse import
if (token == "@import" && rule.size() > 0) {
if (parseImportStatement(rule, stylesheet))
return true;
}
atrule = stylesheet.createLessAtRule(token);
atrule->setReference(reference);
atrule->setRule(rule);
}
return true;
}
shared_ptr<VariableStmt> Parser::parseVariables()
{
shared_ptr<VariableStmt> rootVal = make_shared<VariableStmt>();
rootVal->varDeclare = NULL;
while (advance(IDENT))
{
auto varDecl = parseVariable();
auto varStmt = make_shared<VariableStmt>();
varStmt->varDeclare = varDecl;
varStmt->value.value = "VariableStmt";
varStmt->value.tag = Tag::VAR;
rootVal->varRoot.push_back(varStmt);
}
currNode->addNode(rootVal);
return rootVal;
}
static void enterScope (tokenInfo *const parentToken,
const vString *const extraScope,
const int parentKind)
{
tokenInfo *token = newToken ();
int origParentKind = parentToken->parentKind;
copyToken (token, parentToken, true);
if (extraScope)
{
addToScope (token, extraScope);
token->parentKind = parentKind;
}
readToken (token);
while (token->type != TOKEN_EOF &&
token->type != TOKEN_CLOSE_CURLY)
{
bool readNext = true;
switch (token->type)
{
case TOKEN_OPEN_CURLY:
enterScope (token, NULL, -1);
break;
case TOKEN_KEYWORD:
readNext = parseFunction (token);
break;
case TOKEN_VARIABLE:
readNext = parseVariable (token);
break;
default: break;
}
if (readNext)
readToken (token);
}
copyToken (parentToken, token, false);
parentToken->parentKind = origParentKind;
deleteToken (token);
}
shared_ptr<TypeStmt> Parser::parseType()//暂不支持数组和枚举类型
{
it++;
auto typeRootVal = make_shared<TypeStmt>();
typeRootVal->typeDeclare = NULL;
while (it->tag == IDENT)
{
auto typeDecl=make_shared<TypeDecl>();
auto typeStmt = make_shared<TypeStmt>();
typeStmt->typeDeclare = typeDecl;
typeStmt->value.value = "TypeStmt";
typeStmt->value.tag = Tag::TYPE;
typeDecl->name = it->value;
typeDecl->type = DeclaredType::Record;
it++;
match(EQ);
it++;
switch (it->tag)
{
case RECORD:
while ((it + 1)->tag != END)
{
auto record1=parseVariable();
auto varStmt = make_shared<VariableStmt>();
varStmt->varDeclare = record1;
varStmt->value.value = "VariableStmt";
varStmt->value.tag = Tag::VAR;
typeDecl->vars.push_back(record1);
typeStmt->varStmts.push_back(varStmt);
}
it++;//match(END);
it++;
match(SEMI);
break;
default:
break;
}
typeRootVal->typeRoot.push_back(typeStmt);
}
currNode->addNode(typeRootVal);
return typeRootVal;
}
int parser::parseFuncArgs(char *p, int &iStartParse, subexp *pSubExp, float *pArgs, int &iArgsNum, variable_scope &varScope)
{
iStartParse++;
int iSubIndex = floatToInt(parseDigit(p,iStartParse,true));
// Implement unary minus here
for (int i = 0; pSubExp[iSubIndex].exp[i]; i++)
{
// Parse digit
if (isDigit(pSubExp[iSubIndex].exp[i]))
{
pArgs[iArgsNum] = parseDigit(pSubExp[iSubIndex].exp, i, true);
}
// Parse unary minus
else if (pSubExp[iSubIndex].exp[i]=='-' && pSubExp[iSubIndex].exp[i+1] && isDigit(pSubExp[iSubIndex].exp[i+1]))
{
i++;
pArgs[iArgsNum] = parseDigit(pSubExp[iSubIndex].exp, i, true, true);
}
// Parse next arg
else if (pSubExp[iSubIndex].exp[i]==',')
{
iArgsNum += 1;
continue;
}
// Parse build in func
else if (isChar(pSubExp[iSubIndex].exp[i]) && isFunc(pSubExp[iSubIndex].exp, i))
{
pArgs[iArgsNum] = pSubExp[parseBuildInFunc(pSubExp[iSubIndex].exp, i, pSubExp, varScope, true)].result;
}
// Parse variable
else if (isChar(pSubExp[iSubIndex].exp[i]))
{
pArgs[iArgsNum] = varScope.vScope[parseVariable(pSubExp[iSubIndex].exp, i, varScope, false)].getValue();
}
// Parse sub string
else if (pSubExp[iSubIndex].exp[i]=='$')
{
pArgs[iArgsNum] = pSubExp[parseSubExp(pSubExp[iSubIndex].exp, i, pSubExp, varScope, true)].result;
}
}
iArgsNum += 1;
return iSubIndex;
}
void LessParser::parseRulesetStatements (LessStylesheet &stylesheet,
LessRuleset &ruleset) {
Token token;
TokenList value;
UnprocessedStatement* statement;
CssComment* comment;
while (true) {
if (tokenizer->getTokenType() == Token::COMMENT) {
comment = ruleset.createComment();
comment->setComment(tokenizer->getToken());
tokenizer->readNextToken();
skipWhitespace();
} else if (tokenizer->getTokenType() == Token::ATKEYWORD) {
token = tokenizer->getToken();
tokenizer->readNextToken();
skipWhitespace();
if (parseVariable(value)) {
ruleset.putVariable(token, value);
value.clear();
} else if (token == "@media") {
parseMediaQueryRuleset(token, stylesheet, ruleset);
} else {
throw new ParseException(tokenizer->getToken(),
"Variable declaration after keyword.");
}
} else if ((statement = parseRulesetStatement(ruleset)) != NULL) {
// a selector followed by a ruleset is a nested rule
if (tokenizer->getTokenType() == Token::BRACKET_OPEN) {
parseRuleset(stylesheet, *statement->getTokens(), &ruleset);
ruleset.deleteUnprocessedStatement(*statement);
}
} else
break;
}
}
size_t CLSSource::parseStructure(std::string& src, size_t start){
Structure* structure = new Structure();
structure->source = this;
size_t i = src.find_first_of(" \t\n", start);
i = src.find_first_not_of(" \t\n", i+1);
size_t j = src.find_first_of(" \t\n{", i+1);
structure->name = src.substr(i, j-i);
j = src.find_first_of("{", j);
//std::cout << "Creating data structure: \"" << structure->name << "\"" << std::endl;
m_structures[structure->name] = structure;
i = src.find_first_not_of(" \t\n", j+1);
while (src[i] != '}') {
i = parseVariable(src, i, structure->variables);
i = src.find_first_not_of(" \t\n", i);
}
return i+2;
}
bool LessParser::parseAtRuleOrVariable (LessStylesheet &stylesheet) {
string keyword, import;
TokenList value, rule;
AtRule* atrule = NULL;
if (tokenizer->getTokenType() != Token::ATKEYWORD)
return false;
keyword = tokenizer->getToken();
tokenizer->readNextToken();
skipWhitespace();
#ifdef WITH_LIBGLOG
VLOG(2) << "Parse: keyword: " << keyword;
#endif
if (parseVariable(value)) {
#ifdef WITH_LIBGLOG
VLOG(2) << "Parse: variable";
#endif
stylesheet.putVariable(keyword, value);
} else {
if (keyword == "@media") {
parseLessMediaQuery(stylesheet);
return true;
}
while(parseAny(rule)) {};
if (!parseBlock(rule)) {
if (tokenizer->getTokenType() != Token::DELIMITER) {
throw new ParseException(tokenizer->getToken(),
"delimiter (';') at end of @-rule",
tokenizer->getLineNumber(),
tokenizer->getColumn(),
tokenizer->getSource());
}
tokenizer->readNextToken();
skipWhitespace();
}
// parse import
if (keyword == "@import") {
if (rule.size() != 1 ||
rule.front().type != Token::STRING)
throw new ParseException(rule.toString(), "A string with the \
file path",
tokenizer->getLineNumber(),
tokenizer->getColumn(),
tokenizer->getSource());
import = rule.front();
#ifdef WITH_LIBGLOG
VLOG(2) << "Import filename: " << import;
#endif
if (import.size() < 5 ||
import.substr(import.size() - 5, 4) != ".css") {
if (import.size() < 6 || import.substr(import.size() - 6, 5) != ".less")
import.insert(import.size() - 1, ".less");
importFile(import.substr(1, import.size() - 2), stylesheet);
return true;
}
}
atrule = stylesheet.createAtRule(keyword);
atrule->setRule(rule);
}
return true;
}
static void enterScope (tokenInfo *const parentToken,
const vString *const extraScope,
const int parentKind)
{
tokenInfo *token = newToken ();
int origParentKind = parentToken->parentKind;
copyToken (token, parentToken, TRUE);
if (extraScope)
{
token->parentKind = parentKind;
addToScope (token, extraScope, origParentKind);
}
readToken (token);
while (token->type != TOKEN_EOF &&
token->type != TOKEN_CLOSE_CURLY)
{
boolean readNext = TRUE;
switch (token->type)
{
case TOKEN_OPEN_CURLY:
enterScope (token, NULL, -1);
break;
case TOKEN_KEYWORD:
switch (token->keyword)
{
/* handle anonymous classes */
case KEYWORD_new:
readToken (token);
if (token->keyword != KEYWORD_class)
readNext = FALSE;
else
{
char buf[32];
tokenInfo *name = newToken ();
copyToken (name, token, TRUE);
snprintf (buf, sizeof buf, "AnonymousClass%u", ++AnonymousID);
vStringCopyS (name->string, buf);
readNext = parseClassOrIface (token, K_CLASS, name);
deleteToken (name);
}
break;
case KEYWORD_class: readNext = parseClassOrIface (token, K_CLASS, NULL); break;
case KEYWORD_interface: readNext = parseClassOrIface (token, K_INTERFACE, NULL); break;
case KEYWORD_trait: readNext = parseTrait (token); break;
case KEYWORD_function: readNext = parseFunction (token, NULL); break;
case KEYWORD_const: readNext = parseConstant (token); break;
case KEYWORD_define: readNext = parseDefine (token); break;
case KEYWORD_namespace: readNext = parseNamespace (token); break;
case KEYWORD_private: CurrentStatement.access = ACCESS_PRIVATE; break;
case KEYWORD_protected: CurrentStatement.access = ACCESS_PROTECTED; break;
case KEYWORD_public: CurrentStatement.access = ACCESS_PUBLIC; break;
case KEYWORD_var: CurrentStatement.access = ACCESS_PUBLIC; break;
case KEYWORD_abstract: CurrentStatement.impl = IMPL_ABSTRACT; break;
default: break;
}
break;
case TOKEN_VARIABLE:
readNext = parseVariable (token);
break;
default: break;
}
if (readNext)
readToken (token);
}
copyToken (parentToken, token, FALSE);
parentToken->parentKind = origParentKind;
deleteToken (token);
}
// static
LLMessageBlock * LLTemplateParser::parseBlock(LLTemplateTokenizer & tokens)
{
LLMessageBlock * blockp = NULL;
if(!tokens.want("{"))
{
return NULL;
}
// name first
std::string block_name = tokens.next();
// is name a legit C variable name
if (!b_variable_ok(block_name.c_str()))
{
llerrs << "not a legal block name: " << block_name
<< " at " << tokens.line() << llendl;
}
// now, block type ("Single", "Multiple", or "Variable")
std::string block_type = tokens.next();
// which one is it?
if (block_type == "Single")
{
// ok, we can create a block
blockp = new LLMessageBlock(block_name.c_str(), MBT_SINGLE);
}
else if (block_type == "Multiple")
{
// need to get the number of repeats
std::string repeats = tokens.next();
// is it a legal integer
if (!b_positive_integer_ok(repeats.c_str()))
{
llerrs << "not a legal integer for block multiple count: "
<< repeats << " at " << tokens.line() << llendl;
}
// ok, we can create a block
blockp = new LLMessageBlock(block_name.c_str(),
MBT_MULTIPLE,
atoi(repeats.c_str()));
}
else if (block_type == "Variable")
{
// ok, we can create a block
blockp = new LLMessageBlock(block_name.c_str(), MBT_VARIABLE);
}
else
{
llerrs << "bad block type: " << block_type
<< " at " << tokens.line() << llendl;
}
while(LLMessageVariable * varp = parseVariable(tokens))
{
blockp->addVariable(varp->getName(),
varp->getType(),
varp->getSize());
delete varp;
}
if(!tokens.want("}"))
{
llerrs << "Expecting closing } for block " << block_name
<< " at " << tokens.line() << llendl;
}
return blockp;
}
size_t CLSSource::parseVariable(std::string& src, size_t start){
return parseVariable(src, start, m_variables);
}
