void Student2::set_student2() { set_student(); cout << "Degree: "; string degree; cin >> degree; set_degree(degree); cout << "\n"; if (get_semester() != 0) { cout << "Type averages for semesters:\n"; double *average = new double[get_semester()]; for (int i = 0; i < get_semester(); i++) { cout << i + 1 << ". "; cin >> average[i]; } set_average(average); }
/*static*/ WantGkEnd(gk_string *wantend, gk_string *haveend, bool writeflag, int strict) { int compval; word_form wform, hform; /* Dialect wdial = dialect_of(wantend); Dialect hdial = dialect_of(haveend); */ Dialect wdial; Dialect hdial; Dialect d/*, AndDialect()*/; int wmood = mood_of( forminfo_of(wantend) ); int hmood = mood_of( forminfo_of(haveend) ); int wvoice = voice_of( forminfo_of(wantend) ); int hvoice = voice_of( forminfo_of(haveend) ); int wtense = tense_of( forminfo_of(wantend) ); int htense = tense_of( forminfo_of(haveend) ); int wgender = gender_of( forminfo_of(wantend) ); int hgender = gender_of( forminfo_of(haveend) ); int wdegree = degree_of( forminfo_of(wantend) ); int hdegree = degree_of( forminfo_of(haveend) ); int wcase = case_of( forminfo_of(wantend) ); int hcase = case_of( forminfo_of(haveend) ); int wperson = person_of( forminfo_of(wantend) ); int hperson = person_of( forminfo_of(haveend) ); int wnumber = number_of( forminfo_of(wantend) ); int hnumber = number_of( forminfo_of(haveend) ); char wendstr[MAXWORDSIZE]; char * hendstr = gkstring_of(haveend); wform = forminfo_of(wantend); hform = forminfo_of(haveend); /* * basically, we check to see if any particular form has been requested * and check each ending against this. if nothing is asked for (e.g. no * mood or voice is specified) then we just take the ending (i.e. we take * subjunctive, optative, indicative etc. rather than just the optatives or * subjunctives or whatever... */ setwendstr(wendstr,gkstring_of(wantend)); if( wmood && hmood != wmood ) { if( hmood || (!hmood && strict) ) { #ifdef SHOWFAIL printf("failing on wmood %o hmood %o\n", wmood, hmood ); #endif return(0); } } /* * * perfect actives are, by definition, always active in form */ if( (stemtype_of(wantend) & PPARTMASK ) == PP_PF ) { wvoice = ACTIVE; voice_of(wform) = ACTIVE; } if( (stemtype_of(wantend) & PPARTMASK ) == PP_SU && cur_lang() == LATIN && wvoice == DEPONENT ) { set_voice(forminfo_of(haveend), wvoice); } if( cur_lang() == LATIN && wvoice == DEPONENT ) { if( hvoice == ACTIVE && hmood != PARTICIPLE && hmood != GERUNDIVE ) return(0); } else if( wvoice ) { if( ! Want_Voice( wform , hform )) { if( hvoice || (!hvoice && strict)) { #ifdef SHOWFAIL printf("have [%s] failing on wvoice %o hvoice %o\n",hendstr, wvoice, hvoice ); #endif return(0); } } else { /* * note that an ending may generally be either middle or passive, but * if the stem in hand is strictly middle or strictly passive, * then the ending inherits that limitation. */ if( writeflag == YES ) set_voice(forminfo_of(haveend), wvoice); } } if( wtense && htense != wtense ) if( htense || (!htense && strict) ) { #ifdef SHOWFAIL printf("failing on wtense %o htense %o\n", wtense, htense ); #endif return(0); } /* * note that here you only fail if the gender is set in the * ending as well as in the stem. * * if we follow the normal algorithm, a masculine stem would * not match a set of endings that had no gender specified. * * likewise, we need to match either masculine or feminine against * an ending that is common to both (but not, for example, to a neuter * stem, e.g. -es in nom pl for masc and fem, but -a for neuter) */ /* /* * only fail if gender set for both. * e.g., dwr- from dw=ron will want to find * endings such as -on, or -a that are specifically flagged * as neuter, but will also want to find other endings * that can attach themselves to any gender */ if( wgender ) { if( hgender ) { if( ! Want_Gender(wform, hform)) { #ifdef SHOWFAIL printf("failing with hgender %o and wgender %o\n", hgender , wgender ); #endif return(0); } } if( writeflag ) if( Want_Gender(wform,hform) ) set_gender(forminfo_of(haveend), Want_Gender(wform, hform)); else set_gender(forminfo_of(haveend), wgender ); } if( wcase ) { if( ! Want_Case(wform, hform)) if( hcase || (!hcase && strict) ) { #ifdef SHOWFAIL printf("failing with hcase %o wcase %o\n", hcase , wcase ); #endif return(0); } if( writeflag ) { #ifdef SHOWFAIL printf("[%s] hcase %o wcase %o anded %o\n", gkstring_of(haveend), hcase, wcase, hcase & wcase ); #endif set_case(forminfo_of(haveend) , wcase&hcase ); } } if( wperson && hperson != wperson ) { if( hperson || (!hperson && strict) ) { #ifdef SHOWFAIL printf("failing with hperson %o wperson %o\n", hperson , wperson ); #endif return(0); } } if( wnumber && hnumber != wnumber ) if( hnumber || (!hnumber && strict) ) { #ifdef SHOWFAIL printf("failing on wnumber %o hnumber %o\n", wnumber , hnumber ); #endif return(0); } if( *wendstr && strict ) { if( (compval=endstrcmp(wendstr,hendstr))){ /* * this expects that you have a sorted list of endings and that you * don't want to look for endings that are alphabetically larger * than the ending that you want */ if( compval < 0 && noaccstrcmp(wendstr,hendstr) ) { #ifdef SHOWFAIL #endif return(compval); } #ifdef SHOWFAIL printf("failing on wendsrr\n"); #endif /* * don't fail if you did not specifically ask for a long vowel. * * do fail if you specifically ask for a long vowel and this ending is not * marked as long. */ if( has_quantacc(hendstr) != has_quantacc(wendstr) ) { char tmp[MAXWORDSIZE]; Xstrncpy(tmp,hendstr,MAXWORDSIZE); stripquantacc(tmp); compval=endstrcmp(wendstr,tmp); /* compval=dictstrcmp(wendstr,tmp); */ if( compval ) return(0); } else return(0); } else { /* * if you ask for "w=", then match only "w=" and not "w". * * if you ask for "w", however, then match both "w=" and "w". */ if( hasaccent(wendstr) ) { char tmp1[MAXWORDSIZE]; char tmp2[MAXWORDSIZE]; Xstrncpy(tmp1,wendstr,(int)sizeof tmp1); stripquant(tmp1); Xstrncpy(tmp2,hendstr,(int)sizeof tmp2); stripquant(tmp2); if( strcmp(tmp1,tmp2) ) return(0); } } } if( ! EuphEnd(wantend,haveend,strict) ) { #ifdef SHOWFAIL printf("[%s] failing on euph end\n", gkstring_of(haveend) ); #endif return(0); } wdial = dialect_of(wantend); hdial = dialect_of(haveend); /* * note that we are checking not for equality, but to see if * we want any of the dialect bits set for the current ending */ if( (d=AndDialect(hdial,wdial)) < 0 ) return(0); /* else if( writeflag ) { set_dialect(haveend,d); } */ /* * we currently mark a)/ristos as "os_h_on superl". * we thus want a)rist- to have all the normal endings (-os,-h,-on,-ou,-hs,-ou) * but not to have endings such as "-o/tatos" or "-w/teros" tacked onto it. */ /* * grc 6/5/89 * * this system prevents morphology formulas from generating any actual endings. the * formula has the flag "comp" or "superl", but none of the endings in the basic * paradigms are so marked, so they are all skipped. i added the requirement that this * rule only be active if strict is non zero to get around this (this is much the same * strategy that we took with iteratives. */ if( wdegree ) { if( hdegree && wdegree != hdegree /* grc 6/5/89 */ && strict /* end mod*/) { if( hdegree || (!hdegree && strict) ) return(0); } if( wdegree && writeflag ) set_degree(forminfo_of(haveend),wdegree); } if( ! RightMorphflags(wantend,haveend)) { #ifdef SHOWFAIL printf("[%s] failing on rightmorphflags\n", gkstring_of(haveend) ); #endif return(0); } return(1); }