/////////////////////////////////////////////////////////////////////// // 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); }