int fun(){
int i;
for(i=1;i<root;i++){
if(freq[i] ==0 ){
leaf.push(i);
}
}
int f, p;
i = 0;
while(! leaf.empty() ){
f = leaf.top(); leaf.pop();
p = node[i];
edge.insert( make_pair(p, f) );
if(--freq[p] == 0 && p < root-1){
leaf.push(p);
}
i++;
}
edge.erase(0);
printf("(");
traceback(root-1);
printf(")\n");
edge.clear();
}
void readIn(){
int n;
e.clear();
r.clear();
h.clear();
string a, b;
cin>>n;
while(n--){ // type of plug
cin>>a;
e.insert(a);
}
cin>>n;
while(n--){ // type of device
cin>>a>>b;
if(e.find(b) != e.end()){
e.erase(b);
} else {
r[b]++;
}
}
cin>>n;
while(n--){ // type of adapter
cin>>a>>b;
//h.insert(make_pair(a,b));
h.insert(make_pair(b,a));
}
}
void patchSettingExit()
{
SendDlgItemMessage(hIpsDlg, IDC_SCREENSHOT_H, STM_SETIMAGE, IMAGE_BITMAP, 0);
memset(hItemHandles, 0, MAX_NODES);
memset(hPatchHandlesIndex, 0, MAX_NODES);
nPatchIndex = 0;
nNumPatches = 0;
for (int i = 0; i < MAX_NODES; i++) {
szPatchFileNames[i][0] = _T('\0');
szDataNames[i][0] = _T('\0');
}
// clear relations
depTable.clear();
confTable.clear();
itemStateTable.clear();
if (hPreview) {
DeleteObject((HGDIOBJ)hPreview);
hPreview = NULL;
}
if (hDefPreview) {
DeleteObject((HGDIOBJ)hDefPreview);
hDefPreview = NULL;
}
DeleteObject(hWhiteBGBrush);
EndDialog(hIpsDlg, 0);
}
void SV_SectorList_f( void )
{
areaParms_t ap;
// ap.mins = mins;
// ap.maxs = maxs;
// ap.list = list;
// ap.count = 0;
// ap.maxcount = maxcount;
entStats.clear();
SV_AreaEntitiesTree(sv_worldSectors,&ap,0);
char mess[1000];
multimap<int,pair<int,list<CBBox> > >::iterator j;
for(j=entStats.begin();j!=entStats.end();j++)
{
sprintf(mess,"**************************************************\n");
Sleep(5);
OutputDebugString(mess);
sprintf(mess,"level=%i, count=%i\n",(*j).first,(*j).second.first);
Sleep(5);
OutputDebugString(mess);
list<CBBox>::iterator k;
for(k=(*j).second.second.begin();k!=(*j).second.second.end();k++)
{
sprintf(mess,"mins=%f %f %f, maxs=%f %f %f\n",
(*k).mMins[0],(*k).mMins[1],(*k).mMins[2],(*k).mMaxs[0],(*k).mMaxs[1],(*k).mMaxs[2]);
OutputDebugString(mess);
}
}
}
LRUCache(int capacity)
{
count = 0;
count2Key.clear();
key2Value2Count.clear();
max = capacity;
}
void init() {
double INF = 262144;
S.clear();
S.insert(make_pair(Seg(Pt(-INF, -INF), Pt(INF, -INF), -1, -1), (Triangle*)NULL));
S.insert(make_pair(Seg(Pt(-INF, INF), Pt(INF, INF), -1, -1), (Triangle*)NULL));
status = 0;
}
void DFHack::EventManager::onStateChange(color_ostream& out, state_change_event event) {
static bool doOnce = false;
if ( !doOnce ) {
//TODO: put this somewhere else
doOnce = true;
EventHandler buildingHandler(Buildings::updateBuildings, 100);
DFHack::EventManager::registerListener(EventType::BUILDING, buildingHandler, NULL);
//out.print("Registered listeners.\n %d", __LINE__);
}
if ( event == DFHack::SC_WORLD_UNLOADED ) {
lastTick = 0;
lastJobId = -1;
for ( auto i = prevJobs.begin(); i != prevJobs.end(); i++ ) {
Job::deleteJobStruct((*i).second);
}
prevJobs.clear();
tickQueue.clear();
livingUnits.clear();
nextItem = -1;
nextBuilding = -1;
buildings.clear();
constructions.clear();
Buildings::clearBuildings(out);
gameLoaded = false;
nextInvasion = -1;
} else if ( event == DFHack::SC_WORLD_LOADED ) {
uint32_t tick = DFHack::World::ReadCurrentYear()*ticksPerYear
+ DFHack::World::ReadCurrentTick();
multimap<uint32_t,EventHandler> newTickQueue;
for ( auto i = tickQueue.begin(); i != tickQueue.end(); i++ ) {
newTickQueue.insert(pair<uint32_t,EventHandler>(tick + (*i).first, (*i).second));
}
tickQueue.clear();
tickQueue.insert(newTickQueue.begin(), newTickQueue.end());
nextItem = 0;
nextBuilding = 0;
lastTick = 0;
nextInvasion = df::global::ui->invasions.next_id;
gameLoaded = true;
}
}
void a_search(string t, multimap<string, int>& pos)
{
//扫描文本t
//返回其中出现的字典树中的字符串及其位置 存储于映射表pos中
pos.clear();
int i(0);
ac_node *p(&a_root);
while(i < (int)t.length())
{
int index = t[i] - 'a';
while(p->a_ch[index] == NULL && p != &a_root)
//若字典树中该节点不存在
//则沿着fail指针递归 直到回到根节点
p = p->a_fail;
if(p->a_ch[index] == NULL)
p = &a_root;
else
{
//若点p的孩子节点index存在
//即该孩子节点与文本下标i处字符匹配
p = p->a_ch[index];
ac_node *tmp(p);
while(tmp != &a_root)
{
//通过指针tmp找出所有可能与文本下标i处匹配的字符串
//因为除了p的孩子节点index 还可能存在其他字符串此时也与i处匹配
//
//在文档"AC自动机算法详解" 作者"极限定律"中
//第一个有问题的地方是:
//原文中该处的判断条件是:
//while(tmp != root && tmp->a_cnt == 0)
//(原文与本文中的变量名不一样 但代码的含义没有曲解)
//但是经过测试这里tmp->a_cnt == 0的条件恰好应该是相反的
//即tmp->a_cnt != 0 也可写作tmp->a_cnt(该值为正时即true)
if(tmp->a_cnt)
{
string s(a_getstring(tmp));
pos.insert(make_pair(s, i - (int)s.length() + 1));
//文档"AC自动机算法详解" 作者"极限定律"中
//第二个有问题的地方则是:
//原文中该处有一处操作:
//tmp->a_cnt = 0;
//(原文与本文中的变量名不一样 但代码的含义没有曲解)
//但我不太明白为何要将字典树中该字符串删除
//也可能只求字符串第一次出现的位置
//本文的代码中没有删除字符串
//测试用例中可以看出本文的代码找出了所有匹配到的字符串位置
}
tmp = tmp->a_fail;
}
}
++ i;
}
}
void clearMimeHandlerCache()
{
LOGDEB(("clearMimeHandlerCache()\n"));
typedef multimap<string, RecollFilter*>::value_type value_type;
multimap<string, RecollFilter *>::iterator it;
PTMutexLocker locker(o_handlers_mutex);
for (it = o_handlers.begin(); it != o_handlers.end(); it++) {
delete it->second;
}
o_handlers.clear();
}
void jack_host::get_automation(int param_no, multimap<uint32_t, automation_range> &dests)
{
dests.clear();
if (!cc_mappings)
return;
for(automation_map::iterator i = cc_mappings->begin(); i != cc_mappings->end(); ++i)
{
if (param_no == -1 || param_no == i->second.param_no)
dests.insert(*i);
}
}
vector<string> findItinerary(vector<pair<string, string>> tickets)
{
trav.clear();
for (int i=0;i<tickets.size();++i)
trav.emplace(tickets[i].first, tickets[i].second);
ans.clear();
solve("JFK");
reverse(ans.begin(), ans.end());
return ans;
}
static int parseRelations()
{
depTable.clear();
confTable.clear();
char assistName[MAX_PATH];
sprintf(assistName, "%s\\%s\\%s", WtoA(getMiscPath(PATH_IPS)), BurnDrvGetTextA(DRV_NAME), "assistant.txt");
//parse ips dat and update the treewidget
FILE* fp = fopen(assistName, "rt");
if (!fp) {
return 1;
}
char s[1024];
char* p = NULL;
string line;
size_t nLen = 0;
size_t pos = string::npos;
while (!feof(fp)) {
if (fgets(s, sizeof s, fp) != NULL) {
p = s;
// skip UTF-8 sig
if (strncmp(p, UTF8_SIGNATURE, strlen(UTF8_SIGNATURE)) == 0) {
p += strlen(UTF8_SIGNATURE);
}
if (p[0] == '#') {
continue; // skip comment
}
getLine(p);
line = p;
pos = line.find(">");
if (pos != string::npos) {
StringList depStrs = split2Str(line, ">");
string parent = *(depStrs.begin());
lowerString(parent);
StringList children = stringSplit(depStrs.back(), ",");
lowerTrimmed(children);
depTable.insert(make_pair(parent, children));
} else {
StringList conflicts = stringSplit(line, ",");
lowerTrimmed(conflicts);
confTable.push_back(conflicts);
}
}
}
return 0;
}
void operator& (multimap<double,double>& x, istream& stream) {
size_t l;
l & stream;
validateListSize (l);
x.clear ();
multimap<double,double>::iterator pos = x.begin ();
for (size_t i = 0; i < l; ++i) {
double s;
double t;
s & stream;
t & stream;
pos = x.insert (pos, make_pair (s,t));
}
}
void OP_perf_utils::op_release_resources(void)
{
map<pid_t, operf_process_info *>::iterator it = process_map.begin();
while (it != process_map.end())
delete it++->second;
process_map.clear();
multimap<string, struct operf_mmap *>::iterator images_it = all_images_map.begin();
while (images_it != all_images_map.end())
delete images_it++->second;
all_images_map.clear();
delete kernel_mmap;
operf_sfile_close_files();
operf_free_modules_list();
}
int countRangeSum(vector<int>& nums, int lower, int upper)
{
_hash.clear(); _prefix.clear();
_prefix.push_back(0);
for (int i = 0, sz = nums.size(); i < sz; i++)
{
_prefix.push_back(_prefix.back() + nums[i]);
_hash.insert(make_pair(_prefix.back(), i + 1));
}
int ret = 0;
for (int i = 0, sz = _prefix.size(); i < sz; i++)
{
int64_t hoge = _prefix[i];
for (auto it = _hash.lower_bound(hoge + lower);
it != _hash.end() && it -> first <= hoge + upper; it++ )
if (it -> second > i)
ret++;
}
return ret;
}
void solve() {
int i, j, cnt = 0;
for (i = 0; i < n; i++) {
tr[i].get();
ev[cnt++] = EVENT(i, tr[i].p1.x, IN);
ev[cnt++] = EVENT(i, tr[i].p2.x, CH);
ev[cnt++] = EVENT(i, tr[i].p3.x, OUT);
}
sort(ev, ev + cnt);
T.clear();
T.insert(make_pair(SEG(POINT(-INF, -INF), POINT(INF, -INF), -1), 1));
T.insert(make_pair(SEG(POINT(-INF, INF), POINT(INF, INF), -1), 0));
curx = 0, ans = 1;
for (i = 0; i < cnt && ans != -1; i++) {
j = ev[i].id, curx = ev[i].x;
if (ev[i].type == IN) {
tr[j].p12 = T.insert(make_pair(SEG(tr[j].p1, tr[j].p2, j), 0));
tr[j].p13 = T.insert(make_pair(SEG(tr[j].p1, tr[j].p3, j), 0));
if (!isok(tr[j].p12) || !isok(tr[j].p13)) ans = -1;
else {
IT t = tr[j].p12;
if (++t == tr[j].p13) update(tr[j].p12, tr[j].p13);
else update(tr[j].p13, tr[j].p12);
}
} else if (ev[i].type == CH) {
if (!isok(tr[j].p12)) ans = -1;
else {
tr[j].p23 = T.insert(make_pair(SEG(tr[j].p2, tr[j].p3, j), tr[j].p12->second));
T.erase(tr[j].p12);
if (!isok(tr[j].p23)) ans = -1;
}
} else if (ev[i].type == OUT) {
if (!isok(tr[j].p13) || !isok(tr[j].p23)) ans = -1;
else T.erase(tr[j].p13), T.erase(tr[j].p23);
}
}
if (ans == -1) printf("ERROR\n");
else printf("%d shades\n", ans);
}
double getValue(double value){
if(type == Filter_Median){
data.push_back(value);
medianMap.clear();
for(int i=0; i < data.size(); i++){
medianMap.insert(make_pair(data[i], data[i]));
}
double median = getValue();
medians.push_back(median);
if(medians.size() > mediansLength){
medians.erase(medians.begin());
}
value = 0.0;
for(unsigned int i=0; i<medians.size(); i++){
value += medians[i];
}
value = value / (double) medians.size();
}
else if(type == Filter_Average){
data.push_back(value);
value = getValue();
}
if(data.size() > bufferLength){
data.erase(data.begin());
}
return value;
}
int main()
{
int no_n_t,no_t;
printf("No of Non Terminals\n");
scanf("%d",&no_n_t);
printf("Enter Non Terminals\n");
string non_terminal,terminal;
while(no_n_t--)
{
cin>>non_terminal;
n_t.push_back(non_terminal);
}
printf("No of Terminals\n");
scanf("%d",&no_t);
printf("Enter Terminals\n");
while(no_t--)
{
cin>>terminal;
t.push_back(terminal);
}
printf("Enter Rules\n");
char c;
string rule,cur_rule;
int len;
multimap<string,string>::iterator it;
fflush(stdin);
for(unsigned int i=0;i<n_t.size();i++)
{
rule.clear();
cout<<"For "<<n_t[i]<<":"<<endl;
while((c=getc(stdin))!='\n')
{
rule.push_back(c);
}
//cout<<rule<<endl;
/*********************/
/* Rules Parser ('|')*/
/*********************/
len=rule.size();
cur_rule.clear();
for(int j=0;j<len;j++)
{
if(rule[j]=='|')
{
rules.insert(pair<string,string>(n_t[i],cur_rule));
cur_rule.clear();
}
else
{
cur_rule.push_back(rule[j]);
}
}
rules.insert(pair<string,string>(n_t[i],cur_rule));
cur_rule.clear();
}
for(it=rules.begin();it!=rules.end();it++)
{
//cout<<(*it).first<<" "<<(*it).second<<endl;
}
//left_factor();
/*********************************/
/* Eliminating Left Recursion. */
/*********************************/
eliminate_left_recursion(rules);
cout<<"New Rules"<<endl;
update_non_terminals();
for(it=rules.begin();it!=rules.end();it++)
{
cout<<(*it).first<<" "<<(*it).second<<endl;
}
cout<<"----------------------------------------------"<<endl;
left_factor();
update_non_terminals();
rules.clear();
for(it=left_factored_rules.begin();it!=left_factored_rules.end();it++)
{
rules.insert(pair<string,string>((*it).first,(*it).second));
}
cout<<"Rules after left factoring"<<endl;
for(it=rules.begin();it!=rules.end();it++)
{
cout<<(*it).first<<" "<<(*it).second<<endl;
}
cout<<"Non Terminals..."<<endl;
for(int i=0;i<n_t.size();i++)
{
cout<<n_t[i]<<endl;
}
first();
follow();
for(int i = 0; i < n_t.size(); i++)
{
vector<string> row(t.size()+1,"`");
LL1_PT[n_t[i]] = row;
}
construct_LL1_pt();
ofstream fout;
fout.open("LL1_Table.ap");
map< string,vector<string> > ::iterator ip;
// fout<<"\t";
// for(int i = 0; i < t.size(); i++)
// fout<<t[i]<<"\t";
// fout<<"#"<<endl;
for(ip = LL1_PT.begin(); ip != LL1_PT.end(); ip++)
{
fout<<ip->first;
for(int i = 0; i < t.size(); i++)
{
fout<<"\t"<<LL1_PT[ip->first][i];
}
fout<<"\t"<<LL1_PT[ip->first][t.size()]<<endl;
}
fout.close();
fout.open("non_terminals.ap");
for(int i = 0; i < n_t.size(); i++)
fout<<n_t[i]<<"\t";
fout.close();
fout.open("terminals.ap");
for(int i = 0; i < t.size(); i++)
fout<<t[i]<<"\t";
fout<<"#";
fout.close();
cout<<n_t[0]<<endl;
}
void DFHack::EventManager::onStateChange(color_ostream& out, state_change_event event) {
static bool doOnce = false;
// const string eventNames[] = {"world loaded", "world unloaded", "map loaded", "map unloaded", "viewscreen changed", "core initialized", "begin unload", "paused", "unpaused"};
// out.print("%s,%d: onStateChange %d: \"%s\"\n", __FILE__, __LINE__, (int32_t)event, eventNames[event].c_str());
if ( !doOnce ) {
//TODO: put this somewhere else
doOnce = true;
EventHandler buildingHandler(Buildings::updateBuildings, 100);
DFHack::EventManager::registerListener(EventType::BUILDING, buildingHandler, NULL);
//out.print("Registered listeners.\n %d", __LINE__);
}
if ( event == DFHack::SC_MAP_UNLOADED ) {
lastJobId = -1;
for ( auto i = prevJobs.begin(); i != prevJobs.end(); i++ ) {
Job::deleteJobStruct((*i).second, true);
}
prevJobs.clear();
tickQueue.clear();
livingUnits.clear();
buildings.clear();
constructions.clear();
equipmentLog.clear();
Buildings::clearBuildings(out);
lastReport = -1;
lastReportUnitAttack = -1;
gameLoaded = false;
multimap<Plugin*,EventHandler> copy(handlers[EventType::UNLOAD].begin(), handlers[EventType::UNLOAD].end());
for (auto a = copy.begin(); a != copy.end(); a++ ) {
(*a).second.eventHandler(out, NULL);
}
} else if ( event == DFHack::SC_MAP_LOADED ) {
/*
int32_t tick = df::global::world->frame_counter;
multimap<int32_t,EventHandler> newTickQueue;
for ( auto i = tickQueue.begin(); i != tickQueue.end(); i++ )
newTickQueue.insert(pair<int32_t,EventHandler>(tick+(*i).first, (*i).second));
tickQueue.clear();
tickQueue.insert(newTickQueue.begin(), newTickQueue.end());
//out.print("%s,%d: on load, frame_counter = %d\n", __FILE__, __LINE__, tick);
*/
//tickQueue.clear();
if (!df::global::item_next_id)
return;
if (!df::global::building_next_id)
return;
if (!df::global::job_next_id)
return;
if (!df::global::ui)
return;
if (!df::global::world)
return;
nextItem = *df::global::item_next_id;
nextBuilding = *df::global::building_next_id;
nextInvasion = df::global::ui->invasions.next_id;
lastJobId = -1 + *df::global::job_next_id;
constructions.clear();
for ( auto i = df::global::world->constructions.begin(); i != df::global::world->constructions.end(); i++ ) {
df::construction* constr = *i;
if ( !constr ) {
if ( Once::doOnce("EventManager.onLoad null constr") ) {
out.print("EventManager.onLoad: null construction.\n");
}
continue;
}
if ( constr->pos == df::coord() ) {
if ( Once::doOnce("EventManager.onLoad null position of construction.\n") )
out.print("EventManager.onLoad null position of construction.\n");
continue;
}
constructions[constr->pos] = *constr;
}
for ( size_t a = 0; a < df::global::world->buildings.all.size(); a++ ) {
df::building* b = df::global::world->buildings.all[a];
Buildings::updateBuildings(out, (void*)b);
buildings.insert(b->id);
}
lastSyndromeTime = -1;
for ( size_t a = 0; a < df::global::world->units.all.size(); a++ ) {
df::unit* unit = df::global::world->units.all[a];
for ( size_t b = 0; b < unit->syndromes.active.size(); b++ ) {
df::unit_syndrome* syndrome = unit->syndromes.active[b];
int32_t startTime = syndrome->year*ticksPerYear + syndrome->year_time;
if ( startTime > lastSyndromeTime )
lastSyndromeTime = startTime;
}
}
lastReport = -1;
if ( df::global::world->status.reports.size() > 0 ) {
lastReport = df::global::world->status.reports[df::global::world->status.reports.size()-1]->id;
}
lastReportUnitAttack = -1;
lastReportInteraction = -1;
reportToRelevantUnitsTime = -1;
reportToRelevantUnits.clear();
for ( size_t a = 0; a < EventType::EVENT_MAX; a++ ) {
eventLastTick[a] = -1;//-1000000;
}
gameLoaded = true;
}
}
int main()
{
myPow[0] = 1;
for(int i = 1; i < 110; ++i)
myPow[i] = myPow[i - 1] * p;
while(scanf("%d", &k) == 1)
{
mp.clear();
if(k == 0) break;
scanf("%s%s%s", w[0], w[1], s);
wlen[0] = strlen(w[0]);
wlen[1] = strlen(w[1]);
slen = strlen(s);
for(int i = 0; i < slen - wlen[0] + 1; ++i)
{
static char curKey[110];
static bool vis[110];
for(int j = 0; j < wlen[0]; ++j)
curKey[j] = (((int)s[i + j] - 1 - w[0][j]) % 26 + 26) % 26 + 'A', vis[j + 1] = false;
curKey[wlen[0]] = 0;
initHash(curKey, wlen[0]);
for(int l = 1; l <= k; ++l)
{
if(vis[l]) continue;
int startPos = i % l;
long long h = hashVal[l - 1];
bool flag = true;
for(int i = 0; i * l + l - 1 < wlen[0]; ++i)
{
if(h * (myPow[i * l]) != (hashVal[i * l + l - 1] - (i * l == 0 ? 0 : hashVal[i * l - 1])))
{
flag = false;
break;
}
}
if(!flag) continue;
for(int i = wlen[0] / l * l, j = 0; i < wlen[0]; ++i, ++j)
{
if(curKey[i] != curKey[j])
{
flag = false;
break;
}
}
if(flag)
{
for(int i = 0; i * l <= wlen[0]; ++i)
vis[i * l] = true;
static char finalKey[110];
h = 0;
for(int i = startPos, j = 0; j < l; ++j, i = (i + 1) % l)
finalKey[i] = curKey[j % wlen[0]];
finalKey[l] = 0;
for(int i = 0; i < l; ++i)
h += myPow[i] * finalKey[i];
mp.insert(make_pair(h, i));
}
}
}
int cnt = 0, keyLen;
char key[110];
long long resKey;
// printf("%d %d\n", wlen[0], wlen[1]);
for(int i = 0; i < slen - wlen[1] + 1; ++i)
{
static char curKey2[110];
static bool vis2[110];
for(int j = 0; j < wlen[1]; ++j)
curKey2[j] = (((int)s[i + j] - 1 - w[1][j]) % 26 + 26) % 26 + 'A', vis2[j + 1] = false;
curKey2[wlen[1]] = 0;
initHash(curKey2, wlen[1]);
for(int l = 1; l <= k; ++l)
{
if(vis2[l]) continue;
int startPos = i % l;
long long h = hashVal[l - 1];
bool flag = true;
for(int i = 0; (i + 1) * l - 1 < wlen[1]; ++i)
{
if(h * (myPow[i * l]) != (hashVal[i * l + l - 1] - (i * l == 0 ? 0 : hashVal[i * l - 1])))
{
flag = false;
break;
}
}
if(!flag) continue;
for(int i = wlen[1] / l * l, j = 0; i < wlen[1]; ++i, ++j)
{
if(curKey2[i] != curKey2[j])
{
flag = false;
break;
}
}
if(flag)
{
for(int i = 0; i * l <= wlen[1]; ++i)
vis2[i * l] = true;
static char finalKey2[110];
h = 0;
for(int i = startPos, j = 0; j < l; ++j, i = (i + 1) % l)
finalKey2[i] = curKey2[j % wlen[1]];
for(int i = 0; i < l; ++i)
h += myPow[i] * finalKey2[i];
finalKey2[l] = 0;
pair<multimap<long long, int>::iterator, multimap<long long, int>::iterator> range;
range = mp.equal_range(h);
if(range.first == range.second) continue;
range.second--;
// printf("%d %d\n", range.first -> second, range.second -> second);
if(range.first -> second + wlen[0] - 1 < i || (range.second) -> second > i + wlen[1] - 1)
{
if(cnt != 0)
{
if(resKey == h) continue;
}
cnt++;
if(cnt == 1)
{
for(int j = 0; j < l; ++j)
key[j] = finalKey2[j];
keyLen = l;
resKey = h;
}
}
}
}
}
if(cnt == 1)
{
for(int i = 0, j = 0; i < slen; ++i, j = (j + 1) % keyLen)
{
putchar((((int)s[i] - 'A' - key[j] + 'A' - 1) % 26 + 26) % 26 + 'A');
}
puts("");
}
else
{
if(cnt > 1)
puts("ambiguous");
else
puts("impossible");
}
}
return 0;
}
void left_factor()
{
/*************************************/
/* Algorithm
/* Generate all the prefixes of
all the rules.
/* Take each prefix one by one
/* Check if it is the common
/* prefix of atleast two of the
/* rules.
/* Update the longest common prefix.*/
/*************************************/
bool non_terminal_used;
string RHS;
string pre;
multimap<string,string>::iterator it;
string new_left_rule;
// for(int i=0;i<prefixes.size();i++)
// {
// cout<<"Prefix:"<<prefixes[i]<<endl;
// }
string prefix_of_rhs;
int len_of_prefix;
int len_of_longest_prefix;
string longest_prefix; // keeps track of what is the longest prefix.
int longest_prefix_index=-1;
int count_of_matches; // keeps track of how many rules match for a given prefix.
string left,remaining; // left holds the prefix. // remaining holds the remaining RHS.
string new_non_terminal;
for(int n=0;n<n_t.size();n++)
{
memset(is_considered,0,sizeof(is_considered));
memset(is_matched,0,sizeof(is_matched));
prefixes.clear();
current_non_term_rules.clear();
it=rules.find(n_t[n]);
for(;it!=rules.end() && ((*it).first.compare(n_t[n])==0);it++)
{
current_non_term_rules.insert(pair<string,string>((*it).first,(*it).second));
}
for(it=current_non_term_rules.begin();it!=current_non_term_rules.end();it++)
{
pre.clear();
RHS=(*it).second;
//cout<<(*it).first<<"-->"<<(*it).second<<endl;
//cout<<RHS.size();
for(int i=0;i<RHS.size();i++)
{
pre.clear();
for(int j=0;j<=i;j++)
{
pre.push_back(RHS[j]);
}
if(find(prefixes.begin(),prefixes.end(),pre)==prefixes.end())
prefixes.push_back(pre);
}
}
// for(it=current_non_term_rules.begin();it!=current_non_term_rules.end();it++)
// {
// cout<<(*it).first<<"-->"<<(*it).second;
// }
for(int m=0;m<current_non_term_rules.size();m++)
{
//cout<<"Round "<<m<<endl;
longest_prefix.clear();
for(int i=0;i<prefixes.size();i++)
{
//cout<<"Current Prefix:"<<prefixes[i]<<endl;
len_of_prefix=prefixes[i].size();
count_of_matches=0;
for(it=current_non_term_rules.begin();it!=current_non_term_rules.end();it++)
{
// if(is_matched[it-rules.begin()])
// continue;
prefix_of_rhs.clear();
RHS.clear();
RHS=(*it).second;
//cout<<(*it).first<<"-->"<<(*it).second<<endl;
if(RHS.size()<len_of_prefix|| is_considered[distance(current_non_term_rules.begin(),it)])
continue;
for(int j=0;j<len_of_prefix;j++)
{
prefix_of_rhs.push_back(RHS[j]);
}
//cout<<"Prefix of RHS:"<<prefix_of_rhs<<endl;
if(prefix_of_rhs.compare(prefixes[i])==0)
{
//cout<<prefix_of_rhs<<"matched with "<<prefixes[i]<<endl;
//cout<<"Rule No:"<<distance(rules.begin(),it)<<endl;
is_matched[i][distance(current_non_term_rules.begin(),it)]=true;
count_of_matches++;
}
}
// cout<<"RUles after longest prefix"<<endl;
// for(it=rules.begin();it!=rules.end();it++)
// {
// cout<<"Rule No:"<<<<"-"<<(*it).first<<"-->"<<(*it).second<<endl;
// }
//cout<<"Prefix is:"<<prefixes[i]<<" has count:"<<count_of_matches<<endl;
if(count_of_matches>1 && prefixes[i].size()>=1)
{
if(longest_prefix.size()<prefixes[i].size())
{
longest_prefix.clear();
longest_prefix=prefixes[i];
longest_prefix_index=i;
}
}
}
//cout<<"Index:"<<longest_prefix_index<<"and longest prefix is :"<<longest_prefix<<"!"<<endl;
if(longest_prefix_index!=-1 && longest_prefix.size()>=1)
{
/* Get rules which matched the longest prefix.*/
non_terminal_used=false;
new_non_terminal=next_nt_string();
for(int j=0;j<current_non_term_rules.size();j++)
{
if(is_matched[longest_prefix_index][j] && !is_considered[j])
{
non_terminal_used=true;
it=current_non_term_rules.begin();
advance(it,j);
RHS=(*it).second;
//cout<<"Rule No:"<<j<<"-"<<(*it).first<<"-->"<<(*it).second<<endl;
len_of_longest_prefix=longest_prefix.size();
left.clear();
remaining.clear();
for(int k=0;k<len_of_longest_prefix;k++)
{
left.push_back(RHS[k]);
}
if(RHS[len_of_longest_prefix]==' ')
len_of_longest_prefix++;
for(int k=len_of_longest_prefix;k<RHS.size();k++)
{
remaining.push_back(RHS[k]);
}
if(remaining.size()==0)
remaining="$"; //epsilon.
//cout<<"Remaining:"<<remaining<<" and new non terminal: "<<new_non_terminal<<endl;
/* Erase the current rule an push back the new rule in rules.*/
assert(left.compare(longest_prefix)==0);
//cout<<"Prefix:"<<left<<"and remaining: "<<remaining<<endl;
new_left_rule.clear();
if(longest_prefix[longest_prefix.size()-1]!=' ')
new_left_rule.append(longest_prefix).append(" ").append(new_non_terminal);
else
new_left_rule.append(longest_prefix).append(new_non_terminal);
left_factored_rules.insert(pair<string,string>(new_non_terminal,remaining));
is_considered[distance(current_non_term_rules.begin(),it)]=true;
//rules.erase(it);
}
}
if(non_terminal_used)
{
left_factored_rules.insert(pair<string,string>((*it).first,new_left_rule));
left_fact_n_t.push_back(new_non_terminal);
}
}
}
update_rules(is_considered);
}
multimap<string,string>::iterator iter;
for(iter=left_factored_rules.begin();iter!=left_factored_rules.end();iter++)
{
cout<<(*iter).first<<"-->"<<(*iter).second<<endl;
}
}
int main() {
int n;
while(cin >> n >> ws) {
// reset.
vexp.clear();
vvar.clear();
vals.clear();
expr.clear();
vreq.assign(n, set<string>());
vidx.clear();
q.clear();
broken = false;
ans = 0;
result.clear();
// input and calculation.
for(int i = 0; i < n; ++i) {
//cout << "i = " << i << endl;
string s;
getline(cin, s);
int p = s.find(' ');
vvar.push_back(s.substr(0, p));
vexp.push_back(s.substr(p + 3));
//cout << "vvar = |" << vvar[i] << "|" << endl;
//cout << "vexp = |" << vexp[i] << "|" << endl;
// scratch all the reference variables.
// add sentienl to split.
istringstream iss(vexp.back());
string v;
while(iss >> v) {
// if variable gotcha.
if(isalpha(v[0])) {
// initialize variable list
vals[v] = 0;
expr[v] = "";
// add requirement link
vreq[i].insert(v);
// add index link, AVOID repeatly link.
if(vidx[v].size() == 0 || vidx[v].back() != i) {
vidx[v].push_back(i);
}
}
}
// if the value is clear.
if(vreq[i].size() == 0) {
i64 val = eval(vexp.back());
q.insert(make_pair(val, i));
}
}
// proccess
while(!q.empty()) {
// pop from priority queue.
i64 val = q.begin()->first;
int i = q.begin()->second;
q.erase(q.begin());
// get var.
string v = vvar[i];
if(vals[v] == 0) {
result.push_back(i);
vals[v] = val;
expr[v] = vexp[i];
for(int j = 0; j < vidx[v].size(); ++j) {
int k = vidx[v][j];
// kick the link.
vreq[k].erase(v);
// if all requirement was calculated.
if(vreq[k].empty()) {
i64 val = eval(vexp[k]);
if(val != 0) q.insert(make_pair(val, k));
}
}
}
}
// reduce..
if(result.size() < vals.size()) broken = true;
for(map<string, i64>::iterator it = vals.begin(); it != vals.end(); ++it) {
// if overflow
if(ans + it->second < ans) {
broken = true;
break;
}
ans += it->second;
}
if(broken) {
cout << "stupid expressions!" << endl;
}
else {
cout << ans << endl;
for(int i = 0; i < result.size(); ++i) {
int j = result[i];
cout << vvar[j] << " = " << vexp[j] << endl;
}
}
}
return 0;
}
void RegularExpression::turingMachine(string regularExpression){
firstDelimiter = find(reservedfirstDelimiters.begin(), reservedfirstDelimiters.end(), regularExpression[0]); // verify if the first character is a delimiter
if(regularExpression.size() == 1 || ((regularExpression[0] != regularExpression[regularExpression.size() - 1]) &&
!(*firstDelimiter)) || (regularExpression[0] == '\\' || regularExpression[regularExpression.size() - 1] == '\\') ||
regularExpression[0] == ']' || regularExpression[0] == '}' || regularExpression[0] == ')' ||
regularExpression[0] == '>') cout << "Error: Missing primary delimiters" << endl; // analyse if the first and last characters are not delimiters
else if(regularExpression[0] == '[' && regularExpression[regularExpression.size() - 1] != ']' ||
regularExpression[0] == '{' && regularExpression[regularExpression.size() - 1] != '}' ||
regularExpression[0] == '(' && regularExpression[regularExpression.size() - 1] != ')' ||
regularExpression[0] == '<' && regularExpression[regularExpression.size() - 1] != '>' ||
regularExpression[0] == '/' && regularExpression[regularExpression.size() - 1] != '/' ||
regularExpression[0] == '#' && regularExpression[regularExpression.size() - 1] != '#' ||
regularExpression[0] == '~' && regularExpression[regularExpression.size() - 1] != '~' ||
regularExpression[0] == '%' && regularExpression[regularExpression.size() - 1] != '%' ||
regularExpression[0] == '@' && regularExpression[regularExpression.size() - 1] != '@' ||
regularExpression[0] == '!' && regularExpression[regularExpression.size() - 1] != '!'){ // analyse if the first is a delimiter and close with its proprer closing delimiter
if(regularExpression[regularExpression.size() - 1] == 'i' &&
regularExpression[0] == '[' && regularExpression[regularExpression.size() - 2] != ']' ||
regularExpression[0] == '{' && regularExpression[regularExpression.size() - 2] != '}' ||
regularExpression[0] == '(' && regularExpression[regularExpression.size() - 2] != ')' ||
regularExpression[0] == '<' && regularExpression[regularExpression.size() - 2] != '>' ||
regularExpression[0] == '/' && regularExpression[regularExpression.size() - 2] != '/' ||
regularExpression[0] == '#' && regularExpression[regularExpression.size() - 2] != '#' ||
regularExpression[0] == '~' && regularExpression[regularExpression.size() - 2] != '~' ||
regularExpression[0] == '%' && regularExpression[regularExpression.size() - 2] != '%' ||
regularExpression[0] == '@' && regularExpression[regularExpression.size() - 2] != '@' ||
regularExpression[0] == '!' && regularExpression[regularExpression.size() - 2] != '!'){ // for case insensitive
cout << "Error: Expected closing delimiter for " << *firstDelimiter << " at position " << 0 << endl;
}
else if(regularExpression[regularExpression.size() - 1] != 'i'){
cout << "Error: Expected closing delimiter for " << *firstDelimiter << " at position " << 0 << endl;
}
}
else{
if(countOccurrences(regularExpression, regularExpression[0], 0, regularExpression.size()) > 2){ // if primary delimeters have more than two ocurrences, because it's a nesting
cout << "Error: Primary delimiters has a nesting" << endl;
}
else{
for(runner = 0; runner < regularExpression.size(); runner++){
firstDelimiter = find(reservedfirstDelimiters.begin(), reservedfirstDelimiters.end(), regularExpression[runner]);
if(*firstDelimiter && regularExpression[runner - 1] != '\\'){ // analyse if the first character is not escaping
if(*firstDelimiter == '['){
firstDelimiterPosition = findIt(regularExpression, '[', keepLastPositionOfSquareBrackets);
keepLastPositionOfSquareBrackets = firstDelimiterPosition;
runnerInside = firstDelimiterPosition;
found = false;
while(true){
secondDelimiter = find(reservedfirstDelimiters.begin(), reservedfirstDelimiters.end(), regularExpression[runnerInside]);
content += regularExpression[runnerInside];
runnerInside++;
if(regularExpression[runnerInside - 1] != '\\' && regularExpression[runnerInside] == '['){ // to avoid delimiter nesting
cout << "Error: Nested " << *firstDelimiter << " opening at position " << firstDelimiterPosition << endl;
found = false;
content = "";
break;
}
if(regularExpression[runnerInside - 1] != '\\' && regularExpression[runnerInside] == ']'){ // if the character is not escaping
found = true;
squareBracketsFlag = true;
content += regularExpression[runnerInside];
break;
}
if(runner != 0 && runnerInside == regularExpression.size() - 1){
found = false;
content = "";
break;
}
}
if(found == true){
secondDelimiterPosition = findIt(regularExpression, ']', keepLastPositionOfSquareBrackets + 1);
cout << "Delimiter " << *firstDelimiter << " opening at position " << firstDelimiterPosition << " and closing at position " << secondDelimiterPosition << endl;
keepLastPositionOfSquareBrackets = secondDelimiterPosition;
firstPair.insert(pair<int, string>(caller, content));
caller++;
secondPair.insert(pair<int, int>(firstDelimiterPosition, secondDelimiterPosition));
allExpressions.push_back(pair< multimap<int, string>, multimap<int, int> >(firstPair, secondPair));
content = "";
firstPair.clear();
secondPair.clear();
}
else if(regularExpression[firstDelimiterPosition - 1] != '\\'){
cout << "Error: Expected closing delimiter for " << *firstDelimiter << " at position " << firstDelimiterPosition << endl;
break;
}
}
else if(*firstDelimiter == '{'){
firstDelimiterPosition = findIt(regularExpression, '{', keepLastPositionOfCurlyBrackets);
keepLastPositionOfCurlyBrackets = firstDelimiterPosition;
runnerInside = firstDelimiterPosition;
found = false;
while(true){
secondDelimiter = find(reservedfirstDelimiters.begin(), reservedfirstDelimiters.end(), regularExpression[runnerInside]);
content += regularExpression[runnerInside];
runnerInside++;
if(regularExpression[runnerInside - 1] != '\\' && regularExpression[runnerInside] == '{'){
cout << "Error: Nested " << *firstDelimiter << " opening at position " << firstDelimiterPosition << endl;
found = false;
content = "";
break;
}
if(regularExpression[runnerInside - 1] != '\\' && regularExpression[runnerInside] == '}'){
found = true;
curlyBracketsFlag = true;
content += regularExpression[runnerInside];
break;
}
if(runner != 0 && runnerInside == regularExpression.size() - 1){
found = false;
content = "";
break;
}
}
if(found == true){
secondDelimiterPosition = findIt(regularExpression, '}', keepLastPositionOfCurlyBrackets + 1);
cout << "Delimiter " << *firstDelimiter << " opening at position " << firstDelimiterPosition << " and closing at position " << secondDelimiterPosition << endl;
keepLastPositionOfCurlyBrackets = secondDelimiterPosition;
firstPair.insert(pair<int, string>(caller, content));
caller++;
secondPair.insert(pair<int, int>(firstDelimiterPosition, secondDelimiterPosition));
allExpressions.push_back(pair< multimap<int, string>, multimap<int, int> >(firstPair, secondPair));
content = "";
firstPair.clear();
secondPair.clear();
}
else if(regularExpression[firstDelimiterPosition - 1] != '\\'){
cout << "Error: Expected closing delimiter for " << *firstDelimiter << " at position " << firstDelimiterPosition << endl;
break;
}
}
else if(*firstDelimiter == '('){
firstDelimiterPosition = findIt(regularExpression, '(', keepLastPositionOfRoundBrackets);
keepLastPositionOfRoundBrackets = firstDelimiterPosition;
runnerInside = firstDelimiterPosition;
found = false;
while(true){
secondDelimiter = find(reservedfirstDelimiters.begin(), reservedfirstDelimiters.end(), regularExpression[runnerInside]);
content += regularExpression[runnerInside];
runnerInside++;
if(regularExpression[runnerInside - 1] != '\\' && regularExpression[runnerInside] == '('){
cout << "Error: Nested " << *firstDelimiter << " opening at position " << firstDelimiterPosition << endl;
found = false;
content = "";
break;
}
if(regularExpression[runnerInside - 1] != '\\' && regularExpression[runnerInside] == ')'){
found = true;
roundBracketsFlag = true;
content += regularExpression[runnerInside];
break;
}
if(runner != 0 && runnerInside == regularExpression.size() - 1){
found = false;
content = "";
break;
}
}
if(found == true){
secondDelimiterPosition = findIt(regularExpression, ')', keepLastPositionOfRoundBrackets + 1);
cout << "Delimiter " << *firstDelimiter << " opening at position " << firstDelimiterPosition << " and closing at position " << secondDelimiterPosition << endl;
keepLastPositionOfRoundBrackets = secondDelimiterPosition;
firstPair.insert(pair<int, string>(caller, content));
caller++;
secondPair.insert(pair<int, int>(firstDelimiterPosition, secondDelimiterPosition));
allExpressions.push_back(pair< multimap<int, string>, multimap<int, int> >(firstPair, secondPair));
content = "";
firstPair.clear();
secondPair.clear();
}
else if(regularExpression[firstDelimiterPosition - 1] != '\\'){
cout << "Error: Expected closing delimiter for " << *firstDelimiter << " at position " << firstDelimiterPosition << endl;
break;
}
}
else if(*firstDelimiter == '<'){
firstDelimiterPosition = findIt(regularExpression, '<', keepLastPositionOfBrackets);
keepLastPositionOfBrackets = firstDelimiterPosition;
runnerInside = firstDelimiterPosition;
found = false;
while(true){
secondDelimiter = find(reservedfirstDelimiters.begin(), reservedfirstDelimiters.end(), regularExpression[runnerInside]);
content += regularExpression[runnerInside];
runnerInside++;
if(regularExpression[runnerInside - 1] != '\\' && regularExpression[runnerInside] == '<'){
cout << "Error: Nested " << *firstDelimiter << " opening at position " << firstDelimiterPosition << endl;
found = false;
content = "";
break;
}
if(regularExpression[runnerInside - 1] != '\\' && regularExpression[runnerInside] == '>'){
found = true;
bracketsFlag = true;
content += regularExpression[runnerInside];
break;
}
if(runner != 0 && runnerInside == regularExpression.size() - 1){
found = false;
content = "";
break;
}
}
if(found == true){
secondDelimiterPosition = findIt(regularExpression, '>', keepLastPositionOfBrackets + 1);
cout << "Delimiter " << *firstDelimiter << " opening at position " << firstDelimiterPosition << " and closing at position " << secondDelimiterPosition << endl;
keepLastPositionOfBrackets = secondDelimiterPosition;
firstPair.insert(pair<int, string>(caller, content));
caller++;
secondPair.insert(pair<int, int>(firstDelimiterPosition, secondDelimiterPosition));
allExpressions.push_back(pair< multimap<int, string>, multimap<int, int> >(firstPair, secondPair));
content = "";
firstPair.clear();
secondPair.clear();
}
else if(regularExpression[firstDelimiterPosition - 1] != '\\'){
cout << "Error: Expected closing delimiter for " << *firstDelimiter << " at position " << firstDelimiterPosition << endl;
break;
}
}
else if(*firstDelimiter == '/'){
bool nestingFlag = false; // to avoid delimiter nesting of pairs of equal delimiters
if(slashFlag == false){ // to avoid to analyse twice when it reaches the closing delimiter
slashFlag = true;
firstDelimiterPosition = findIt(regularExpression, '/', keepLastPositionOfSlash);
keepLastPositionOfSlash = firstDelimiterPosition;
runnerInside = firstDelimiterPosition + 1;
found = false;
if(countOccurrences(regularExpression, '/', 0, regularExpression.size()) % 2 == 1) nestingFlag = true;
content += regularExpression[runnerInside - 1];
while(true){
secondDelimiter = find(reservedfirstDelimiters.begin(), reservedfirstDelimiters.end(), regularExpression[runnerInside]);
content += regularExpression[runnerInside];
runnerInside++;
if(nestingFlag == true){
cout << "Error: Nested " << *firstDelimiter << " opening at position " << firstDelimiterPosition << endl;
found = false;
content = "";
break;
}
if(regularExpression[runnerInside - 1] != '\\' && regularExpression[runnerInside] == '/'){
found = true;
content += regularExpression[runnerInside];
break;
}
if(runner != 0 && runnerInside == regularExpression.size() - 1){
found = false;
content = "";
break;
}
}
if(found == true){
secondDelimiterPosition = findIt(regularExpression, '/', keepLastPositionOfSlash + 1);
cout << "Delimiter " << *firstDelimiter << " opening at position " << firstDelimiterPosition << " and closing at position " << secondDelimiterPosition << endl;
keepLastPositionOfSlash = secondDelimiterPosition;
firstPair.insert(pair<int, string>(caller, content));
caller++;
secondPair.insert(pair<int, int>(firstDelimiterPosition, secondDelimiterPosition));
allExpressions.push_back(pair< multimap<int, string>, multimap<int, int> >(firstPair, secondPair));
content = "";
firstPair.clear();
secondPair.clear();
}
else if(regularExpression[firstDelimiterPosition - 1] != '\\'){
cout << "Error: Expected closing delimiter for " << *firstDelimiter << " at position " << firstDelimiterPosition << endl;
break;
}
}
}
else if(*firstDelimiter == '#'){
if(sharpFlag == false){
sharpFlag = true;
firstDelimiterPosition = findIt(regularExpression, '#', keepLastPositionOfSharp);
keepLastPositionOfSharp = firstDelimiterPosition;
runnerInside = firstDelimiterPosition + 1;
found = false;
content += regularExpression[runnerInside - 1];
while(true){
secondDelimiter = find(reservedfirstDelimiters.begin(), reservedfirstDelimiters.end(), regularExpression[runnerInside]);
content += regularExpression[runnerInside];
runnerInside++;
if(regularExpression[runnerInside - 1] != '\\' && regularExpression[runnerInside] == '#'){
found = true;
content += regularExpression[runnerInside];
break;
}
if(runner != 0 && runnerInside == regularExpression.size() - 1){
found = false;
content = "";
break;
}
}
if(found == true){
secondDelimiterPosition = findIt(regularExpression, '#', keepLastPositionOfSharp + 1);
cout << "Delimiter " << *firstDelimiter << " opening at position " << firstDelimiterPosition << " and closing at position " << secondDelimiterPosition << endl;
keepLastPositionOfSharp = secondDelimiterPosition;
firstPair.insert(pair<int, string>(caller, content));
caller++;
secondPair.insert(pair<int, int>(firstDelimiterPosition, secondDelimiterPosition));
allExpressions.push_back(pair< multimap<int, string>, multimap<int, int> >(firstPair, secondPair));
content = "";
firstPair.clear();
secondPair.clear();
}
}
}
else if(*firstDelimiter == '~'){
if(tildeFlag == false){
tildeFlag = true;
firstDelimiterPosition = findIt(regularExpression, '~', keepLastPositionOfTilde);
keepLastPositionOfTilde = firstDelimiterPosition;
runnerInside = firstDelimiterPosition + 1;
found = false;
content += regularExpression[runnerInside - 1];
while(true){
secondDelimiter = find(reservedfirstDelimiters.begin(), reservedfirstDelimiters.end(), regularExpression[runnerInside]);
content += regularExpression[runnerInside];
runnerInside++;
if(regularExpression[runnerInside - 1] != '\\' && regularExpression[runnerInside] == '~'){
found = true;
content += regularExpression[runnerInside];
break;
}
if(runner != 0 && runnerInside == regularExpression.size() - 1){
found = false;
content = "";
break;
}
}
if(found == true){
secondDelimiterPosition = findIt(regularExpression, '~', keepLastPositionOfTilde + 1);
cout << "Delimiter " << *firstDelimiter << " opening at position " << firstDelimiterPosition << " and closing at position " << secondDelimiterPosition << endl;
keepLastPositionOfTilde = secondDelimiterPosition;
firstPair.insert(pair<int, string>(caller, content));
caller++;
secondPair.insert(pair<int, int>(firstDelimiterPosition, secondDelimiterPosition));
allExpressions.push_back(pair< multimap<int, string>, multimap<int, int> >(firstPair, secondPair));
content = "";
firstPair.clear();
secondPair.clear();
}
}
}
else if(*firstDelimiter == '%'){
if(percentFlag == false){
percentFlag = true;
firstDelimiterPosition = findIt(regularExpression, '%', keepLastPositionOfPercent);
keepLastPositionOfPercent = firstDelimiterPosition;
runnerInside = firstDelimiterPosition + 1;
found = false;
content += regularExpression[runnerInside - 1];
while(true){
secondDelimiter = find(reservedfirstDelimiters.begin(), reservedfirstDelimiters.end(), regularExpression[runnerInside]);
content += regularExpression[runnerInside];
runnerInside++;
if(regularExpression[runnerInside - 1] != '\\' && regularExpression[runnerInside] == '%'){
found = true;
content += regularExpression[runnerInside];
break;
}
if(runner != 0 && runnerInside == regularExpression.size() - 1){
found = false;
content = "";
break;
}
}
if(found == true){
secondDelimiterPosition = findIt(regularExpression, '%', keepLastPositionOfPercent + 1);
cout << "Delimiter " << *firstDelimiter << " opening at position " << firstDelimiterPosition << " and closing at position " << secondDelimiterPosition << endl;
keepLastPositionOfPercent = secondDelimiterPosition;
firstPair.insert(pair<int, string>(caller, content));
caller++;
secondPair.insert(pair<int, int>(firstDelimiterPosition, secondDelimiterPosition));
allExpressions.push_back(pair< multimap<int, string>, multimap<int, int> >(firstPair, secondPair));
content = "";
firstPair.clear();
secondPair.clear();
}
}
}
else if(*firstDelimiter == '@'){
if(atFlag == false){
atFlag = true;
firstDelimiterPosition = findIt(regularExpression, '@', keepLastPositionOfAt);
keepLastPositionOfAt = firstDelimiterPosition;
runnerInside = firstDelimiterPosition + 1;
found = false;
content += regularExpression[runnerInside - 1];
while(true){
secondDelimiter = find(reservedfirstDelimiters.begin(), reservedfirstDelimiters.end(), regularExpression[runnerInside]);
content += regularExpression[runnerInside];
runnerInside++;
if(regularExpression[runnerInside - 1] != '\\' && regularExpression[runnerInside] == '@'){
found = true;
content += regularExpression[runnerInside];
break;
}
if(runner != 0 && runnerInside == regularExpression.size() - 1){
found = false;
content = "";
break;
}
}
if(found == true){
secondDelimiterPosition = findIt(regularExpression, '@', keepLastPositionOfAt + 1);
cout << "Delimiter " << *firstDelimiter << " opening at position " << firstDelimiterPosition << " and closing at position " << secondDelimiterPosition << endl;
keepLastPositionOfAt = secondDelimiterPosition;
firstPair.insert(pair<int, string>(caller, content));
caller++;
secondPair.insert(pair<int, int>(firstDelimiterPosition, secondDelimiterPosition));
allExpressions.push_back(pair< multimap<int, string>, multimap<int, int> >(firstPair, secondPair));
content = "";
firstPair.clear();
secondPair.clear();
}
}
}
else if(*firstDelimiter == '!'){
if(exclamationPointFlag == false){
exclamationPointFlag = true;
firstDelimiterPosition = findIt(regularExpression, '!', keepLastPositionOfExclamationPoint);
keepLastPositionOfExclamationPoint = firstDelimiterPosition;
runnerInside = firstDelimiterPosition + 1;
found = false;
content += regularExpression[runnerInside - 1];
while(true){
secondDelimiter = find(reservedfirstDelimiters.begin(), reservedfirstDelimiters.end(), regularExpression[runnerInside]);
content += regularExpression[runnerInside];
runnerInside++;
if(regularExpression[runnerInside - 1] != '\\' && regularExpression[runnerInside] == '!'){
found = true;
content += regularExpression[runnerInside];
break;
}
if(runner != 0 && runnerInside == regularExpression.size() - 1){
found = false;
content = "";
break;
}
}
if(found == true){
secondDelimiterPosition = findIt(regularExpression, '!', keepLastPositionOfExclamationPoint + 1);
cout << "Delimiter " << *firstDelimiter << " opening at position " << firstDelimiterPosition << " and closing at position " << secondDelimiterPosition << endl;
keepLastPositionOfExclamationPoint = secondDelimiterPosition;
firstPair.insert(pair<int, string>(caller, content));
caller++;
secondPair.insert(pair<int, int>(firstDelimiterPosition, secondDelimiterPosition));
allExpressions.push_back(pair< multimap<int, string>, multimap<int, int> >(firstPair, secondPair));
content = "";
firstPair.clear();
secondPair.clear();
}
}
}
else if(*firstDelimiter == ']' && squareBracketsFlag == false && regularExpression[runner - 1] != '\\'){
firstDelimiterPosition = findIt(regularExpression, ']', keepLastPositionOfSquareBrackets);
keepLastPositionOfSquareBrackets = firstDelimiterPosition;
cout << "Error: Expected opening delimiter for " << *firstDelimiter << " at position " << firstDelimiterPosition << endl;
break;
}
else if(*firstDelimiter == '}' && curlyBracketsFlag == false ){
firstDelimiterPosition = findIt(regularExpression, '}', keepLastPositionOfCurlyBrackets);
keepLastPositionOfCurlyBrackets = firstDelimiterPosition;
cout << "Error: Expected opening delimiter for " << *firstDelimiter << " at position " << firstDelimiterPosition << endl;
break;
}
else if(*firstDelimiter == ')' && roundBracketsFlag == false ){
firstDelimiterPosition = findIt(regularExpression, ')', keepLastPositionOfRoundBrackets);
keepLastPositionOfRoundBrackets = firstDelimiterPosition;
cout << "Error: Expected opening delimiter for " << *firstDelimiter << " at position " << firstDelimiterPosition << endl;
break;
}
else if(*firstDelimiter == '>' && bracketsFlag == false ){
firstDelimiterPosition = findIt(regularExpression, '>', keepLastPositionOfBrackets);
keepLastPositionOfBrackets = firstDelimiterPosition;
cout << "Error: Expected opening delimiter for " << *firstDelimiter << " at position " << firstDelimiterPosition << endl;
break;
}
}
//else{
// O LANCE DE VERIFICAÇÃO DE INTERCALAÇÃO DE DELIMITADORES(ERRO) SERÁ QUANDO FOR INSERIR NO VETOR
// PERMITIR ESCAPAGEM DE QUALQUER CARACTER, INCLUSIVE LETRA E NÚMERO, MAS SÓ TEM VALOR ESPECIAL SE FOR RESERVADO
// AQUI TRATAR O QUE NÃO ESTÁ DENTRO DOS DELIMITADORES
/*
Estou achando o parent da sequência do delimitador pra quando eu for analisar
dentro do delimitador saber onde foi chamado;
*/
//}
}
}
}
}
