/* * Parse file, calling action specific functions for: * 1) Lines containing !E * 2) Lines containing !I * 3) Lines containing !D * 4) Lines containing !F * 5) Lines containing !P * 6) Lines containing !C * 7) Default lines - lines not matching the above */ static void parse_file(FILE *infile) { char line[MAXLINESZ]; char * s; while (fgets(line, MAXLINESZ, infile)) { if (line[0] == '!') { s = line + 2; switch (line[1]) { case 'E': while (*s && !isspace(*s)) s++; *s = '\0'; externalfunctions(line+2); break; case 'I': while (*s && !isspace(*s)) s++; *s = '\0'; internalfunctions(line+2); break; case 'D': while (*s && !isspace(*s)) s++; *s = '\0'; symbolsonly(line+2); break; case 'F': /* filename */ while (*s && !isspace(*s)) s++; *s++ = '\0'; /* function names */ while (isspace(*s)) s++; singlefunctions(line +2, s); break; case 'P': /* filename */ while (*s && !isspace(*s)) s++; *s++ = '\0'; /* DOC: section name */ while (isspace(*s)) s++; docsection(line + 2, s); break; case 'C': while (*s && !isspace(*s)) s++; *s = '\0'; if (findall) findall(line+2); break; default: defaultline(line); } } else { defaultline(line); } } fflush(stdout); }
void findall(TreeNode* root, string &a) { int val=root->val; string ha=to_string(val); if(a.size()!=0) a=a+"->"+ha; else a=ha; if(root->left==NULL&&root->right==NULL) { result.push_back(a); return; } string b=a; if(root->left!=NULL) findall(root->left,a); if(root->right!=NULL) findall(root->right,b); }
/* * Parse file, calling action specific functions for: * 1) Lines containing !E * 2) Lines containing !I * 3) Lines containing !D * 4) Lines containing !F * 5) Lines containing !P * 6) Lines containing !C * 7) Default lines - lines not matching the above */ static void parse_file(FILE *infile) { char line[MAXLINESZ]; char *p, *s; while (fgets(line, MAXLINESZ, infile)) { p = is_directive(line); if (!p) { defaultline(line); continue; } switch (*p++) { case 'E': chomp(p); externalfunctions(p); break; case 'I': chomp(p); internalfunctions(p); break; case 'D': chomp(p); symbolsonly(p); break; case 'F': /* filename */ s = chomp(p); /* function names */ while (isspace(*s)) s++; singlefunctions(p, s); break; case 'P': /* filename */ s = chomp(p); /* DOC: section name */ while (isspace(*s)) s++; docsection(p, s); break; case 'C': chomp(p); if (findall) findall(p); break; default: defaultline(line); } } fflush(stdout); }
void View::extract_regex(string regex, vector<int> groups, vector<string> column_names, string text) { vector<vector<int> > result = findall(regex.c_str(), text.c_str()); columns.clear(); for (int col = 0; col < groups.size(); col++) { columns.push_back(Column(column_names[col])); for (int i = 0; i < result.size(); i++) { int from = result[i][groups[col]*2] ,to = result[i][groups[col]*2+1]; columns[col].spans.push_back(Span(text.substr(from, to-from), from, to)); } } }
int main(void) { int i; node **L; if (sizeof(int) < 4) { puts("This code must be compiled with 32-bit ints!"); return EXIT_FAILURE; } L=newlist(); puts(" DOWN"); for(i = 100; i >= 0; i -=2) insertnode(L, i, i); puts(" UP"); for(i = 1; i < 100; i += 2) insertnode(L, i, i); deletenode(L, 40); puts(" FIND"); for(i = -2; i <= 100; ++i) findnode(L, i); puts(" FAST"); findall(L); puts("SAMPLES"); printf(" %d", findnode(L, -10)); printf(" %d,", findnode(L, 0)); printf(" %d", findnode(L, 1)); printf(" %d", findnode(L, 2)); printf(" %d", findnode(L, 39)); printf(" %d", findnode(L, 40)); printf(" %d", findnode(L, 41)); printf(" %d", findnode(L, 42)); puts(" DONE"); return EXIT_SUCCESS; }
std::vector<col> Parser::extract_stmt() { this->match("extract"); std::vector<token> extract_spec_v = this->extract_spec(); this->match("from"); std::vector<token> from_list_v = this->from_list(); std::map<std::string, std::string> temp_to_origin_view_name; for (int i = 0; (size_t)i < from_list_v.size(); i += 2) temp_to_origin_view_name[from_list_v[i + 1].value] = from_list_v[i].value; if (extract_spec_v[0].type == EMPTY) { /* * back-end extract regex logic. */ if (extract_spec_v.size() > 6) this->error("semantic error."); std::string reg = extract_spec_v[1].value.substr(1, extract_spec_v[1].value.length() - 2); col col_to_exec = this->get_col(this->get_view(temp_to_origin_view_name[extract_spec_v[2].value]), extract_spec_v[3].value); std::string col_name = (extract_spec_v.size() == 5) ? extract_spec_v[4].value : extract_spec_v[5].value; std::string document = col_to_exec.spans[0].value; std::vector< std::vector<int> > result = findall(reg.c_str(), document.c_str()); std::vector<col> regex_spec_col_v; col regex_exec_result = col(col_name); for (int i = 0; (size_t)i < result.size(); i++) { std::string match; for (int j = result[i][0]; j < result[i][1]; j++) match += document[j]; regex_exec_result.spans.push_back(span(match, result[i][0], result[i][1])); } regex_spec_col_v.push_back(regex_exec_result); return regex_spec_col_v; } else { /* * back-end extract pattern logic. */ int look = 0; std::vector<col> cols_to_exec; while (extract_spec_v[look].type != EMPTY) { if (extract_spec_v[look].type == ID) { col c = this->get_col(this->get_view(temp_to_origin_view_name[extract_spec_v[look].value]), extract_spec_v[look + 1].value); if (extract_spec_v[look].is_grouped) c.is_grouped = true; cols_to_exec.push_back(c); look += 2; } else if (extract_spec_v[look].type == TOKEN) { int min = atoi(extract_spec_v[look + 1].value.c_str()), max = atoi(extract_spec_v[look + 2].value.c_str()); std::string document = this->get_col(this->get_view("Document"), "text").spans[0].value; col token_col = col("token"); for (int i = min; i <= max; i++) for (int j = 0; (size_t)j + i <= this->document_tokens.size(); j++) token_col.spans.push_back(span("token", this->document_tokens[j].from, this->document_tokens[j + i - 1].to)); cols_to_exec.push_back(token_col); look += 3; } else if (extract_spec_v[look].type == REG) { std::string reg = extract_spec_v[look].value.substr(1, extract_spec_v[look].value.length() - 2); std::string document = this->get_col(this->get_view("Document"), "text").spans[0].value; std::vector< std::vector<int> > result = findall(reg.c_str(), document.c_str()); col regex_exec_result = col("regex"); for (int i = 0; (size_t)i < result.size(); i++) { std::string match; for (int j = result[i][0]; j < result[i][1]; j++) match += document[j]; regex_exec_result.spans.push_back(span(match, result[i][0], result[i][1])); } if (extract_spec_v[look].is_grouped) regex_exec_result.is_grouped = true; cols_to_exec.push_back(regex_exec_result); look++; } else this->error("pattern match failed."); } std::vector<record> r; std::string document = this->get_col(this->get_view("Document"), "text").spans[0].value; for (int j = 0; (size_t)j < cols_to_exec[0].spans.size(); j++) { int temp = cols_to_exec[0].spans[j].to; while (document[temp] == ' ') temp++; record re = record(temp); re.pos.push_back(j); r.push_back(re); } for (int i = 0; (size_t)i < cols_to_exec.size() - 1; i++) { std::vector<record> temp_record; for (int j = 0; (size_t)j < cols_to_exec[i + 1].spans.size(); j++) for (int k = 0; (size_t)k < r.size(); k++) if (cols_to_exec[i + 1].spans[j].from == r[k].to) { int temp = cols_to_exec[i + 1].spans[j].to; while (document[temp] == ' ') temp++; record re = record(temp); for (int t = 0; (size_t)t < r[k].pos.size(); t++) re.pos.push_back(r[k].pos[t]); re.pos.push_back(j); temp_record.push_back(re); } r.clear(); r.insert(r.end(), temp_record.begin(), temp_record.end()); } look++; std::vector<col> group; if (extract_spec_v[look].type == ID) group.push_back(col(extract_spec_v[look].value)); else while ((size_t)look < extract_spec_v.size()) group.push_back(col(extract_spec_v[look + 1].value)), look += 2; for (int i = 0; (size_t)i < r.size(); i++) { int group_count = 1; std::string span_value; int last_to = -1; for (int j = 0; (size_t)j < r[i].pos.size(); j++) { span s = cols_to_exec[j].spans[r[i].pos[j]]; if (last_to != -1) while (last_to != s.from) span_value += ' ', last_to++; span_value += (s.value == "token") ? document.substr(s.from, s.to - s.from) : s.value, last_to = s.to; if (cols_to_exec[j].is_grouped) group[group_count++].spans.push_back(s); } group[0].spans.push_back(span(span_value, cols_to_exec[0].spans[r[i].pos[0]].from, cols_to_exec[cols_to_exec.size() - 1].spans[r[i].pos[cols_to_exec.size() - 1]].to)); } return group; } }
vector<string> binaryTreePaths(TreeNode* root) { string ha; if(root==NULL) return result; findall(root,ha); return result; }