- Edinburgh Speech Tools Library (used by the Festival Speech Synthesis System).
| EST_relation_aux.cc (speech_tools-2.4-release) | : | EST_relation_aux.cc (speech_tools-2.5.0-release) |
|---|
| | |
| skipping to change at line 60 | | skipping to change at line 60 |
|---|
| | |
| static int is_in_class(const EST_String &name, EST_StrList &s); | | static int is_in_class(const EST_String &name, EST_StrList &s); |
| | |
| bool dp_match(const EST_Relation &lexical, | | bool dp_match(const EST_Relation &lexical, |
| const EST_Relation &surface, | | const EST_Relation &surface, |
| EST_Relation &match, | | EST_Relation &match, |
| float ins, float del, float sub); | | float ins, float del, float sub); |
| | |
| float start(EST_Item *n) | | float start(EST_Item *n) |
| { | | { |
|
| return (n->prev() == 0) ? 0.0 : n->prev()->F("end"); | | return (iprev(n) == 0) ? 0.0 : iprev(n)->F("end"); |
| } | | } |
| | |
| float duration(EST_Item *n) | | float duration(EST_Item *n) |
| { | | { |
| return n->F("end") - start(n); | | return n->F("end") - start(n); |
| } | | } |
| | |
| void quantize(EST_Relation &a, float q) | | void quantize(EST_Relation &a, float q) |
| { | | { |
| EST_Item *a_ptr; | | EST_Item *a_ptr; |
| float end; | | float end; |
| | |
|
| for (a_ptr = a.head(); a_ptr != 0; a_ptr = a_ptr->next()) | | for (a_ptr = a.head(); a_ptr != 0; a_ptr = inext(a_ptr)) |
| { | | { |
| end = a_ptr->F("end") / q; | | end = a_ptr->F("end") / q; |
| end = rint(end); | | end = rint(end); |
| end = end * q; | | end = end * q; |
| a_ptr->set("end", end); | | a_ptr->set("end", end); |
| } | | } |
| } | | } |
| | |
| // edit labels using a sed file to do the editing | | // edit labels using a sed file to do the editing |
| | |
| | |
| skipping to change at line 101 | | skipping to change at line 101 |
|---|
| file1 = make_tmp_filename(); | | file1 = make_tmp_filename(); |
| file2 = make_tmp_filename(); | | file2 = make_tmp_filename(); |
| | |
| fp = fopen(file1, "wb"); | | fp = fopen(file1, "wb"); |
| if (fp == NULL) | | if (fp == NULL) |
| { | | { |
| fprintf(stderr,"edit_labels: cannot open \"%s\" for writing\n", | | fprintf(stderr,"edit_labels: cannot open \"%s\" for writing\n", |
| (const char *)file1); | | (const char *)file1); |
| return -1; | | return -1; |
| } | | } |
|
| for (a_ptr = a.head(); a_ptr != 0; a_ptr = a_ptr->next()) | | for (a_ptr = a.head(); a_ptr != 0; a_ptr = inext(a_ptr)) |
| { | | { |
| strcpy(name, a_ptr->name()); | | strcpy(name, a_ptr->name()); |
| fprintf(fp, "%s\n", name); | | fprintf(fp, "%s\n", name); |
| } | | } |
| fclose(fp); | | fclose(fp); |
| strcpy(command, "cat "); | | strcpy(command, "cat "); |
| strcat(command, file1); | | strcat(command, file1); |
| strcat(command, " | sed -f "); | | strcat(command, " | sed -f "); |
| strcat(command, sedfile); | | strcat(command, sedfile); |
| strcat(command, " > "); | | strcat(command, " > "); |
| | |
| skipping to change at line 124 | | skipping to change at line 124 |
|---|
| printf("command: %s\n", command); | | printf("command: %s\n", command); |
| system(command); | | system(command); |
| | |
| fp = fopen(file2, "rb"); | | fp = fopen(file2, "rb"); |
| if (fp == NULL) | | if (fp == NULL) |
| { | | { |
| fprintf(stderr,"edit_labels: cannot open \"%s\" for reading\n", | | fprintf(stderr,"edit_labels: cannot open \"%s\" for reading\n", |
| (const char *)file2); | | (const char *)file2); |
| return -1; | | return -1; |
| } | | } |
|
| for (a_ptr = a.head(); a_ptr != 0; a_ptr = a_ptr->next()) | | for (a_ptr = a.head(); a_ptr != 0; a_ptr = inext(a_ptr)) |
| { | | { |
| fscanf(fp, "%s", newname); | | fscanf(fp, "%s", newname); |
| // cout << "oldname: " << a_ptr->name() << " newname: " << newname << endl; | | // cout << "oldname: " << a_ptr->name() << " newname: " << newname << endl; |
| a_ptr->set_name(newname); | | a_ptr->set_name(newname); |
| } | | } |
| fclose(fp); | | fclose(fp); |
| return 0; | | return 0; |
| } | | } |
| | |
| // make new EST_Relation from start and end points. | | // make new EST_Relation from start and end points. |
| void extract(const EST_Relation &orig, float s, | | void extract(const EST_Relation &orig, float s, |
| float e, EST_Relation &ex) | | float e, EST_Relation &ex) |
| { | | { |
| EST_Item *a; | | EST_Item *a; |
| EST_Item *tmp; | | EST_Item *tmp; |
| | |
|
| for (a = orig.head(); a != 0; a = a->next()) | | for (a = orig.head(); a != 0; a = inext(a)) |
| if ((a->F("end") > s) && (start(a) < e)) | | if ((a->F("end") > s) && (start(a) < e)) |
| { | | { |
| tmp = ex.append(a); | | tmp = ex.append(a); |
| if ((a->F("end") > e)) | | if ((a->F("end") > e)) |
| tmp->set("end", e); | | tmp->set("end", e); |
| } | | } |
| } | | } |
| | |
| void merge_all_label(EST_Relation &seg, const EST_String &labtype) | | void merge_all_label(EST_Relation &seg, const EST_String &labtype) |
| { | | { |
| EST_Item *a_ptr, *n_ptr; | | EST_Item *a_ptr, *n_ptr; |
| (void)labtype; // unused parameter | | (void)labtype; // unused parameter |
| | |
| for (a_ptr = seg.head(); a_ptr != seg.tail(); a_ptr = n_ptr) | | for (a_ptr = seg.head(); a_ptr != seg.tail(); a_ptr = n_ptr) |
| { | | { |
|
| n_ptr = a_ptr->next(); | | n_ptr = inext(a_ptr); |
| if (a_ptr->name() == a_ptr->next()->name()) | | if (a_ptr->name() == inext(a_ptr)->name()) |
| seg.remove_item(a_ptr); | | seg.remove_item(a_ptr); |
| } | | } |
| } | | } |
| | |
| void change_label(EST_Relation &seg, const EST_String &oname, | | void change_label(EST_Relation &seg, const EST_String &oname, |
| const EST_String &nname) | | const EST_String &nname) |
| { | | { |
| EST_Item *a_ptr; | | EST_Item *a_ptr; |
| | |
|
| for (a_ptr = seg.head(); a_ptr != 0; a_ptr = a_ptr->next()) | | for (a_ptr = seg.head(); a_ptr != 0; a_ptr = inext(a_ptr)) |
| if (a_ptr->name() == oname) | | if (a_ptr->name() == oname) |
| a_ptr->set_name(nname); | | a_ptr->set_name(nname); |
| } | | } |
| | |
| void change_label(EST_Relation &seg, const EST_StrList &oname, | | void change_label(EST_Relation &seg, const EST_StrList &oname, |
| const EST_String &nname) | | const EST_String &nname) |
| { | | { |
| EST_Item *a_ptr; | | EST_Item *a_ptr; |
| EST_Litem *p; | | EST_Litem *p; |
| | |
|
| for (a_ptr = seg.head(); a_ptr != 0; a_ptr = a_ptr->next()) | | for (a_ptr = seg.head(); a_ptr != 0; a_ptr = inext(a_ptr)) |
| for (p = oname.head(); p ; p = p->next()) | | for (p = oname.head(); p ; p = p->next()) |
| if (a_ptr->name() == oname(p)) | | if (a_ptr->name() == oname(p)) |
| a_ptr->set_name(nname); | | a_ptr->set_name(nname); |
| } | | } |
| | |
| static int is_in_class(const EST_String &name, EST_StrList &s) | | static int is_in_class(const EST_String &name, EST_StrList &s) |
| { | | { |
| EST_Litem *p; | | EST_Litem *p; |
| | |
| for (p = s.head(); p; p = p->next()) | | for (p = s.head(); p; p = p->next()) |
| if (name == s(p)) | | if (name == s(p)) |
| return TRUE; | | return TRUE; |
| | |
| return FALSE; | | return FALSE; |
| } | | } |
| | |
| int check_vocab(EST_Relation &a, EST_StrList &vocab) | | int check_vocab(EST_Relation &a, EST_StrList &vocab) |
| { | | { |
| EST_Item *s; | | EST_Item *s; |
|
| for (s = a.head(); s; s = s->next()) | | for (s = a.head(); s; s = inext(s)) |
| if (!is_in_class(s->name(), vocab)) | | if (!is_in_class(s->name(), vocab)) |
| { | | { |
| cerr<<"Illegal entry in file " <<a.name()<< ":\"" << *s << "\"\n"; | | cerr<<"Illegal entry in file " <<a.name()<< ":\"" << *s << "\"\n"; |
| return -1; | | return -1; |
| } | | } |
| return 0; | | return 0; |
| } | | } |
| | |
| void convert_to_broad_class(EST_Relation &seg, const EST_String &class_type, | | void convert_to_broad_class(EST_Relation &seg, const EST_String &class_type, |
| EST_Option &options) | | EST_Option &options) |
| | |
| skipping to change at line 233 | | skipping to change at line 233 |
|---|
| convert_to_broad(seg, pos_list); | | convert_to_broad(seg, pos_list); |
| } | | } |
| | |
| void convert_to_broad(EST_Relation &seg, EST_StrList &pos_list, | | void convert_to_broad(EST_Relation &seg, EST_StrList &pos_list, |
| EST_String broad_name, int polarity) | | EST_String broad_name, int polarity) |
| { | | { |
| EST_Item *a_ptr; | | EST_Item *a_ptr; |
| if (broad_name == "") | | if (broad_name == "") |
| broad_name = "pos"; | | broad_name = "pos"; |
| | |
|
| for (a_ptr = seg.head(); a_ptr != 0; a_ptr = a_ptr->next()) | | for (a_ptr = seg.head(); a_ptr != 0; a_ptr = inext(a_ptr)) |
| if (is_in_class(a_ptr->name(), pos_list)) | | if (is_in_class(a_ptr->name(), pos_list)) |
| a_ptr->set(broad_name, (polarity) ? 1 : 0); | | a_ptr->set(broad_name, (polarity) ? 1 : 0); |
| else | | else |
| a_ptr->set(broad_name, (polarity) ? 0 : 1); | | a_ptr->set(broad_name, (polarity) ? 0 : 1); |
| } | | } |
| | |
| void label_map(EST_Relation &seg, EST_Option &map) | | void label_map(EST_Relation &seg, EST_Option &map) |
| { | | { |
|
| EST_Item *p, *n; | | EST_Item *p; |
| | |
|
| for (p = seg.head(); p != 0; n = p) | | for (p = seg.head(); p != 0; p = inext(p)) |
| { | | { |
|
| n = p->next(); | | |
| if (map.present(p->name())) | | if (map.present(p->name())) |
| { | | { |
| if (map.val(p->name()) == "!DELETE") | | if (map.val(p->name()) == "!DELETE") |
| seg.remove_item(p); | | seg.remove_item(p); |
| else | | else |
| p->set_name(map.val(p->name())); | | p->set_name(map.val(p->name())); |
| } | | } |
| | |
| } | | } |
| } | | } |
| | |
| void shift_label(EST_Relation &seg, float shift) | | void shift_label(EST_Relation &seg, float shift) |
| { | | { |
| //shift every end time by adding x seconds. | | //shift every end time by adding x seconds. |
| EST_Item *a_ptr; | | EST_Item *a_ptr; |
| | |
|
| for (a_ptr = seg.head(); a_ptr != 0; a_ptr = a_ptr->next()) | | for (a_ptr = seg.head(); a_ptr != 0; a_ptr = inext(a_ptr)) |
| a_ptr->set("end", a_ptr->F("end") + shift); | | a_ptr->set("end", a_ptr->F("end") + shift); |
| } | | } |
| | |
| void RelationList_select(EST_RelationList &mlf, EST_StrList filenames, bool | | void RelationList_select(EST_RelationList &mlf, EST_StrList filenames, bool |
| exact_match) | | exact_match) |
| { | | { |
| // select only files in 'filenames' | | // select only files in 'filenames' |
| // remove all others from mlf | | // remove all others from mlf |
| EST_Litem *fptr, *ptr; | | EST_Litem *fptr, *ptr; |
| bool flag; | | bool flag; |
| | |
| skipping to change at line 352 | | skipping to change at line 351 |
|---|
| // combine all relation in MLF into a single relation. | | // combine all relation in MLF into a single relation. |
| EST_Relation RelationList_combine(EST_RelationList &mlf) | | EST_Relation RelationList_combine(EST_RelationList &mlf) |
| { | | { |
| EST_Litem *p; | | EST_Litem *p; |
| EST_Relation all; | | EST_Relation all; |
| EST_Item *s, *t = 0; | | EST_Item *s, *t = 0; |
| float last = 0.0; | | float last = 0.0; |
| | |
| for (p = mlf.head(); p; p = p->next()) | | for (p = mlf.head(); p; p = p->next()) |
| { | | { |
|
| for (s = mlf(p).head(); s; s = s->next()) | | for (s = mlf(p).head(); s; s = inext(s)) |
| { | | { |
| t = all.append(); | | t = all.append(); |
| t->set("name", s->S("name")); | | t->set("name", s->S("name")); |
| t->set("end", s->F("end") + last); | | t->set("end", s->F("end") + last); |
| cout << "appended t " << t << endl; | | cout << "appended t " << t << endl; |
| } | | } |
| last = (t != 0) ? t->F("end") : 0.0; | | last = (t != 0) ? t->F("end") : 0.0; |
| } | | } |
| return all; | | return all; |
| } | | } |
| | |
| skipping to change at line 378 | | skipping to change at line 377 |
|---|
| EST_Item *s, *t = 0, *k; | | EST_Item *s, *t = 0, *k; |
| float st; | | float st; |
| | |
| if (key.length() != mlf.length()) | | if (key.length() != mlf.length()) |
| { | | { |
| cerr << "RelationList has " << mlf.length() << " elements: expected " | | cerr << "RelationList has " << mlf.length() << " elements: expected " |
| << key.length() << " from key file\n"; | | << key.length() << " from key file\n"; |
| return all; | | return all; |
| } | | } |
| | |
|
| for (k = key.head(), p = mlf.head(); p; p = p->next(), k = k->next()) | | for (k = key.head(), p = mlf.head(); p; p = p->next(), k = inext(k)) |
| { | | { |
| st = start(k); | | st = start(k); |
|
| for (s = mlf(p).head(); s; s = s->next()) | | for (s = mlf(p).head(); s; s = inext(s)) |
| { | | { |
| t = all.append(); | | t = all.append(); |
| t->set("name", s->S("name")); | | t->set("name", s->S("name")); |
| t->set("end", (s->F("end") + st)); | | t->set("end", (s->F("end") + st)); |
| } | | } |
| } | | } |
| return all; | | return all; |
| } | | } |
| | |
| int relation_divide(EST_RelationList &slist, EST_Relation &lab, | | int relation_divide(EST_RelationList &slist, EST_Relation &lab, |
| | |
| skipping to change at line 414 | | skipping to change at line 413 |
|---|
| | |
| slist.clear(); | | slist.clear(); |
| | |
| if ((keylab.tail())->F("end") < (lab.tail())->F("end")) | | if ((keylab.tail())->F("end") < (lab.tail())->F("end")) |
| { | | { |
| cerr << "Key file must extend beyond end of label file\n"; | | cerr << "Key file must extend beyond end of label file\n"; |
| return -1; | | return -1; |
| } | | } |
| | |
| // find a the first keylab that will make a non-empty file | | // find a the first keylab that will make a non-empty file |
|
| for (k = keylab.head(); k ; k = k->next()) | | for (k = keylab.head(); k ; k = inext(k)) |
| if (k->F("end") > lab.head()->F("end")) | | if (k->F("end") > lab.head()->F("end")) |
| break; | | break; |
| | |
| filename = (EST_String)k->f("file"); | | filename = (EST_String)k->f("file"); |
| a.f.set("name", (filename + ext)); | | a.f.set("name", (filename + ext)); |
| kstart = 0.0; | | kstart = 0.0; |
| | |
|
| for (s = lab.head(); s; s = s->next()) | | for (s = lab.head(); s; s = inext(s)) |
| { | | { |
|
| n = s->next(); | | n = inext(s); |
| if (n == 0) | | if (n == 0) |
| { | | { |
| t = a.append(s); | | t = a.append(s); |
| t->set("end", (s->F("end") - kstart)); | | t->set("end", (s->F("end") - kstart)); |
| break; | | break; |
| } | | } |
| if (n->F("end") > k->F("end")) | | if (n->F("end") > k->F("end")) |
| { | | { |
| if (((n->F("end") - k->F("end")) < | | if (((n->F("end") - k->F("end")) < |
| (k->F("end") - start(n))) || | | (k->F("end") - start(n))) || |
| is_in_class(n->name(), blank)) | | is_in_class(n->name(), blank)) |
| { | | { |
| a.append(s); | | a.append(s); |
| t->set("end", (s->F("end") - kstart)); | | t->set("end", (s->F("end") - kstart)); |
| | |
| t = a.append(n); | | t = a.append(n); |
| t->set("end", (k->F("end") - kstart)); | | t->set("end", (k->F("end") - kstart)); |
| | |
| if (!is_in_class(n->name(), blank)) | | if (!is_in_class(n->name(), blank)) |
|
| s = s->next(); | | s = inext(s); |
| } | | } |
| else | | else |
| { | | { |
| t = a.append(s); | | t = a.append(s); |
| t->set("end", (k->F("end") - kstart)); | | t->set("end", (k->F("end") - kstart)); |
| } | | } |
| | |
| slist.append(a); | | slist.append(a); |
|
| k = k->next(); | | k = inext(k); |
| kstart = start(k); | | kstart = start(k); |
| a.clear(); | | a.clear(); |
| filename = (EST_String)k->f("file"); | | filename = (EST_String)k->f("file"); |
| a.f.set("name", (filename + ext)); | | a.f.set("name", (filename + ext)); |
| } | | } |
| else | | else |
| { | | { |
| t = a.append(s); | | t = a.append(s); |
| t->set("end", (s->F("end") - kstart)); | | t->set("end", (s->F("end") - kstart)); |
| } | | } |
| | |
| skipping to change at line 489 | | skipping to change at line 488 |
|---|
| if ((keylab.tail())->F("end") < (lab.tail())->F("end")) | | if ((keylab.tail())->F("end") < (lab.tail())->F("end")) |
| { | | { |
| cerr << "Key file must extend beyond end of label file\n"; | | cerr << "Key file must extend beyond end of label file\n"; |
| return -1; | | return -1; |
| } | | } |
| | |
| k = keylab.head(); | | k = keylab.head(); |
| a.f.set("name", (k->name() + ext)); | | a.f.set("name", (k->name() + ext)); |
| kstart = 0.0; | | kstart = 0.0; |
| | |
|
| for (s = lab.head(); s; s = s->next()) | | for (s = lab.head(); s; s = inext(s)) |
| { | | { |
| t = a.append(); | | t = a.append(); |
| t->set_name(s->name()); | | t->set_name(s->name()); |
| t->set("end", (s->F("end") - kstart)); | | t->set("end", (s->F("end") - kstart)); |
| | |
| if (s->F("end") > k->F("end")) | | if (s->F("end") > k->F("end")) |
| { | | { |
| cout << "appending " << a; | | cout << "appending " << a; |
| mlf.append(a); | | mlf.append(a); |
| | |
| kstart = s->F("end"); | | kstart = s->F("end"); |
| k->set("end", (s->F("end"))); | | k->set("end", (s->F("end"))); |
|
| k = k->next(); | | k = inext(k); |
| a.clear(); | | a.clear(); |
| a.f.set("name", (k->name() + ext)); | | a.f.set("name", (k->name() + ext)); |
| } | | } |
| } | | } |
| cout << "appending " << a; | | cout << "appending " << a; |
| mlf.append(a); | | mlf.append(a); |
| | |
| return 0; | | return 0; |
| } | | } |
| | |
| | |
| skipping to change at line 530 | | skipping to change at line 529 |
|---|
| // first pass, copy times as appropriate, and find first | | // first pass, copy times as appropriate, and find first |
| // and last defined ends | | // and last defined ends |
| // This is hacky and certainly won't work for many cases | | // This is hacky and certainly won't work for many cases |
| | |
| first_end = -1.0; | | first_end = -1.0; |
| prev_end = 0.0; | | prev_end = 0.0; |
| last_end = 0.0; | | last_end = 0.0; |
| | |
| // cout << "surface: " << surface << endl; | | // cout << "surface: " << surface << endl; |
| | |
|
| for (s = target.head(); s; s = s->next()) | | for (s = target.head(); s; s = inext(s)) |
| { | | { |
| if ((t = daughter1(s->as_relation(match_name))) != 0) | | if ((t = daughter1(s->as_relation(match_name))) != 0) |
| { | | { |
| s->set(time_name + "end", t->F("end")); | | s->set(time_name + "end", t->F("end")); |
| if (do_start) | | if (do_start) |
| s->set(time_name + "start", t->F("start")); | | s->set(time_name + "start", t->F("start")); |
| | |
| last_end = t->F("end"); | | last_end = t->F("end"); |
| if (first_end < 0.0) | | if (first_end < 0.0) |
| first_end = t->F("end"); | | first_end = t->F("end"); |
| | |
| skipping to change at line 558 | | skipping to change at line 557 |
|---|
| target.head()->set(time_name + "start", 0.0); | | target.head()->set(time_name + "start", 0.0); |
| } | | } |
| | |
| if (!target.tail()->f_present(time_name + "end")) | | if (!target.tail()->f_present(time_name + "end")) |
| { | | { |
| target.tail()->set(time_name + "end", last_end + 0.01); | | target.tail()->set(time_name + "end", last_end + 0.01); |
| if (do_start) | | if (do_start) |
| target.tail()->set(time_name + "start", last_end); | | target.tail()->set(time_name + "start", last_end); |
| } | | } |
| | |
|
| for (s = target.head(); s; s = s->next()) | | for (s = target.head(); s; s = inext(s)) |
| { | | { |
| if (!s->f_present(time_name + "end")) | | if (!s->f_present(time_name + "end")) |
| { | | { |
| // cout << "missing end feature for " << *s << endl; | | // cout << "missing end feature for " << *s << endl; |
|
| for (i = 1, p = s; p; p = p->next(), ++i) | | for (i = 1, p = s; p; p = inext(p), ++i) |
| if (p->f_present(time_name + "end")) | | if (p->f_present(time_name + "end")) |
| break; | | break; |
| inc = (p->F(time_name + "end") - prev_end) / ((float) i); | | inc = (p->F(time_name + "end") - prev_end) / ((float) i); |
| // cout << "inc is : " << inc << endl; | | // cout << "inc is : " << inc << endl; |
| | |
| // cout << "stop phone is " << *p << endl; | | // cout << "stop phone is " << *p << endl; |
| | |
|
| for (i = 1; s !=p ; s = s->next(), ++i) | | for (i = 1; s !=p ; s = inext(s), ++i) |
| { | | { |
| s->set(time_name + "end", (prev_end + ((float) i * inc))); | | s->set(time_name + "end", (prev_end + ((float) i * inc))); |
| if (do_start) | | if (do_start) |
| s->set(time_name + "start", (prev_end+((float) (i - 1 )* inc))); | | s->set(time_name + "start", (prev_end+((float) (i - 1 )* inc))); |
| } | | } |
| } | | } |
| prev_end = s->F("end"); | | prev_end = s->F("end"); |
| } | | } |
| } | | } |
| | |
| | |
| skipping to change at line 662 | | skipping to change at line 661 |
|---|
| return; | | return; |
| label_map(lab, map); | | label_map(lab, map); |
| } | | } |
| } | | } |
| | |
| void print_relation_features(EST_Relation &stream) | | void print_relation_features(EST_Relation &stream) |
| { | | { |
| EST_Item *s; | | EST_Item *s; |
| EST_Features::Entries p; | | EST_Features::Entries p; |
| | |
|
| for (s = stream.head(); s; s = s->next()) | | for (s = stream.head(); s; s = inext(s)) |
| { | | { |
| cout << s->name() << "\t:"; | | cout << s->name() << "\t:"; |
| for(p.begin(s->features()); p; ++p) | | for(p.begin(s->features()); p; ++p) |
| cout << p->k << " " | | cout << p->k << " " |
| << p->v << "; "; | | << p->v << "; "; |
| cout << endl; | | cout << endl; |
| } | | } |
| | |
| } | | } |
| | |
| void build_RelationList_hash_table(EST_RelationList &mlf, | | void build_RelationList_hash_table(EST_RelationList &mlf, |
| EST_hashedRelationList &hash_table, | | EST_hashedRelationList &hash_table, |
| const bool base) | | const bool base) |
| { | | { |
| EST_Litem *p; | | EST_Litem *p; |
| if (base) | | if (base) |
|
| for (p = mlf.head(); p; p = p->next()) | | for (p = mlf.head(); p; p = p->next()) |
| hash_table.add_item(basename(mlf(p).name(), "*"), | | hash_table.add_item(basename(mlf(p).name(), "*"), |
| &(mlf(p))); | | &(mlf(p))); |
| else | | else |
|
| for (p = mlf.head(); p; p = p->next()) | | for (p = mlf.head(); p; p = p->next()) |
| hash_table.add_item(mlf(p).name(), | | hash_table.add_item(mlf(p).name(), |
| &(mlf(p))); | | &(mlf(p))); |
| } | | } |
| | |
| bool hashed_RelationList_extract(EST_Relation* &rel, | | bool hashed_RelationList_extract(EST_Relation* &rel, |
| const EST_hashedRelationList &hash_table, | | const EST_hashedRelationList &hash_table, |
| const EST_String &filename, bool base) | | const EST_String &filename, bool base) |
| { | | { |
| EST_Relation *d; | | EST_Relation *d; |
| EST_String fname = filename; | | EST_String fname = filename; |
| | | |
| End of changes. 31 change blocks. |
|---|
| 32 lines changed or deleted | | 31 lines changed or added |
|---|
"Fossies" - the Fresh Open Source Software Archive 