| #define adjazent | ( | a, | |
| b | |||
| ) |
matrix [ (a) * anzahl_toene * sizeof (char) \ + (b) * sizeof (char)]
Definiert in Zeile 2244 der Datei Parser.cpp.
Wird benutzt von berechne_toene_absolut() und test_zyklen().
| #define AKTIONEN_MAX 100 |
Definiert in Zeile 90 der Datei GrafKern.cpp.
Wird benutzt von AktionenMessage().
| #define bcopy | ( | from, | |
| to, | |||
| n | |||
| ) | memcpy((to),(from),(n)) |
Definiert in Zeile 48 der Datei Global.h.
Wird benutzt von protokoll_liegende_frequenzen() und yyparse().
| #define C_STR | ( | x | ) | (x) |
Definiert in Zeile 155 der Datei Defs.h.
Wird benutzt von InGis::Open().
| #define DOUBLE_TO_LONG | ( | x | ) | ((long int) ((x) * (1L<<24))) |
Definiert in Zeile 47 der Datei Interpre.h.
Wird benutzt von expand_tonliste(), expandiere_tonsystem() und expandiere_umstimmung().
| #define FAKTOR_TO_MIDI | ( | x | ) | (17.31234049066756089 * log(x)) |
Definiert in Zeile 60 der Datei Global.h.
Wird benutzt von expand_tonliste(), expandiere_tonsystem() und expandiere_umstimmung().
| #define FLUSH_UPDATE_UI FlushUpdateUI() |
Definiert in Zeile 64 der Datei Execute.h.
Wird benutzt von InMidiPort::Proceed() und InMidiFile::Proceed().
| #define FREQUENZ_TO_MIDI | ( | x | ) | (log((x)/440.0)/0.05776226504666210908 + 69) |
Definiert in Zeile 57 der Datei Global.h.
Wird benutzt von expand_tonliste() und expandiere_tonsystem().
| #define HEAP_PORTION_SYNTAX /*65536L*/ 64000 |
Definiert in Zeile 33 der Datei Hilfs.h.
Wird benutzt von xmalloc() und xrealloc().
| #define KEY_CHANGED | ( | box | ) | { keys_changed[box]=1; keys_changed_sum = 1; } |
Definiert in Zeile 57 der Datei Execute.cpp.
Wird benutzt von AddKey(), DeleteKey() und execute_aktion().
| #define LAUFZEIT_ERROR0 | ( | format, | |
| a | |||
| ) | strcpy(Fmeldung, format) |
Definiert in Zeile 127 der Datei GrafKern.h.
Wird benutzt von InMidiPort::Open() und OutMidiPort::Open().
| #define LAUFZEIT_ERROR1 | ( | format, | |
| a | |||
| ) | sprintf(Fmeldung, format, a) |
Definiert in Zeile 128 der Datei GrafKern.h.
Wird benutzt von InMidiFile::Open().
| #define LAUFZEIT_ERROR2 | ( | format, | |
| a, | |||
| b | |||
| ) | sprintf(Fmeldung, format, a, b) |
Definiert in Zeile 129 der Datei GrafKern.h.
Wird benutzt von InMidiPort::Open() und OutMidiPort::Open().
| #define LINE_DRAW_QUANTUM 17 |
| #define MAX_BOX 256 |
Definiert in Zeile 63 der Datei Global.h.
Wird benutzt von AktionTraceReset(), BoxColor(), CheckBoxesUsed(), MutFrame::CmDoActivate(), MutRouteWnd::createBoxes(), expandiere_in_globale_liste(), FlushUpdateUI(), get_cache_konstante(), GlobalReset(), initBoxColors(), mutabor_tabellen_generator(), MutResetKeys(), OutMidiPort::NoteOff(), Panic(), MutFrame::RaiseLogic(), MutApp::RestoreState(), MutApp::SaveState(), SmallestBoxUsed() und MutFrame::UpdateBoxMenu().
| #define MAX_BREITE 72 |
Definiert in Zeile 52 der Datei Global.h.
Wird benutzt von change_breite(), expand_pattern() und MutResetKeys().
| #define MIDI_MAX_CHANNEL 15 |
Definiert in Zeile 206 der Datei Defs.h.
Wird benutzt von MutInputMidiDeviceShape::GetInputFilterPanel().
| #define MIDI_MAX_KEY 0x7f |
Definiert in Zeile 208 der Datei Defs.h.
Wird benutzt von MutInputMidiDeviceShape::GetInputFilterPanel().
| #define MIDI_MIN_CHANNEL 0 |
Definiert in Zeile 205 der Datei Defs.h.
Wird benutzt von MutInputMidiDeviceShape::GetInputFilterPanel().
| #define MIDI_MIN_KEY 0 |
Definiert in Zeile 207 der Datei Defs.h.
Wird benutzt von MutInputMidiDeviceShape::GetInputFilterPanel().
| #define MUT_ERR_MALLOC_FAILED MUT_ERR_UNFINISHED_TRANSLATION |
| #define mutC_STR | ( | x | ) | (x) |
Definiert in Zeile 156 der Datei Defs.h.
Wird benutzt von check_aktionen(), check_ausloeser(), check_komplex_intervall(), check_konsistenz(), get_ausloeser_taste(), get_intervall_wert(), get_new_harmonie(), get_new_intervall(), get_new_intervall_komplex(), get_new_logik(), get_new_name_in_argument_list(), get_new_name_in_parameterlist(), get_new_ton_absolut(), get_new_ton_komplex_negative(), get_new_ton_komplex_positive(), get_new_tonsystem(), get_new_tonsystem_negative(), get_umstimmung_breite_abs(), get_umstimmung_breite_rel(), get_umstimmung_taste_abs(), get_umstimmung_taste_rel(), get_umstimmung_umstimm_case_parameter(), get_umstimmung_umstimm_case_zahl(), get_umstimmung_umstimmungs_bund(), get_wert_komplex_intervall(), init_umstimmung(), intervall_nummer(), InGis::Open(), setze_nummer_von_abstand_und_zentrum(), test_zyklen(), test_zyklen_nummer(), ton_nummer(), u_test_zyklen() und yyparse().
| #define mutChar char |
Definiert in Zeile 142 der Datei Defs.h.
Wird benutzt von DoParse(), GetSep(), GisNote::GisNote(), KeyboardIn(), compat30::LoadRoutes(), Name2Key(), InGis::ProceedRoute(), ReadNote(), ReadParaNumber(), ReadParaStr() und ReadTag().
| #define mutCloseStream | ( | stream | ) | stream.close() |
Definiert in Zeile 176 der Datei Defs.h.
Wird benutzt von InMidiFile::Open().
| #define mutCopyIntoString | ( | left, | |
| right | |||
| ) | strcpy(left,right) |
| #define mutCopyString | ( | left, | |
| right | |||
| ) | left = strdup(right) |
Definiert in Zeile 149 der Datei Defs.h.
Wird benutzt von EndSegment(), EndSequenz(), GisReadHead::GisReadHead() und Tag().
| #define mutDelString | ( | string | ) | (mutFreeString(string), string = mutEmptyString) |
| #define mutEmptyString ((char *) NULL) |
Definiert in Zeile 145 der Datei Defs.h.
Wird benutzt von ChordNote::CheckCloseAlter(), ChordNote::CheckCloseTie(), ChordNote::ChordNote(), GisWriteHead::GetFreeNote(), GetSep(), GetTagId(), GisNote::GisNote(), GisParse(), GisSegment::GisSegment(), GisSequenz::GisSequenz(), GspParse(), InMidiFile::Load(), OutMidiFile::Load(), InGis::Load(), OutGis::Load() und ReadNewLine().
| #define mutFreeString | ( | string | ) | if (string) free (string) |
Definiert in Zeile 146 der Datei Defs.h.
Wird benutzt von GisReadHead::~GisReadHead(), GisSegment::~GisSegment(), GisSequenz::~GisSequenz(), GisTag::~GisTag(), GisToken::~GisToken() und GisWriteHead::~GisWriteHead().
| #define mutGetC | ( | stream | ) | stream.getc() |
Definiert in Zeile 180 der Datei Defs.h.
Wird benutzt von InMidiFile::Open().
| #define mutOpenIFstream | ( | name, | |
| filename | |||
| ) | STD_PRE::ifstream name(mutFileName(filename), STD_PRE::ios::in | STD_PRE::ios::binary/*0, filebuf::openprot*/) |
Definiert in Zeile 169 der Datei Defs.h.
Wird benutzt von InMidiFile::Open().
| #define mutOpenOFstream | ( | name, | |
| filename | |||
| ) | STD_PRE::ofstream name(mutFileName(filename), STD_PRE::ios::out | STD_PRE::ios::binary/*0, filebuf::openprot*/) |
Definiert in Zeile 167 der Datei Defs.h.
Wird benutzt von OutMidiFile::Close().
| #define mutPutC | ( | stream, | |
| data | |||
| ) | stream.putc(data) |
Definiert in Zeile 179 der Datei Defs.h.
Wird benutzt von Track::Save() und WriteLength().
| #define mutReadStream | ( | stream, | |
| data, | |||
| count | |||
| ) | stream.read(data,count) |
Definiert in Zeile 174 der Datei Defs.h.
Wird benutzt von InMidiFile::Open() und ReadLength().
| #define mutStrCmp | ( | left, | |
| right | |||
| ) | strcmp (left, right) |
Definiert in Zeile 152 der Datei Defs.h.
Wird benutzt von GetMatchingHeader().
| #define mutStreamBad | ( | stream | ) | (stream.bad()) |
Definiert in Zeile 182 der Datei Defs.h.
Wird benutzt von InMidiFile::Open(), OpenFile() und ReadNewLine().
| #define mutStreamEOF | ( | stream | ) | (stream.eof()) |
Definiert in Zeile 184 der Datei Defs.h.
Wird benutzt von InMidiFile::Open() und ReadNewLine().
| #define mutStreamGood | ( | stream | ) | (!stream.bad()) |
Definiert in Zeile 183 der Datei Defs.h.
Wird benutzt von InMidiFile::Open().
| #define mutStrEq | ( | left, | |
| right | |||
| ) | (!strcmp (left, right)) |
Definiert in Zeile 153 der Datei Defs.h.
Wird benutzt von MutaborTag().
| #define mutString (char*) |
Definiert in Zeile 143 der Datei Defs.h.
Wird benutzt von ChordNote::CheckCloseAlter(), ChordNote::CheckCloseTie(), GisReadHead::CreateSegmentSubs(), GisReadHead::CreateSequenzSubs(), GetMidiInstrument(), GetTheSpeedFactor(), MutaborTag(), tree_storage::Read(), ReadNote(), ReadParaStr(), ReadTag(), configtree::toFirstLeaf() und configtree::toNextLeaf().
| #define mutStrLen strlen |
Definiert in Zeile 159 der Datei Defs.h.
Wird benutzt von KeyboardIn().
| #define mutT _T |
Definiert in Zeile 78 der Datei Defs.h.
Wird benutzt von BeginParameter(), BeginRange(), ChordNote::CheckCloseTie(), ChordNote::ChordNote(), CloseAllSubs(), GisWriteHead::CloseCurrentToken(), GisWriteHead::CloseSubs(), GisReadHead::CreateSegmentSubs(), GisReadHead::CreateSequenzSubs(), DoParse(), EndParameter(), GisWriteHead::GetFreeNote(), GetMidiInstrument(), GetSep(), GetTheSpeedFactor(), GisNote::GisNote(), IsLetter(), IsNumber(), KeyboardIn(), MutaborTag(), ChordNote::MutNoteOn(), Name2Key(), ReadLong(), ReadNote(), ReadParaNumber(), ReadParaStr() und ReadTag().
| #define mutWriteStream | ( | stream, | |
| data, | |||
| count | |||
| ) | stream.write(data,count) |
Definiert in Zeile 172 der Datei Defs.h.
Wird benutzt von OutMidiFile::Close() und Track::Save().
| #define N_ | ( | s | ) | s |
Definiert in Zeile 50 der Datei Errors.cpp.
| #define OFFSET (sizeof(size_t)) |
| #define PROT_MAXCHARS PROT_MAXLINES*40 |
Definiert in Zeile 89 der Datei GrafKern.cpp.
Wird benutzt von laufzeit_message().
| #define PROT_MAXLINES 30 |
Definiert in Zeile 88 der Datei GrafKern.cpp.
| #define REUSE | ( | type | ) | type |
Definiert in Zeile 69 der Datei Defs.h.
Wird benutzt von OutMidiFile::NoteOn(), MutRouteWnd::OnDraw() und InMidiFile::ReadMidiProceed().
| #define SHOW_CHANNEL |
Definiert in Zeile 663 der Datei Execute.cpp.
| #define SYNTHESIZER_TYP_FB01 1 |
Definiert in Zeile 349 der Datei Interpre.h.
| #define SYNTHESIZER_TYP_GIS 3 |
Definiert in Zeile 351 der Datei Interpre.h.
| #define SYNTHESIZER_TYP_KEINER 0 |
Definiert in Zeile 348 der Datei Interpre.h.
| #define SYNTHESIZER_TYP_MULTI16 2 |
Definiert in Zeile 350 der Datei Interpre.h.
| #define u_adjazent | ( | a, | |
| b | |||
| ) |
u_matrix [ (a) * anzahl_umstimmungen_und_logiken \ * sizeof (char) + (b) * sizeof (char)]
Definiert in Zeile 2690 der Datei Parser.cpp.
Wird benutzt von check_konsistenz() und u_test_zyklen().
| typedef int parameter_typ |
| typedef struct TSYS tone_system |
| anonymous enum |
| MUT_ERR_UNKNOWN | |
| MUT_ERR_SYNTAX_ERROR | |
| MUT_ERR_INVALID_CHAR | |
| MUT_ERR_FILE_OPEN_FAILED | |
| MUT_ERR_UNFINISHED_TRANSLATION |
Definiert in Zeile 51 der Datei Errors.h.
{
MUT_ERR_UNKNOWN=0,
MUT_ERR_SYNTAX_ERROR,
MUT_ERR_INVALID_CHAR,
MUT_ERR_FILE_OPEN_FAILED,
MUT_ERR_UNFINISHED_TRANSLATION, /* Memory exhausted or insufficient source file */
};
| enum aktions_typ |
| enum argument_typ |
| enum aufruf_typ |
Definiert in Zeile 158 der Datei Interpre.h.
| enum ausloeser_typ |
| enum intervall_typ |
| enum ton_einstell_typ |
Definiert in Zeile 110 der Datei Interpre.h.
| enum ton_typ |
| enum umst_oder_logik_typ |
Definiert in Zeile 2664 der Datei Parser.cpp.
{
typ_umstimmung, typ_logik
};
| enum umstimmung_typ |
| long absLong | ( | const long | x | ) |
Definiert in Zeile 37 der Datei Frac.cpp.
Wird benutzt von frac::gcd().
{
if ( x >= 0 ) return x;
else return -x;
}
| void Add_Key | ( | int | instr, |
| int | key, | ||
| int | velo | ||
| ) |
| void AddKey | ( | int | box, |
| int | taste, | ||
| int | id | ||
| ) |
Definiert in Zeile 541 der Datei Execute.cpp.
Benutzt GET_INDEX, HarmonyAnalysis(), KEY_CHANGED, last_note_id, liegende_tasten, liegende_tasten_max, mut_box, harmonie_ereignis::pattern, mutabor_box_type::pattern und PTRN::tonigkeit.
Wird benutzt von InGis::Proceed(), InMidiPort::ProceedRoute() und InMidiFile::ProceedRoute().
{
liegende_tasten[box][liegende_tasten_max[box]++] = taste;
mut_box[box].pattern.tonigkeit[GET_INDEX(taste,mut_box[box].tonesystem)]++;
last_note_id[box] = (id << 16) + (box << 8) + taste;
HarmonyAnalysis(box, &mut_box[box].pattern);
last_note_id[box] = 0;
KEY_CHANGED(box);
}
| void AktionenInit | ( | ) |
Definiert in Zeile 121 der Datei GrafKern.cpp.
Benutzt nAktionen.
Wird benutzt von Activate().
{
nAktionen = 0;
}
| void AktionenMessage | ( | int | box, |
| const char * | aktionName | ||
| ) |
Definiert in Zeile 145 der Datei GrafKern.cpp.
Benutzt AKTIONEN_MAX, boxAktionen, lAktionen, nAktionen und sAktionen.
Wird benutzt von execute_aktion().
{
if ( nAktionen < AKTIONEN_MAX ) {
boxAktionen[nAktionen] = ((unsigned char*)&box)[0];
int l = 0;
if ( nAktionen )
l = lAktionen[nAktionen-1];
strcpy(&sAktionen[l], aktionName);
lAktionen[nAktionen++] = l + strlen(aktionName);
}
}
| void allgemeine_initialisierungen | ( | void | ) |
Definiert in Zeile 78 der Datei Parser.cpp.
Benutzt ton::name, ton::next, ton::ton_absolut, ton_absolut, ton::ton_typ, ton::u und xmalloc().
Wird benutzt von check_konsistenz().
{
ton_ohne_namen=(ton*) xmalloc((size_t) sizeof(struct ton));
ton_ohne_namen->name=NULL;
ton_ohne_namen->ton_typ=ton_absolut;
ton_ohne_namen->u.ton_absolut.ton_wert=0.0;
ton_ohne_namen->next=NULL;
}
| int argument_list_laenge | ( | struct argument_liste * | list | ) |
Definiert in Zeile 144 der Datei Parser.cpp.
Benutzt ton::next.
Wird benutzt von check_aktionen() und check_konsistenz().
{
if (list) return 1 + argument_list_laenge (list -> next);
return 0;
}
Definiert in Zeile 2249 der Datei Parser.cpp.
Benutzt ton::next.
Wird benutzt von berechne_toene_absolut().
{
while (liste)
{
*toene = liste;
toene++;
liste = liste->next;
}
}
| static void belege_zyklenfeld | ( | struct umst_oder_logik * | zyklen_feld, |
| struct umstimmung * | liste1, | ||
| struct logik * | liste2 | ||
| ) | [static] |
Definiert in Zeile 2695 der Datei Parser.cpp.
Benutzt umst_oder_logik::logik, logik::next, umstimmung::next, typ_logik, typ_umstimmung, umst_oder_logik::u, umst_oder_logik::umst_oder_logik_typ und umst_oder_logik::umstimmung.
Wird benutzt von check_konsistenz().
{
int i = 0;
while (liste1)
{
zyklen_feld[i].umst_oder_logik_typ = typ_umstimmung;
zyklen_feld[i].u.umstimmung = liste1;
liste1 = liste1->next;
i++;
}
while (liste2)
{
zyklen_feld[i].umst_oder_logik_typ = typ_logik;
zyklen_feld[i].u.logik = liste2;
liste2 = liste2->next;
i++;
}
}
| static void berechne_toene_absolut | ( | struct ton * | ton_liste | ) | [static] |
Definiert in Zeile 2321 der Datei Parser.cpp.
Benutzt _(), adjazent, anzahl_toene, belege_toene(), berechne_ton_endgueltig(), fatal_error(), test_zyklen(), ton_absolut, ton_komplex, ton_list_laenge(), ton_nummer(), ton::u, xalloca() und xde_alloca().
Wird benutzt von mutabor_programm_einlesen().
{
int i,j,k;
anzahl_toene = ton_list_laenge (list_of_toene);
toene = (ton* *) xalloca (sizeof(struct ton *) * anzahl_toene);
visited = (char*) xalloca (sizeof(char) * anzahl_toene);
matrix = (char*) xalloca (sizeof(char) * anzahl_toene * anzahl_toene);
/* Feld mit toenen initialisieren (zum schnelleren Zugriff) */
belege_toene (toene, list_of_toene);
/* Adjazenzmatrix initialisieren (Kein Ton hÑngt vom anderen ab) */
for (i=0; i<anzahl_toene; i++)
{
for (j=0; j<anzahl_toene; j++) {
adjazent (i,j) = 0;
}
}
/* Adjazenzmatrix initialisieren (AbhÑngigkeiten eintragen) */
for (i=0; i<anzahl_toene; i++)
{
if (toene[i]->ton_typ == ton_absolut) /* alles ok */ ;
else if (toene[i]->ton_typ == ton_komplex) {
adjazent (i, ton_nummer (toene[i]->u.ton_komplex.bezugston)) = 1;
} else {
fatal_error(0,_C_STR(_("loop")));
}
}
#ifdef DEBUG_ANZEIGE
/* Adjazenzmatrix anzeigen */
printf ("Matrix:\n");
for (i=0; i<anzahl_toene; i++)
{
printf ("%s -> ", toene[i]->name);
for (j=0; j<anzahl_toene; j++) {
if (adjazent (i,j))
printf ("%s ", toene[j]->name);
}
printf ("\n");
}
printf ("\n");
#endif
/* auf Zyklenfreiheit Pruefen */
for (k=0; k<anzahl_toene; k++)
visited [k] = 0;
for (k=0; k<anzahl_toene; k++)
{
visited [k] = 1;
test_zyklen (k);
visited [k] = 0;
}
/* Toene endgueltig berechnen */
for (k=0; k<anzahl_toene; k++)
berechne_ton_endgueltig (k);
#ifdef DEBUG_ANZEIGE
/* Adjazenzmatrix anzeigen */
printf ("Matrix:\n");
for (i=0; i<anzahl_toene; i++)
{
printf ("%s -> ", toene[i]->name);
for (j=0; j<anzahl_toene; j++) {
if (adjazent (i,j))
printf ("%s ", toene[j]->name);
}
printf ("\n");
}
printf ("\n");
#endif
xde_alloca (toene);
xde_alloca (visited);
xde_alloca (matrix);
}
| static void berechne_ton_endgueltig | ( | int | k | ) | [static] |
Definiert in Zeile 2291 der Datei Parser.cpp.
Benutzt _(), fatal_error(), get_wert_komplex_intervall(), ton::ton_absolut, ton_absolut, ton_komplex, ton_nummer(), ton::ton_typ und ton::u.
Wird benutzt von berechne_toene_absolut().
{
int b;
double help, help2;
switch (toene[k]->ton_typ) {
case ton_absolut: /* hier nichts zu tun */
break;
case ton_komplex:
b = ton_nummer (toene[k]->u.ton_komplex.bezugston);
berechne_ton_endgueltig (b);
help2 = get_wert_komplex_intervall (toene[k]->u.ton_komplex.komplex_liste);
help = toene[b]->u.ton_absolut.ton_wert;
toene[k]->ton_typ = ton_absolut;
toene[k]->u.ton_absolut.ton_wert = help * help2;
break;
default:
fatal_error(0,_C_STR(_("loop")));
}
}
| void calc_declaration_numbers | ( | char | withNames | ) |
Definiert in Zeile 201 der Datei GrafKern.cpp.
Benutzt anzahl_eingelesene_zeichen, intervall_list_laenge(), list_of_intervalle, list_of_logiken, list_of_toene, list_of_tonsysteme, list_of_umstimmungen, logik_list_laenge(), sd1, sd2, ton_list_laenge(), tonsystem_list_laenge() und umstimmungs_list_laenge().
Wird benutzt von Compile().
{
#ifdef MUTWIN
#ifdef WX
sd1 = wxString::Format(_T("%d"), logik_list_laenge(list_of_logiken));
sd2 = wxString::Format(_T("%d"), ton_list_laenge(list_of_toene));
sd3 = wxString::Format(_T("%d"), umstimmungs_list_laenge(list_of_umstimmungen));
sd4 = wxString::Format(_T("%d"), tonsystem_list_laenge(list_of_tonsysteme));
sd5 = wxString::Format(_T("%d"), intervall_list_laenge(list_of_intervalle));
sd6 = wxString::Format(_T("%ld"), anzahl_eingelesene_zeichen);
#else
sprintf(sd1, "%d\n%d\n%d",
logik_list_laenge(list_of_logiken),
ton_list_laenge(list_of_toene),
umstimmungs_list_laenge(list_of_umstimmungen));
sprintf(sd2, "%d\n%d\n%d",
tonsystem_list_laenge(list_of_tonsysteme),
intervall_list_laenge(list_of_intervalle),
anzahl_eingelesene_zeichen);
#endif
#else
if ( withNames) {
sprintf(sd1, " logics: %d\n tones: %d\n tunes: %d",
logik_list_laenge(list_of_logiken),
ton_list_laenge(list_of_toene),
umstimmungs_list_laenge(list_of_umstimmungen));
sprintf(sd2, " tone systems: %d\n intervalls; %d\n read chars: %d",
tonsystem_list_laenge(list_of_tonsysteme),
intervall_list_laenge(list_of_intervalle),
anzahl_eingelesene_zeichen);
} else {
sprintf(sd1, "%d\n%d\n%d",
logik_list_laenge(list_of_logiken),
ton_list_laenge(list_of_toene),
umstimmungs_list_laenge(list_of_umstimmungen));
sprintf(sd2, "%d\n%d\n%d",
tonsystem_list_laenge(list_of_tonsysteme),
intervall_list_laenge(list_of_intervalle),
anzahl_eingelesene_zeichen);
}
#endif
}
| static int case_label_enthalten_in_case_liste | ( | double | case_label, |
| struct case_liste * | lauf | ||
| ) | [static] |
Definiert in Zeile 2445 der Datei Parser.cpp.
Benutzt ton::next.
Wird benutzt von check_konsistenz().
{
if (lauf == NULL)
return 0;
else if ( ! lauf -> is_default &&
( (int)(case_label) == (int)(lauf -> case_label) ) )
return 1;
else
return case_label_enthalten_in_case_liste (case_label, lauf -> next);
}
| void change_anker | ( | int | instr, |
| int | neu | ||
| ) |
Definiert in Zeile 383 der Datei Execute.cpp.
Benutzt TSYS::anker, TSYS::breite, free_tonesystem, GET_FREQ, laufzeit_zentrum, mut_box, TSYS::periode, TSYS::ton und mutabor_box_type::tonesystem.
Wird benutzt von execute_aktion().
{
tone_system * tonsys = mut_box[box].tonesystem;
tone_system * temp = tonsys;
int i;
laufzeit_zentrum[box]-=neu-tonsys->anker;
while ( laufzeit_zentrum[box] < 0 )
laufzeit_zentrum[box] += tonsys->breite;
laufzeit_zentrum[box]%=tonsys->breite;
while (neu<36)
neu += tonsys->breite;
while (neu>96)
neu -= tonsys->breite;
free_tonesystem->ton[0]=GET_FREQ(neu,tonsys);
for (i=1; i<tonsys->breite; i++)
free_tonesystem->ton[i] =
free_tonesystem->ton[0] + tonsys->ton[i]-tonsys->ton[0];
free_tonesystem->anker=neu;
free_tonesystem->breite=tonsys->breite;
free_tonesystem->periode=tonsys->periode;
mut_box[box].tonesystem=free_tonesystem;
free_tonesystem=temp;
}
| void change_breite | ( | int | instr, |
| int | neu | ||
| ) |
Definiert in Zeile 414 der Datei Execute.cpp.
Benutzt TSYS::anker, TSYS::breite, GET_FREQ, MAX_BREITE, mut_box, TSYS::periode, TSYS::ton und mutabor_box_type::tonesystem.
Wird benutzt von execute_aktion().
{
tone_system * tonsys = mut_box[box].tonesystem;
int i;
if ( neu>0 && neu < MAX_BREITE ) {
if ( neu > tonsys->breite )
for (i = tonsys->breite; i < neu; i++)
tonsys->ton[i]=GET_FREQ((tonsys->anker+i),tonsys);
tonsys->periode =
GET_FREQ(tonsys->anker+neu,tonsys) - GET_FREQ(tonsys->anker,tonsys);
tonsys->breite=neu;
}
}
| static void check_aktionen | ( | struct aktions_liste * | aktionen, |
| const char * | name | ||
| ) | [static] |
Definiert in Zeile 2566 der Datei Parser.cpp.
Benutzt _(), aktions_liste::aktion_aufruf, aktion_aufruf, aktions_liste::aktion_midi_out, aktion_midi_out, aktions_liste::aktions_typ, argument_list_laenge(), compiler_warning(), fatal_error(), get_logik(), get_umstimmung(), midiliste::midi_code, mutC_STR, midiliste::next, parameter_list_laenge(), umstimmung::parameter_liste, parser_get_tonsystem() und aktions_liste::u.
Wird benutzt von check_konsistenz().
{
for ( ; aktionen ; aktionen = aktionen -> next )
{
if (aktionen->aktions_typ == aktion_midi_out) {
struct midiliste * midi_lauf
= aktionen->u.aktion_midi_out.midi_code;
if (midi_lauf -> midi_code < 128 ||
midi_lauf -> midi_code > 255 ) {
compiler_warning (1, mutC_STR(name));
}
while (midi_lauf) {
if (midi_lauf -> midi_code < 0 ||
midi_lauf -> midi_code > 255 ) {
fatal_error (50, mutC_STR(name), _C_STR(_("byte")));
}
midi_lauf = midi_lauf -> next;
}
}
if (aktionen->aktions_typ == aktion_aufruf) {
struct umstimmung * help_umstimmung =
get_umstimmung (aktionen->u.aktion_aufruf.name,
list_of_umstimmungen);
struct tonsystem * help_tonsystem =
parser_get_tonsystem (aktionen->u.aktion_aufruf.name,
list_of_tonsysteme);
struct logik * help_logik =
get_logik (aktionen->u.aktion_aufruf.name,
list_of_logiken);
int i=0;
if (help_umstimmung) i++;
if (help_tonsystem) i++;
if (help_logik) i++;
if (i == 0) {
fatal_error (38,
mutC_STR(aktionen->u.aktion_aufruf.name),
mutC_STR(name));
}
if (i > 1) {
compiler_warning (3, mutC_STR(aktionen->u.aktion_aufruf.name), mutC_STR(name));
}
if (help_umstimmung) {
if (argument_list_laenge (aktionen->u.aktion_aufruf.argument_liste)
!= parameter_list_laenge (help_umstimmung->parameter_liste)) {
fatal_error (61, mutC_STR(name), mutC_STR(aktionen->u.aktion_aufruf.name));
}
} else if (help_tonsystem) {
if (argument_list_laenge (aktionen->u.aktion_aufruf.argument_liste)
!= 0 ) {
fatal_error (61, mutC_STR(name), mutC_STR(aktionen->u.aktion_aufruf.name));
}
} else if (help_logik) {
if (argument_list_laenge (aktionen->u.aktion_aufruf.argument_liste)
!= 0 ) {
fatal_error (61, mutC_STR(name), mutC_STR(aktionen->u.aktion_aufruf.name));
}
}
}
}
}
Definiert in Zeile 2457 der Datei Parser.cpp.
Benutzt _(), ausloeser::ausloeser_harmonie, ausloeser_harmonie, ausloeser::ausloeser_harmonie_form, ausloeser_harmonie_form, ausloeser::ausloeser_midi_in, ausloeser_midi_in, ausloeser::ausloeser_typ, compiler_warning(), enthalten_in_tastenliste(), fatal_error(), get_harmonie(), midiliste::midi_code, mutC_STR, midiliste::next, harmonie::tastenliste und ausloeser::u.
Wird benutzt von check_konsistenz().
{
struct harmonie * help_harmonie;
if (ausloeser == NULL) return;
if (ausloeser->ausloeser_typ == ausloeser_harmonie_form)
{
help_harmonie = get_harmonie (ausloeser->u.ausloeser_harmonie_form.name, list_of_harmonien);
if (help_harmonie == NULL) {
fatal_error (30,
mutC_STR(ausloeser->u.ausloeser_harmonie_form.name),
mutC_STR(name));
}
if (enthalten_in_tastenliste
(ausloeser->u.ausloeser_harmonie_form.vortaste,
help_harmonie->tastenliste) ||
ausloeser->u.ausloeser_harmonie_form.vortaste
== -1 ) {
/* OK */
} else {
compiler_warning (2, mutC_STR(name));
/* Markierung setzen, fuer unmoeglichen Ausloeser */
ausloeser->u.ausloeser_harmonie_form.vortaste = -2;
}
if (enthalten_in_tastenliste
(ausloeser->u.ausloeser_harmonie_form.nachtaste,
help_harmonie->tastenliste) ||
ausloeser->u.ausloeser_harmonie_form.nachtaste
== -1 ) {
/* OK */
} else {
compiler_warning (2, mutC_STR(name));
/* Markierung setzen, fuer unmoeglichen Ausloeser */
ausloeser->u.ausloeser_harmonie_form.vortaste = -2;
}
}
if (ausloeser->ausloeser_typ == ausloeser_harmonie)
{
help_harmonie = get_harmonie (ausloeser->u.ausloeser_harmonie.name, list_of_harmonien);
if (help_harmonie == NULL) {
fatal_error (30,
mutC_STR(ausloeser->u.ausloeser_harmonie.name),
mutC_STR(name));
}
if (enthalten_in_tastenliste
(ausloeser->u.ausloeser_harmonie.vortaste,
help_harmonie->tastenliste) ||
ausloeser->u.ausloeser_harmonie.vortaste
== -1 ) {
/* OK */
} else {
compiler_warning (2, mutC_STR(name));
/* Markierung setzen, fuer unmoeglichen Ausloeser */
ausloeser->u.ausloeser_harmonie.vortaste = -2;
}
if (enthalten_in_tastenliste
(ausloeser->u.ausloeser_harmonie.nachtaste,
help_harmonie->tastenliste) ||
ausloeser->u.ausloeser_harmonie.nachtaste
== -1 ) {
/* OK */
} else {
compiler_warning (2, mutC_STR(name));
/* Markierung setzen, fuer unmoeglichen Ausloeser */
ausloeser->u.ausloeser_harmonie.vortaste = -2;
}
}
if (ausloeser->ausloeser_typ == ausloeser_midi_in)
{
struct midiliste * midi_lauf
= ausloeser->u.ausloeser_midi_in.midi_code;
if (midi_lauf -> midi_code < 128 ||
midi_lauf -> midi_code > 255 ) {
fatal_error (50, mutC_STR(name), _C_STR(_("status byte")));
}
if (midi_lauf -> midi_code & 0x000F ) {
midi_lauf -> midi_code &= 0xFFF0;
compiler_warning(1,mutC_STR(name));
}
midi_lauf = midi_lauf -> next;
while (midi_lauf) {
if (midi_lauf -> midi_code < 0 ||
midi_lauf -> midi_code > 127 ) {
fatal_error (50, mutC_STR(name), _C_STR(_("data byte")));
} else
midi_lauf = midi_lauf -> next;
}
}
}
| static void check_konsistenz | ( | void | ) | [static] |
Definiert in Zeile 2765 der Datei Parser.cpp.
Benutzt _(), aktions_liste::aktion_aufruf, aktion_aufruf, allgemeine_initialisierungen(), logik::anweisungsliste, anzahl_umstimmungen_und_logiken, argument_list_laenge(), anweisung::ausloeser, logik::ausloeser, ausloeser_default, ausloeser::ausloeser_typ, belege_zyklenfeld(), case_label_enthalten_in_case_liste(), check_aktionen(), check_ausloeser(), check_komplex_intervall(), compiler_warning(), logik::einstimmungs_name, fatal_error(), get_logik(), get_ton(), get_umstimmung(), logik_list_laenge(), mutC_STR, logik::name, umstimmung::name, ton::name, tonsystem::name, anweisung::next, logik::next, case_liste::next, aktions_liste::next, umstimmung::next, ton::next, tonsystem::next, parameter_list_laenge(), parser_get_tonsystem(), tonsystem::periode, tonsystem::taste, test_zyklen_nummer(), tonsystem::toene, ton_absolut, ton::ton_komplex, typ_logik, typ_umstimmung, umst_oder_logik::u, aktions_liste::u, ton::u, umstimmung::u, u_adjazent, u_test_zyklen(), umst_oder_logik::umstimmung, umstimmung_breite_abs, umstimmung_breite_rel, umstimmung_taste_abs, umstimmung_taste_rel, umstimmung::umstimmung_toene_veraendert, umstimmung_toene_veraendert, umstimmung::umstimmung_typ, umstimmung::umstimmung_umstimmungs_case, umstimmung_umstimmungs_case, umstimmung::umstimmung_umstimmungsbund, umstimmung_umstimmungsbund, umstimmung::umstimmung_wiederholung_abs, umstimmung_wiederholung_abs, umstimmung::umstimmung_wiederholung_rel, umstimmung_wiederholung_rel, umstimmungs_list_laenge(), xalloca() und xde_alloca().
Wird benutzt von mutabor_programm_einlesen().
{
allgemeine_initialisierungen();
/* Tonsysteme:
öberprÅfen, ob Periode und Tîne deklariert sind
und ob die Taste im Bereich 36 - 96 liegt.
*/
{ struct tonsystem * lauf;
struct ton * ton_lauf;
for (lauf = list_of_tonsysteme; lauf; lauf = lauf->next) {
check_komplex_intervall (lauf->periode, lauf->name);
if (lauf->taste < 24 || lauf->taste > 108) {
fatal_error(47,lauf->taste,mutC_STR(lauf->name)); /* UngÅlt. Taste */
}
for (ton_lauf = lauf->toene;
ton_lauf;
ton_lauf = ton_lauf->next) {
if ((ton_lauf->name != NULL) &&
(get_ton (ton_lauf->name, list_of_toene) == NULL)) {
fatal_error(33,mutC_STR(ton_lauf->name),mutC_STR(lauf->name));
}
}
}
}
/**** Umstimmungen prÅfen, ob alle Tîne und Intervalle
global deklariert sind, ob Umstimmungsbund und Umstimmungs_case
keine Rekursion enthÑlt, ob case_labels eindeutig sind,
und ob die benutzten Parameter
zu den deklarierten Parametern passen.
****/
{
struct umstimmung * lauf;
for (lauf = list_of_umstimmungen; lauf; lauf = lauf -> next) {
switch (lauf -> umstimmung_typ) {
default :
fatal_error (0, _T(__FILE__), __LINE__);
break;
case umstimmung_taste_abs :
case umstimmung_taste_rel :
case umstimmung_breite_abs :
case umstimmung_breite_rel :
break;
case umstimmung_wiederholung_rel :
check_komplex_intervall (lauf->u.umstimmung_wiederholung_rel.komplex_liste,
lauf->name);
break;
case umstimmung_wiederholung_abs :
check_komplex_intervall (lauf->u.umstimmung_wiederholung_abs.komplex_liste,
lauf->name);
break;
case umstimmung_toene_veraendert : {
struct ton * lauf_ton;
for (lauf_ton = lauf->u.umstimmung_toene_veraendert.tonliste;
lauf_ton;
lauf_ton = lauf_ton -> next) {
if (lauf_ton -> name != NULL) {
/* break geht hier wegen Bug in TURBO-C nicht! break for the next tone */
if (lauf_ton -> ton_typ == ton_absolut) {
fatal_error(48,mutC_STR(lauf->name), mutC_STR(lauf_ton->name));
/* nicht komplexer Ton */
}
if (strcmp (lauf_ton->name,
lauf_ton->u.ton_komplex.bezugston)) {
fatal_error(0,_T(__FILE__),__LINE__,_C_STR(_("retuning")));
}
if ((lauf_ton->name[0] != '@') &&
(get_ton (lauf_ton->name, list_of_toene) == NULL)) {
fatal_error(34,mutC_STR(lauf_ton->name),mutC_STR(lauf->name));
/* Undekl. Ton in Umst. */
}
check_komplex_intervall (lauf_ton->u.ton_komplex.komplex_liste,
lauf->name);
}
}
}
break;
case umstimmung_umstimmungsbund : {
/* Hier werden nur die LÑngen der Parameterlisten
verglichen. Die Zyklenfreiheit kommt spÑter
*/
struct aktions_liste * help_aktionen;
for (help_aktionen = lauf -> u.umstimmung_umstimmungsbund.aktions_liste;
help_aktionen;
help_aktionen = help_aktionen -> next) {
if (help_aktionen -> aktions_typ == aktion_aufruf) {
struct umstimmung * umst =
get_umstimmung (help_aktionen -> u.aktion_aufruf.name,
list_of_umstimmungen);
if (umst == NULL) {
struct tonsystem * tonsys =
parser_get_tonsystem (help_aktionen -> u.aktion_aufruf.name,
list_of_tonsysteme);
if (tonsys == NULL) {
struct logik * help_logik;
help_logik = get_logik (help_aktionen -> u.aktion_aufruf.name,
list_of_logiken);
if (help_logik == NULL) {
fatal_error(36,mutC_STR(help_aktionen -> u.aktion_aufruf.name)
,mutC_STR(lauf->name));
/* Umst. in Bund */
} else {
if (help_aktionen -> u.aktion_aufruf.argument_liste != NULL) {
fatal_error (63, mutC_STR(lauf -> name) ,
mutC_STR(help_aktionen -> u.aktion_aufruf.name));
}
}
} else {
if (help_aktionen -> u.aktion_aufruf.argument_liste != NULL) {
fatal_error (63, mutC_STR(lauf -> name), mutC_STR(help_aktionen -> u.aktion_aufruf.name));
}
}
} else {
if (argument_list_laenge (help_aktionen -> u.aktion_aufruf.argument_liste)
!= parameter_list_laenge (umst -> parameter_liste)) {
fatal_error(60,mutC_STR(lauf->name),mutC_STR(help_aktionen -> u.aktion_aufruf.name));
}
}
}
}
}
break;
case umstimmung_umstimmungs_case : {
/* Hier werden nur Eindeutigkeit der case_label
und die LÑngen der Parameterlisten
verglichen. Die Zyklenfreiheit kommt spÑter
*/
struct case_liste * case_lauf;
int anzahl_defaults;
struct aktions_liste * help_aktionen;
for (case_lauf = lauf->u.umstimmung_umstimmungs_case.umstimmungs_case_liste;
case_lauf;
case_lauf = case_lauf -> next ) {
if ( ! case_lauf -> is_default &&
case_label_enthalten_in_case_liste (case_lauf -> case_label,
case_lauf -> next ) ) {
fatal_error (22, (int)(case_lauf -> case_label),
mutC_STR(lauf -> name));
}
}
for (anzahl_defaults = 0,
case_lauf = lauf->u.umstimmung_umstimmungs_case.umstimmungs_case_liste;
case_lauf;
case_lauf = case_lauf -> next ) {
if (case_lauf -> is_default) {
anzahl_defaults ++;
if (anzahl_defaults > 1) {
fatal_error (21, mutC_STR(lauf -> name));
}
if (case_lauf -> next != NULL) {
/* compiler_warning ( ?? ANSONSTEN ist nicht letztes
Element der case_liste */
}
}
for (help_aktionen = case_lauf -> case_aktion;
help_aktionen;
help_aktionen = help_aktionen -> next) {
if (help_aktionen -> aktions_typ == aktion_aufruf) {
struct umstimmung * umst =
get_umstimmung (help_aktionen -> u.aktion_aufruf.name,
list_of_umstimmungen);
if (umst == NULL) {
struct tonsystem * tonsys =
parser_get_tonsystem (help_aktionen -> u.aktion_aufruf.name,
list_of_tonsysteme);
if (tonsys == NULL) {
struct logik * help_logik;
help_logik = get_logik (help_aktionen -> u.aktion_aufruf.name,
list_of_logiken);
if (help_logik == NULL) {
fatal_error(36,mutC_STR(help_aktionen -> u.aktion_aufruf.name)
,lauf->name);
/* Umst. in Bund */
} else {
if (help_aktionen -> u.aktion_aufruf.argument_liste != NULL) {
fatal_error (64, mutC_STR(lauf -> name) ,
mutC_STR(help_aktionen -> u.aktion_aufruf.name));
}
}
} else {
if (help_aktionen -> u.aktion_aufruf.argument_liste != NULL) {
fatal_error (64, mutC_STR(lauf -> name) ,
mutC_STR(help_aktionen -> u.aktion_aufruf.name));
}
}
} else {
if (argument_list_laenge (help_aktionen -> u.aktion_aufruf.argument_liste)
!= parameter_list_laenge (umst -> parameter_liste)) {
fatal_error(60, mutC_STR(lauf->name),
mutC_STR(help_aktionen -> u.aktion_aufruf.name));
}
}
}
}
}
}
break;
} /* of switch */
} /* of for */
/**** testzyklen ****/
{
int i,j,k;
anzahl_umstimmungen_und_logiken =
umstimmungs_list_laenge (list_of_umstimmungen)
+ logik_list_laenge (list_of_logiken) ;
zyklen_feld = (umst_oder_logik*) xalloca (sizeof(struct umst_oder_logik) * anzahl_umstimmungen_und_logiken);
u_visited = (char*) xalloca (sizeof(char) * anzahl_umstimmungen_und_logiken);
u_matrix = (char*) xalloca (sizeof(char) * anzahl_umstimmungen_und_logiken
* anzahl_umstimmungen_und_logiken);
/* Feld mit Umstimmungen initialisieren (zum schnelleren Zugriff) */
belege_zyklenfeld (zyklen_feld, list_of_umstimmungen, list_of_logiken);
/* Adjazenzmatrix initialisieren (Keine Umstimmung
hÑngt von einer anderen ab) */
for (i=0; i<anzahl_umstimmungen_und_logiken; i++) {
for (j=0; j<anzahl_umstimmungen_und_logiken; j++) {
u_adjazent (i,j) = 0;
}
}
/* Adjazenzmatrix initialisieren (AbhÑngigkeiten eintragen) */
for (i=0; i<anzahl_umstimmungen_und_logiken; i++) {
if (zyklen_feld[i].umst_oder_logik_typ == typ_umstimmung &&
zyklen_feld[i].u.umstimmung->umstimmung_typ == umstimmung_umstimmungsbund) {
struct aktions_liste *lauf = zyklen_feld[i].u.umstimmung->u.umstimmung_umstimmungsbund.aktions_liste;
for ( ; lauf ; lauf = lauf -> next ) {
if (lauf -> aktions_typ == aktion_aufruf) {
if (get_umstimmung (lauf -> u.aktion_aufruf.name,
list_of_umstimmungen) != NULL
||
get_logik (lauf -> u.aktion_aufruf.name,
list_of_logiken) != NULL
) {
/* Keine Tonsysteme adjazent eintragen */
u_adjazent (i, test_zyklen_nummer (lauf->u.aktion_aufruf.name)) = 1;
}
}
}
} else if (zyklen_feld[i].umst_oder_logik_typ == typ_umstimmung &&
zyklen_feld[i].u.umstimmung->umstimmung_typ ==
umstimmung_umstimmungs_case) {
struct case_liste * case_lauf;
for (case_lauf = zyklen_feld[i].u.umstimmung->u.umstimmung_umstimmungs_case.umstimmungs_case_liste;
case_lauf;
case_lauf = case_lauf -> next) {
struct aktions_liste *lauf = case_lauf -> case_aktion;
for ( ; lauf ; lauf = lauf -> next ) {
if (lauf -> aktions_typ == aktion_aufruf) {
if (get_umstimmung (lauf -> u.aktion_aufruf.name,
list_of_umstimmungen) != NULL
||
get_logik (lauf -> u.aktion_aufruf.name,
list_of_logiken) != NULL
) {
/* Keine Tonsysteme adjazent eintragen */
u_adjazent (i, test_zyklen_nummer (lauf->u.aktion_aufruf.name)) = 1;
}
}
}
}
} else if (zyklen_feld[i].umst_oder_logik_typ == typ_logik &&
zyklen_feld[i].u.logik->einstimmungs_name) {
if (get_umstimmung (zyklen_feld[i].u.logik->einstimmungs_name,
list_of_umstimmungen) != NULL) {
/* Keine Tonsysteme adjazent eintragen */
u_adjazent (i, test_zyklen_nummer (zyklen_feld[i].u.logik->einstimmungs_name)) = 1;
}
}
}
#ifdef DEBUG_ANZEIGE_2
/* Adjazenzmatrix anzeigen */
printf ("U_Matrix:\n");
for (i=0; i<anzahl_umstimmungen_und_logiken; i++) {
if (zyklen_feld[i].umst_oder_logik_typ == typ_umstimmung)
printf ("Umstimmung %s -> ", zyklen_feld[i].u.umstimmung->name);
else
printf ("Logik %s -> ", zyklen_feld[i].u.logik->name);
for (j=0; j<anzahl_umstimmungen_und_logiken; j++) {
if (u_adjazent (i,j))
if (zyklen_feld[j].umst_oder_logik_typ == typ_umstimmung)
printf ("Umstimmung %s ", zyklen_feld[j].u.umstimmung->name);
else
printf ("Logik %s -> ", zyklen_feld[j].u.logik->name);
}
printf ("\n");
}
printf ("\n");
#endif
/* auf Zyklenfreiheit Pruefen */
for (k=0; k<anzahl_umstimmungen_und_logiken; k++)
u_visited [k] = 0;
for (k=0; k<anzahl_umstimmungen_und_logiken; k++) {
u_visited [k] = 1;
u_test_zyklen (k);
u_visited [k] = 0;
}
#ifdef DEBUG_ANZEIGE_2
/* Adjazenzmatrix anzeigen */
printf ("U_Matrix:\n");
for (i=0; i<anzahl_umstimmungen_und_logiken; i++) {
if (zyklen_feld[i].umst_oder_logik_typ == typ_umstimmung)
printf ("Umstimmung %s -> ", zyklen_feld[i].u.umstimmung->name);
else
printf ("Logik %s -> ", zyklen_feld[i].u.logik->name);
for (j=0; j<anzahl_umstimmungen_und_logiken; j++) {
if (u_adjazent (i,j))
if (zyklen_feld[j].umst_oder_logik_typ == typ_umstimmung)
printf ("Umstimmung %s ", zyklen_feld[j].u.umstimmung->name);
else
printf ("Logik %s -> ", zyklen_feld[j].u.logik->name);
}
printf ("\n");
}
printf ("\n");
#endif
xde_alloca (zyklen_feld);
xde_alloca (u_visited);
xde_alloca (u_matrix);
}
/******* ende testzyklen **/
}
/* Logiken:
öberprÅfen, ob Einstimmung deklariert ist
und ob die Anweisungen korrekt deklariert sind.
*/
#if 1
{ struct logik * lauf;
struct anweisung * anweisungs_lauf;
int anzahl_default_ausloeser;
for (lauf = list_of_logiken; lauf; lauf = lauf->next) {
struct umstimmung * help_umstimmung;
check_ausloeser (lauf->ausloeser, lauf->name);
/* Eine Logik darf nicht mit dem DEFAULT-Auslîser aufgerufen werden */
if (lauf->ausloeser) {
if (lauf->ausloeser->ausloeser_typ == ausloeser_default) {
fatal_error (51, mutC_STR(lauf->name));
}
}
if (lauf->einstimmungs_name!=NULL) {
if (parser_get_tonsystem (lauf->einstimmungs_name, list_of_tonsysteme) == NULL) {
if ((help_umstimmung=get_umstimmung (lauf->einstimmungs_name, list_of_umstimmungen)) == NULL) {
fatal_error(37,mutC_STR(lauf->einstimmungs_name),
mutC_STR(lauf->name));
/* Einst. in Logik */
} else {
if (parameter_list_laenge (help_umstimmung -> parameter_liste) != 0) {
fatal_error(62, mutC_STR(lauf->name),
mutC_STR(lauf->einstimmungs_name));
}
}
}
}
for (anweisungs_lauf = lauf->anweisungsliste,
anzahl_default_ausloeser = 0;
anweisungs_lauf;
anweisungs_lauf = anweisungs_lauf->next) {
check_ausloeser (anweisungs_lauf->ausloeser, lauf->name);
if (anweisungs_lauf->ausloeser == NULL)
fatal_error (0, _T(__FILE__), __LINE__);
else {
if (anweisungs_lauf->ausloeser->ausloeser_typ
== ausloeser_default) {
anzahl_default_ausloeser ++;
if (anzahl_default_ausloeser > 1) {
fatal_error (20, mutC_STR(lauf -> name));
} else {
if (anweisungs_lauf -> next != NULL)
compiler_warning (4, mutC_STR(lauf -> name));
}
}
}
check_aktionen (anweisungs_lauf -> aktion, lauf->name);
}
}
}
#endif
}
| void clear_protokoll_screen | ( | void | ) |
Definiert in Zeile 454 der Datei Execute.cpp.
Benutzt PTRN::tonigkeit.
Wird benutzt von HarmonyAnalysis().
{
int i;
for (i=0;i<breite; i++,startindex++) {
if ( vergleich->tonigkeit[i] ) {
/* Bedeutung: vergleich: 0(egal) 1(off) 2(on)
laufzeit: 0(off) >0(on) */
if ( vergleich->tonigkeit[i]==1 &&
laufzeit->tonigkeit[startindex%breite] )
/* vergleich = off, aber laufzeit != off */
return 0 ;
if ( vergleich->tonigkeit[i]!=1 &&
laufzeit->tonigkeit[startindex%breite]==0 )
/* vergleich = on , aber laufzeit = off */
return 0 ;
}
}
return 1;
}
| void compiler_warning | ( | int | nr, |
| ... | |||
| ) |
Definiert in Zeile 302 der Datei GrafKern.cpp.
Benutzt _(), DEBUGLOGBASE, Fmeldung und Warning_text.
Wird benutzt von check_aktionen(), check_ausloeser(), check_konsistenz() und InGis::Open().
{
va_list arglist;
va_start(arglist,nr);
#ifdef MUTWIN
DEBUGLOGBASE (other,_T(""), _T("testing %s"), _T("%s"));
DEBUGLOGBASE (other,_T(""),
_T("Compiler warning %d: %s"),
nr,
Warning_text[nr]);
#if defined(WX)
wxMessageBox(wxString::FormatV(wxGetTranslation(Warning_text[nr]),
arglist),
_("Compiler warning"),
wxOK | wxICON_ASTERISK );
#else
char Fmeldung[255];
vsprintf( Fmeldung, Warning_text[nr], arglist );
MessageBox(0, Fmeldung, "Compiler warning", MB_OK | MB_ICONASTERISK );
#endif
#endif
}
| static int* create_midi_scan_liste | ( | struct midiliste * | lauf | ) | [static] |
Definiert in Zeile 774 der Datei TabGen.cpp.
Benutzt midiliste::midi_code, midi_list_laenge(), midiliste::next und xcalloc().
Wird benutzt von insert_in_globale_liste() und insert_in_lokale_liste().
{
int j, k, * ret;
j = midi_list_laenge (lauf);
ret = (int*) xcalloc((size_t)(j+1), sizeof(int));
for (k=0; lauf; lauf=lauf->next, k++)
ret [k] = lauf->midi_code;
ret [k] = -1;
return ret;
}
| void Delete_Key | ( | int | instr, |
| int | key | ||
| ) |
| void DeleteKey | ( | int | box, |
| int | taste, | ||
| int | id | ||
| ) |
Definiert in Zeile 552 der Datei Execute.cpp.
Benutzt GET_INDEX, HarmonyAnalysis(), KEY_CHANGED, last_note_id, liegende_tasten, liegende_tasten_max, mut_box, harmonie_ereignis::pattern, mutabor_box_type::pattern und PTRN::tonigkeit.
Wird benutzt von InGis::Proceed(), InMidiPort::ProceedRoute() und InMidiFile::ProceedRoute().
{
for (int i=0; i<liegende_tasten_max[box]; i++)
if ( liegende_tasten[box][i] == taste ) {
liegende_tasten[box][i] =
liegende_tasten[box][--liegende_tasten_max[box]];
mut_box[box].pattern.tonigkeit[GET_INDEX(taste,mut_box[box].tonesystem)]--;
last_note_id[box] = (id << 16) + (box << 8) + taste;
HarmonyAnalysis(box, &mut_box[box].pattern);
last_note_id[box] = 0;
KEY_CHANGED(box);
break;
}
}
| void drucke_keyboard_liste | ( | int | instr | ) |
| void eintrage_parameterliste_in_umstimmung | ( | void | ) |
Definiert in Zeile 1263 der Datei Parser.cpp.
Benutzt get_last_parameter_liste().
Wird benutzt von yyparse().
{
tmp_umstimmung -> parameter_liste = get_last_parameter_liste ();
}
| void enable_protokoll_frame | ( | void | ) |
| int enthalten_in_tastenliste | ( | int | taste, |
| struct taste * | lauf | ||
| ) |
Definiert in Zeile 2432 der Datei Parser.cpp.
Benutzt ton::next.
Wird benutzt von check_ausloeser().
| void execute_aktion | ( | int | box, |
| struct do_aktion * | aktion | ||
| ) |
Definiert in Zeile 124 der Datei Execute.cpp.
Benutzt _(), AktionenMessage(), TSYS::anker, do_aktion::aufruf_logik, aufruf_logik, do_aktion::aufruf_midi_out, aufruf_midi_out, do_aktion::aufruf_tonsystem, aufruf_tonsystem, do_aktion::aufruf_typ, do_aktion::aufruf_umst_breite_abs, aufruf_umst_breite_abs, do_aktion::aufruf_umst_breite_rel, aufruf_umst_breite_rel, do_aktion::aufruf_umst_taste_abs, aufruf_umst_taste_abs, do_aktion::aufruf_umst_taste_rel, aufruf_umst_taste_rel, do_aktion::aufruf_umst_toene_veraendert, aufruf_umst_toene_veraendert, aufruf_umst_umst_bund, do_aktion::aufruf_umst_umst_case, aufruf_umst_umst_case, do_aktion::aufruf_umst_wiederholung_abs, aufruf_umst_wiederholung_abs, do_aktion::aufruf_umst_wiederholung_rel, aufruf_umst_wiederholung_rel, TSYS::breite, case_element::case_aktion, case_element::case_wert, change_anker(), change_breite(), char, ton_einstell::einstell_absolut, einstell_absolut, einstell_gleich, ton_einstell::einstell_relativ, einstell_relativ, einstell_stumm, HarmonyAnalysis(), case_element::is_default, KEY_CHANGED, last_global_harmonie, last_global_keyboard, last_global_midi, logic_changed, midiliste::midi_code, MidiOut(), mut_box, do_aktion::name, midiliste::next, case_element::next, ton_einstell::next, NotesCorrect(), TSYS::periode, ton_einstell::ton_einstell_typ, mutabor_box_type::tonesystem, ton_einstell::u, do_aktion::u und update_pattern().
Wird benutzt von HarmonyAnalysis(), KeyboardAnalyse(), KeyboardAnalyseSimple() und MidiAnalysis().
{
bool WasNewLogic = false;
for ( ; aktion; aktion = aktion -> next)
{
AktionenMessage(box, aktion->name);
switch (aktion->aufruf_typ) {
case aufruf_logik:
execute_aktion (box, aktion->u.aufruf_logik.einstimmung);
* last_global_keyboard[box] =
* aktion->u.aufruf_logik.lokal_keyboard;
* last_global_harmonie[box] =
* aktion->u.aufruf_logik.lokal_harmonie;
* last_global_midi[box] =
* aktion->u.aufruf_logik.lokal_midi;
WasNewLogic = true;
break;
case aufruf_tonsystem:
* mut_box[box].tonesystem =
* aktion->u.aufruf_tonsystem.tonsystem;
update_pattern(box);
#ifdef NOTES_CORRECT_SOFORT
NotesCorrect(box);
#endif
KEY_CHANGED(box);
break;
case aufruf_umst_taste_abs:
change_anker(box,
aktion->u.aufruf_umst_taste_abs.wert[box]);
update_pattern(box);
#ifdef NOTES_CORRECT_SOFORT
NotesCorrect(box);
#endif
KEY_CHANGED(box);
break;
case aufruf_umst_breite_abs:
change_breite(box,
aktion->u.aufruf_umst_breite_abs.wert[box]);
update_pattern(box);
#ifdef NOTES_CORRECT_SOFORT
NotesCorrect(box);
#endif
KEY_CHANGED(box);
break;
case aufruf_umst_wiederholung_abs:
mut_box[box].tonesystem->periode =
aktion->u.aufruf_umst_wiederholung_abs.faktor;
#ifdef NOTES_CORRECT_SOFORT
NotesCorrect(box);
#endif
KEY_CHANGED(box);
break;
case aufruf_umst_wiederholung_rel:
mut_box[box].tonesystem->periode +=
aktion->u.aufruf_umst_wiederholung_rel.faktor;
#ifdef NOTES_CORRECT_SOFORT
NotesCorrect(box);
#endif
KEY_CHANGED(box);
break;
case aufruf_umst_taste_rel: {
int help;
help = mut_box[box].tonesystem->anker;
switch (aktion->u.aufruf_umst_taste_rel.rechenzeichen) {
case '+':
help += aktion->u.aufruf_umst_taste_rel.wert[box];
break;
case '-':
help -= aktion->u.aufruf_umst_taste_rel.wert[box];
break;
}
change_anker(box, help);
update_pattern(box);
#ifdef NOTES_CORRECT_SOFORT
NotesCorrect(box);
#endif
KEY_CHANGED(box);
}
break;
case aufruf_umst_breite_rel: {
int help;
help = mut_box[box].tonesystem->breite;
switch (aktion->u.aufruf_umst_breite_rel.rechenzeichen) {
case '+':
help += aktion->u.aufruf_umst_breite_rel.wert[box];
break;
case '-':
help -= aktion->u.aufruf_umst_breite_rel.wert[box];
break;
case '*':
help *= aktion->u.aufruf_umst_breite_rel.wert[box];
break;
case '/':
help /= aktion->u.aufruf_umst_breite_rel.wert[box];
break;
}
change_breite(box, help);
update_pattern(box);
#ifdef NOTES_CORRECT_SOFORT
NotesCorrect(box);
#endif
KEY_CHANGED(box);
}
break;
case aufruf_umst_toene_veraendert: {
long * ton_zeiger;
struct ton_einstell * lauf;
for (ton_zeiger = mut_box[box].tonesystem->ton,
lauf = aktion->u.aufruf_umst_toene_veraendert.tonliste;
lauf;
lauf = lauf->next, ton_zeiger ++) {
switch (lauf->ton_einstell_typ) {
case einstell_stumm:
* ton_zeiger = 0;
break;
case einstell_gleich:
/* nichts tun */
break;
case einstell_absolut:
* ton_zeiger = lauf->u.einstell_absolut.wert;
break;
case einstell_relativ:
* ton_zeiger += lauf->u.einstell_relativ.wert;
break;
}
}
#ifdef NOTES_CORRECT_SOFORT
NotesCorrect(box);
#endif
KEY_CHANGED(box);
}
break;
case aufruf_umst_umst_case: {
struct case_element * lauf;
int i;
i=aktion->u.aufruf_umst_umst_case.wert[box];
for (lauf = aktion->u.aufruf_umst_umst_case.umst_case;
lauf;
lauf = lauf->next) {
if ( (i == lauf->case_wert) || (lauf->is_default)) {
execute_aktion (box, lauf->case_aktion);
return;
}
}
}
break;
case aufruf_midi_out: {
struct midiliste * lauf;
unsigned long data = 0, faktor = 1, n = 0;
;
for (lauf = aktion->u.aufruf_midi_out.out_liste;
lauf && faktor ;
lauf = lauf -> next) {
data += faktor * (unsigned char) lauf->midi_code;
faktor *= 0x100;
n++;
}
MidiOut(box, data, n);
}
break;
case aufruf_umst_umst_bund:
wxLogWarning(_("Unhandled case path: aufruf_umst_umst_bund"));
break;
default:
wxLogError(_("Unexpected action type: %d"), aktion->aufruf_typ);
}
}
// check harmonies instantly
if ( WasNewLogic ) {
// \todo Check, if this is necessary or used
HarmonyAnalysis(box, &(mut_box[box].pattern));
logic_changed[box] = true;
}
#ifndef NOTES_CORRECT_SOFORT
NotesCorrect(box);
#endif
}
| void exit_laufzeit_protokoll | ( | void | ) |
Definiert in Zeile 343 der Datei GrafKern.cpp.
Wird benutzt von protokoll_aktuelle_relationen(), protokoll_aktuelles_tonsystem(), protokoll_liegende_frequenzen() und protokoll_liegende_relationen().
{}
| static struct do_aktion* expand_aktions_liste | ( | struct aktions_liste * | the_liste, |
| struct interpreter_parameter_liste * | aktuelle_parameter | ||
| ) | [static, read] |
Definiert in Zeile 463 der Datei TabGen.cpp.
Benutzt aktion_aufruf, aktion_midi_out, expandiere_midi(), expandiere_name(), fatal_error(), do_aktion::next und do_aktion::u.
Wird benutzt von expand_case_liste(), expandiere_umstimmung() und insert_in_lokale_liste().
{
struct do_aktion * help_1, * help_2, ** help_3;
if (the_liste == NULL) return NULL;
if (the_liste -> aktions_typ == aktion_aufruf)
{
help_1 = expandiere_name (the_liste -> u.aktion_aufruf.name,
the_liste -> u.aktion_aufruf.argument_liste,
aktuelle_parameter);
} else if (the_liste -> aktions_typ == aktion_midi_out)
{
help_1 = expandiere_midi (the_liste -> u.aktion_midi_out.midi_code);
} else
fatal_error (0, __FILE__, __LINE__);
help_2 = expand_aktions_liste (the_liste -> next, aktuelle_parameter);
for (help_3 = & help_1; * help_3; help_3 = & (*help_3)->next)
;
* help_3 = help_2;
return help_1;
}
| static struct case_element* expand_case_liste | ( | struct case_liste * | the_liste, |
| struct interpreter_parameter_liste * | aktuelle_parameter | ||
| ) | [static, read] |
Definiert in Zeile 497 der Datei TabGen.cpp.
Benutzt case_liste::case_aktion, case_liste::case_label, expand_aktions_liste(), case_liste::is_default, case_liste::next und xmalloc().
Wird benutzt von expandiere_umstimmung().
{
struct case_element * start_liste = NULL;
struct case_element ** ende_liste = & start_liste;
struct case_liste * lauf_liste;
for (lauf_liste = the_liste; lauf_liste; lauf_liste = lauf_liste -> next)
{
if ( ! lauf_liste -> is_default ) {
*ende_liste = (case_element*) xmalloc (sizeof (struct case_element));
(*ende_liste) -> case_wert = lauf_liste -> case_label;
(*ende_liste) -> is_default = 0;
(*ende_liste) -> case_aktion =
expand_aktions_liste (
lauf_liste -> case_aktion,
aktuelle_parameter);
(*ende_liste) -> next = NULL;
ende_liste = & (*ende_liste) -> next;
}
}
for (lauf_liste = the_liste; lauf_liste; lauf_liste = lauf_liste -> next)
{
if ( lauf_liste -> is_default ) {
*ende_liste = (case_element*) xmalloc (sizeof (struct case_element));
(*ende_liste) -> case_wert = lauf_liste -> case_label;
(*ende_liste) -> is_default = 1;
(*ende_liste) -> case_aktion =
expand_aktions_liste (
lauf_liste -> case_aktion,
aktuelle_parameter);
(*ende_liste) -> next = NULL;
ende_liste = & (*ende_liste) -> next;
}
}
return start_liste;
}
Definiert in Zeile 790 der Datei TabGen.cpp.
Benutzt taste::code, fatal_error(), get_harmonie(), list_of_harmonien, MAX_BREITE, taste::next, taste::stern, harmonie::tastenliste, PTRN::tonigkeit und xmalloc().
Wird benutzt von insert_in_globale_liste() und insert_in_lokale_liste().
{
struct harmonie * the_harmonie;
PATTERNN * help;
int i;
struct taste * lauf_taste;
the_harmonie = get_harmonie (harmonie_name, list_of_harmonien);
if (the_harmonie == NULL) {
fatal_error (0, __FILE__, __LINE__);
}
help = (PTRN*) xmalloc (sizeof (PATTERNN));
for (i=0;i<MAX_BREITE;i++) help->tonigkeit[i]=1; /* Off */
for (lauf_taste = the_harmonie->tastenliste;
lauf_taste;
lauf_taste = lauf_taste -> next) {
if (lauf_taste->stern=='*')
help->tonigkeit[lauf_taste->code]=0; /* Egal */
else
help->tonigkeit[lauf_taste->code]=2; /* On */
}
return help;
}
| static struct ton_einstell* expand_tonliste | ( | struct ton * | the_tonliste | ) | [static, read] |
Definiert in Zeile 303 der Datei TabGen.cpp.
Benutzt DOUBLE_TO_LONG, einstell_absolut, einstell_gleich, einstell_relativ, einstell_stumm, FAKTOR_TO_MIDI, fatal_error(), FREQUENZ_TO_MIDI, get_komplex_faktor(), get_komplex_frequenz(), ton::name, ton_einstell::next, ton::ton_absolut, ton_absolut, ton::ton_komplex, ton_komplex, ton::u, ton_einstell::u und xmalloc().
Wird benutzt von expandiere_umstimmung().
{
struct ton_einstell * help;
if (the_tonliste == NULL) return NULL;
help = (ton_einstell*) xmalloc (sizeof (struct ton_einstell));
switch (the_tonliste -> ton_typ)
{
default:
fatal_error (0, __FILE__, __LINE__);
case ton_absolut:
if (the_tonliste->name) {
help -> ton_einstell_typ = einstell_absolut;
help -> u.einstell_absolut.wert =
DOUBLE_TO_LONG (
FREQUENZ_TO_MIDI(
the_tonliste->u.ton_absolut.ton_wert));
} else {
help -> ton_einstell_typ = einstell_stumm;
}
break;
case ton_komplex:
if (the_tonliste->name == NULL) {
help -> ton_einstell_typ = einstell_stumm;
} else
if ( ! strcmp (the_tonliste->name, "@")) {
if (the_tonliste->u.ton_komplex.komplex_liste) {
help -> ton_einstell_typ = einstell_relativ;
help -> u.einstell_relativ.wert =
DOUBLE_TO_LONG (
FAKTOR_TO_MIDI (
get_komplex_faktor (the_tonliste->u.ton_komplex.komplex_liste)));
} else {
help -> ton_einstell_typ = einstell_gleich;
}
} else { /* normaler ton */
help -> ton_einstell_typ = einstell_absolut;
help -> u.einstell_absolut.wert =
DOUBLE_TO_LONG (
FREQUENZ_TO_MIDI (
get_komplex_frequenz (the_tonliste)));
}
break;
}
help -> next = expand_tonliste (the_tonliste -> next);
return help;
}
| static void expandiere_in_globale_liste | ( | void | ) | [static] |
Definiert in Zeile 1105 der Datei TabGen.cpp.
Benutzt midi_ereignis::aktion, expandiere_logik(), MAX_BOX, midi_ereignis::next und midi_ereignis::the_logik_to_expand.
Wird benutzt von mutabor_tabellen_generator().
{
struct harmonie_ereignis * lauf_harmonie [MAX_BOX];
struct keyboard_ereignis * lauf_keyboard [MAX_BOX];
struct midi_ereignis * lauf_midi [MAX_BOX];
int i;
for (i=0; i<MAX_BOX; i++) {
lauf_harmonie[i] = first_harmonie[i];
lauf_keyboard[i] = first_keyboard[i];
lauf_midi [i] = first_midi [i];
}
while (lauf_harmonie[0]) {
int j;
lauf_harmonie[0] -> aktion =
expandiere_logik (lauf_harmonie[0] -> the_logik_to_expand);
for (j=1; j<MAX_BOX; j++) {
lauf_harmonie[j] -> aktion = lauf_harmonie[0] -> aktion;
}
for (j=0; j<MAX_BOX; j++) {
lauf_harmonie[j] = lauf_harmonie[j] -> next;
}
}
while (lauf_keyboard[0]) {
int j;
lauf_keyboard[0] -> aktion =
expandiere_logik (lauf_keyboard[0] -> the_logik_to_expand);
for (j=1; j<MAX_BOX; j++) {
lauf_keyboard[j] -> aktion = lauf_keyboard[0] -> aktion;
}
for (j=0; j<MAX_BOX; j++) {
lauf_keyboard[j] = lauf_keyboard[j] -> next;
}
}
while (lauf_midi[0]) {
int j;
lauf_midi[0] -> aktion =
expandiere_logik (lauf_midi[0] -> the_logik_to_expand);
for (j=1; j<MAX_BOX; j++) {
lauf_midi[j] -> aktion = lauf_midi[0] -> aktion;
}
for (j=0; j<MAX_BOX; j++) {
lauf_midi[j] = lauf_midi[j] -> next;
}
}
}
Definiert in Zeile 413 der Datei TabGen.cpp.
Benutzt aufruf_logik, logik::einstimmungs_name, expandiere_tonsystem(), expandiere_umstimmung(), fatal_error(), get_logik_nummer(), get_umstimmung(), list_of_logiken, list_of_tonsysteme, list_of_umstimmungen, name, umstimmung::next, parser_get_tonsystem(), umstimmung::u und xmalloc().
Wird benutzt von expandiere_in_globale_liste() und expandiere_name().
{
struct do_aktion * help;
int i;
help = (do_aktion*) xmalloc (sizeof (struct do_aktion));
help -> name = the_logik -> name;
help -> aufruf_typ = aufruf_logik;
if (the_logik -> einstimmungs_name)
{
struct tonsystem * help_tonsystem;
struct umstimmung * help_umstimmung;
help_tonsystem = parser_get_tonsystem (the_logik->einstimmungs_name,
list_of_tonsysteme);
if (help_tonsystem) {
help -> u.aufruf_logik.einstimmung = expandiere_tonsystem (help_tonsystem);
} else {
help_umstimmung = get_umstimmung (the_logik->einstimmungs_name,
list_of_umstimmungen);
if (help_umstimmung) {
help -> u.aufruf_logik.einstimmung = expandiere_umstimmung (help_umstimmung, NULL);
} else {
fatal_error (0, __FILE__, __LINE__);
help -> u.aufruf_logik.einstimmung = NULL;
}
}
} else
help -> u.aufruf_logik.einstimmung = NULL;
i = get_logik_nummer (the_logik -> name, list_of_logiken);
help -> u.aufruf_logik.lokal_harmonie = & first_lokal_harmonie [i];
help -> u.aufruf_logik.lokal_keyboard = & first_lokal_keyboard [i];
help -> u.aufruf_logik.lokal_midi = & first_lokal_midi [i];
help -> next = NULL;
return help;
}
Definiert in Zeile 759 der Datei TabGen.cpp.
Benutzt aufruf_midi_out, name, do_aktion::next, do_aktion::u und xmalloc().
Wird benutzt von expand_aktions_liste().
{
struct do_aktion * help;
help = (do_aktion*) xmalloc (sizeof (struct do_aktion));
help -> name = "MidiOut";
help -> aufruf_typ = aufruf_midi_out;
help -> u.aufruf_midi_out.out_liste = liste;
help -> next = NULL;
return help;
}
| static struct do_aktion * expandiere_name | ( | const char * | name, |
| struct argument_liste * | parameter, | ||
| struct interpreter_parameter_liste * | bezugs_liste | ||
| ) | [static, read] |
Definiert in Zeile 706 der Datei TabGen.cpp.
Benutzt expandiere_logik(), expandiere_tonsystem(), expandiere_umstimmung(), fatal_error(), gen_parameter_liste(), get_logik(), get_umstimmung(), list_of_logiken, list_of_tonsysteme, list_of_umstimmungen und parser_get_tonsystem().
Wird benutzt von expand_aktions_liste().
{
struct logik * help_logik;
struct tonsystem * help_tonsystem;
struct umstimmung * help_umstimmung;
if (name == NULL) return NULL;
help_logik = get_logik (name, list_of_logiken);
if (help_logik)
{
return expandiere_logik (help_logik);
} else
{
help_tonsystem = parser_get_tonsystem (name, list_of_tonsysteme);
if (help_tonsystem) {
return expandiere_tonsystem (help_tonsystem);
} else {
help_umstimmung = get_umstimmung (name, list_of_umstimmungen);
if (help_umstimmung) {
struct interpreter_parameter_liste * aktuelle_parameter;
aktuelle_parameter = gen_parameter_liste (parameter, bezugs_liste);
return expandiere_umstimmung (help_umstimmung,
aktuelle_parameter);
} else
fatal_error (0, __FILE__, __LINE__);
return NULL;
}
}
}
Definiert in Zeile 365 der Datei TabGen.cpp.
Benutzt aufruf_tonsystem, DOUBLE_TO_LONG, FAKTOR_TO_MIDI, FREQUENZ_TO_MIDI, get_ton(), get_wert_komplex_intervall(), list_of_toene, ton::name, name, ton::next, toene, TSYS::ton, ton_list_laenge(), ton::u und xmalloc().
Wird benutzt von expandiere_logik() und expandiere_name().
{
struct do_aktion * help;
tone_system * help_tonsystem;
help = (do_aktion*) xmalloc (sizeof (struct do_aktion));
help -> name = the_tonsystem -> name;
help -> aufruf_typ = aufruf_tonsystem;
help_tonsystem = (TSYS*) xmalloc (sizeof (tone_system));
help_tonsystem -> anker = the_tonsystem -> taste;
help_tonsystem -> breite = ton_list_laenge (the_tonsystem -> toene);
help_tonsystem -> periode =
DOUBLE_TO_LONG (
FAKTOR_TO_MIDI (
get_wert_komplex_intervall (
the_tonsystem -> periode)));
{
struct ton * ton_lauf;
int i;
for (ton_lauf = the_tonsystem -> toene , i = 0 ;
ton_lauf;
ton_lauf = ton_lauf -> next , i++ ) {
if (ton_lauf->name) {
help_tonsystem->ton[i] =
DOUBLE_TO_LONG( FREQUENZ_TO_MIDI(
get_ton (
ton_lauf -> name, list_of_toene)
-> u.ton_absolut.ton_wert));
} else {
help_tonsystem->ton[i] = 0 ;
}
}
}
help -> u.aufruf_tonsystem.tonsystem = help_tonsystem;
help -> next = NULL;
return help;
}
| static struct do_aktion * expandiere_umstimmung | ( | struct umstimmung * | the_umstimmung, |
| struct interpreter_parameter_liste * | aktuelle_parameter | ||
| ) | [static, read] |
Definiert in Zeile 546 der Datei TabGen.cpp.
Benutzt aufruf_midi_out, aufruf_umst_breite_abs, aufruf_umst_breite_rel, aufruf_umst_taste_abs, aufruf_umst_taste_rel, aufruf_umst_toene_veraendert, aufruf_umst_umst_case, aufruf_umst_wiederholung_abs, aufruf_umst_wiederholung_rel, DOUBLE_TO_LONG, expand_aktions_liste(), expand_case_liste(), expand_tonliste(), FAKTOR_TO_MIDI, fatal_error(), get_wert_komplex_intervall(), get_wert_of_argument(), name, do_aktion::next, umstimmung::u, do_aktion::u, umstimmung::umstimmung_breite_abs, umstimmung_breite_abs, umstimmung::umstimmung_breite_rel, umstimmung_breite_rel, umstimmung::umstimmung_midi_out, umstimmung_midi_out, umstimmung::umstimmung_taste_abs, umstimmung_taste_abs, umstimmung::umstimmung_taste_rel, umstimmung_taste_rel, umstimmung::umstimmung_toene_veraendert, umstimmung_toene_veraendert, umstimmung::umstimmung_umstimmungs_case, umstimmung_umstimmungs_case, umstimmung::umstimmung_umstimmungsbund, umstimmung_umstimmungsbund, umstimmung::umstimmung_wiederholung_abs, umstimmung_wiederholung_abs, umstimmung_wiederholung_rel, xfree() und xmalloc().
Wird benutzt von expandiere_logik() und expandiere_name().
{
struct do_aktion * help;
help = (do_aktion*) xmalloc (sizeof (struct do_aktion));
help -> name = the_umstimmung -> name;
switch (the_umstimmung -> umstimmung_typ)
{
case umstimmung_taste_abs:
help -> aufruf_typ = aufruf_umst_taste_abs;
help -> u.aufruf_umst_taste_abs.wert =
get_wert_of_argument ( & the_umstimmung->u.umstimmung_taste_abs.argument,
aktuelle_parameter);
help -> next = NULL;
return help;
/* break; */
case umstimmung_breite_abs:
help -> aufruf_typ = aufruf_umst_breite_abs;
help -> u.aufruf_umst_breite_abs.wert =
get_wert_of_argument ( & the_umstimmung->u.umstimmung_breite_abs.argument,
aktuelle_parameter);
help -> next = NULL;
return help;
/* break; */
case umstimmung_wiederholung_abs:
help -> aufruf_typ = aufruf_umst_wiederholung_abs;
help -> u.aufruf_umst_wiederholung_abs.faktor =
DOUBLE_TO_LONG (
FAKTOR_TO_MIDI (
get_wert_komplex_intervall (
the_umstimmung->u.umstimmung_wiederholung_abs.komplex_liste)));
help -> next = NULL;
return help;
/* break; */
case umstimmung_wiederholung_rel:
help -> aufruf_typ = aufruf_umst_wiederholung_rel;
help -> u.aufruf_umst_wiederholung_rel.faktor =
DOUBLE_TO_LONG (
FAKTOR_TO_MIDI (
get_wert_komplex_intervall (
the_umstimmung->u.umstimmung_wiederholung_abs.komplex_liste)));
help -> next = NULL;
return help;
/* break; */
case umstimmung_taste_rel:
help -> aufruf_typ = aufruf_umst_taste_rel;
help -> u.aufruf_umst_taste_rel.wert =
get_wert_of_argument ( & the_umstimmung->u.umstimmung_taste_rel.argument,
aktuelle_parameter);
help -> u.aufruf_umst_taste_rel.rechenzeichen = the_umstimmung->u.umstimmung_taste_rel.rechenzeichen;
help -> next = NULL;
return help;
/* break; */
case umstimmung_breite_rel:
help -> aufruf_typ = aufruf_umst_breite_rel;
help -> u.aufruf_umst_breite_rel.wert =
get_wert_of_argument ( & the_umstimmung->u.umstimmung_breite_rel.argument,
aktuelle_parameter);
help -> u.aufruf_umst_breite_rel.rechenzeichen = the_umstimmung->u.umstimmung_breite_rel.rechenzeichen;
help -> next = NULL;
return help;
/* break; */
case umstimmung_toene_veraendert:
help -> aufruf_typ = aufruf_umst_toene_veraendert;
help -> u.aufruf_umst_toene_veraendert.tonliste =
expand_tonliste ( the_umstimmung->u.umstimmung_toene_veraendert.tonliste);
help -> next = NULL;
return help;
/* break; */
case umstimmung_umstimmungsbund:
xfree (help);
return expand_aktions_liste (the_umstimmung->u.umstimmung_umstimmungsbund.aktions_liste,
aktuelle_parameter);
/* break; */
case umstimmung_umstimmungs_case:
help -> aufruf_typ = aufruf_umst_umst_case;
help -> u.aufruf_umst_umst_case.wert =
get_wert_of_argument ( & the_umstimmung->u.umstimmung_umstimmungs_case.argument,
aktuelle_parameter);
help -> u.aufruf_umst_umst_case.umst_case =
expand_case_liste (the_umstimmung->u.umstimmung_umstimmungs_case.umstimmungs_case_liste,
aktuelle_parameter);
help -> next = NULL;
return help;
/* break; */
case umstimmung_midi_out:
help -> aufruf_typ = aufruf_midi_out;
help -> u.aufruf_midi_out.out_liste =
the_umstimmung->u.umstimmung_midi_out.out_liste;
help -> next = NULL;
return help;
/* break; */
default:
fatal_error (0, __FILE__, __LINE__);
return NULL;
}
}
| void fatal_error | ( | int | nr, |
| ... | |||
| ) |
Definiert in Zeile 288 der Datei GrafKern.cpp.
Benutzt Error_text, Fmeldung und weiter_gehts_nach_compilerfehler.
Wird benutzt von berechne_intervall_endgueltig(), berechne_intervalle_absolut(), berechne_toene_absolut(), berechne_ton_endgueltig(), check_aktionen(), check_ausloeser(), check_komplex_intervall(), check_konsistenz(), expand_aktions_liste(), expand_pattern(), expand_tonliste(), expandiere_logik(), expandiere_name(), expandiere_umstimmung(), fprint_argument(), gen_parameter_liste(), get_ausloeser_taste(), get_instrument_dekl(), get_intervall_wert(), get_komplex_faktor(), get_logik_nummer(), get_new_harmonie(), get_new_intervall(), get_new_intervall_komplex(), get_new_logik(), get_new_name_in_argument_list(), get_new_name_in_parameterlist(), get_new_ton_absolut(), get_new_ton_komplex_negative(), get_new_ton_komplex_positive(), get_new_tonsystem(), get_new_tonsystem_negative(), get_umstimmung_breite_abs(), get_umstimmung_breite_rel(), get_umstimmung_taste_abs(), get_umstimmung_taste_rel(), get_umstimmung_umstimm_case_parameter(), get_umstimmung_umstimm_case_zahl(), get_umstimmung_umstimmungs_bund(), get_umstimmung_wiederholung_abs_negative(), get_wert_komplex_intervall(), get_wert_of_argument(), init_umstimmung(), insert_in_globale_liste(), insert_in_lokale_liste(), intervall_nummer(), mutabor_programm_einlesen(), setze_nummer_von_abstand_und_zentrum(), test_zyklen(), test_zyklen_nummer(), ton_nummer(), u_test_zyklen(), xalloca(), xcalloc(), xmalloc(), xrealloc(), ymalloc(), yylex() und yyparse().
{
va_list arglist;
va_start(arglist,nr);
#if defined(WX)
Fmeldung = wxString::FormatV(wxGetTranslation(Error_text[nr]), arglist);
#else
vsprintf( Fmeldung, Error_text[nr], arglist );
#endif
longjmp( weiter_gehts_nach_compilerfehler , (nr==0)?255:nr );
}
| void FlushUpdateUI | ( | ) |
Definiert in Zeile 743 der Datei Execute.cpp.
Benutzt keys_changed, keys_changed_sum, logic_changed, MAX_BOX und updatecallback.
{
if ( keys_changed_sum && updatecallback ) {
for (int i=0; i<MAX_BOX; i++) {
if (keys_changed[i]) {
updatecallback(i,logic_changed[i]);
keys_changed[i]=0;
logic_changed[i]=0;
}
}
keys_changed_sum = 0;
}
}
| void fprint_argument | ( | FILE * | zieldatei, |
| struct argument * | argument | ||
| ) |
Definiert in Zeile 122 der Datei TabGen.cpp.
Benutzt fatal_error(), parameter, intervall::u und zahl.
{
if (argument -> argument_typ == zahl)
{
fprintf (zieldatei, ", %d ", argument -> u.zahl.zahl);
} else if (argument -> argument_typ == parameter)
{
fprintf (zieldatei, ", %s ", argument -> u.parameter.parameter_name);
} else
fatal_error (0, __FILE__, __LINE__ );
}
| long frac::gcd | ( | long | a, |
| long | b | ||
| ) |
Definiert in Zeile 282 der Datei Frac.cpp.
Benutzt absLong().
Wird benutzt von frac::operator*(), frac::operator*=(), frac::operator+(), frac::operator+=(), frac::operator-(), frac::operator-=(), frac::operator/() und frac::operator/=().
| static struct interpreter_parameter_liste* gen_parameter_liste | ( | struct argument_liste * | liste, |
| struct interpreter_parameter_liste * | bezugs_liste | ||
| ) | [static, read] |
Definiert in Zeile 206 der Datei TabGen.cpp.
Benutzt argument_liste::argument, argument::argument_typ, fatal_error(), get_cache_konstante(), argument_liste::next, interpreter_parameter_liste::next, argument::parameter, parameter, argument::u, interpreter_parameter_liste::werte_feld, xmalloc(), argument::zahl und zahl.
Wird benutzt von expandiere_name().
{
struct interpreter_parameter_liste * help;
if (liste == NULL)
return NULL;
help = (interpreter_parameter_liste*) xmalloc (sizeof (struct interpreter_parameter_liste));
switch (liste->argument.argument_typ)
{
case zahl:
help->werte_feld = get_cache_konstante (liste->argument.u.zahl.zahl);
break;
case parameter: {
int i;
struct interpreter_parameter_liste * lauf;
for (lauf = bezugs_liste, i=liste->argument.u.parameter.parameter_nummer;
lauf && i;
lauf = lauf -> next, i--)
;
if (lauf)
help->werte_feld = lauf -> werte_feld;
else
fatal_error (0, __FILE__, __LINE__);
}
break;
default:
fatal_error (0, __FILE__, __LINE__);
break;
}
help->next = gen_parameter_liste (liste->next, bezugs_liste);
return help;
}
| void get_aktion_aufruf | ( | const char * | name | ) |
| void get_aktion_midi_out | ( | void | ) |
| void get_ausloeser_default | ( | void | ) |
Definiert in Zeile 2040 der Datei Parser.cpp.
Benutzt ausloeser_default und xmalloc().
Wird benutzt von yyparse().
{
tmp_ausloeser = (ausloeser*) xmalloc (sizeof (struct ausloeser));
tmp_ausloeser -> ausloeser_typ = ausloeser_default;
}
| void get_ausloeser_harmonie | ( | void | ) |
Definiert in Zeile 2048 der Datei Parser.cpp.
Benutzt ausloeser_harmonie, tmp_nach_taste, tmp_name, tmp_vor_taste, ausloeser::u und xmalloc().
Wird benutzt von yyparse().
{
tmp_ausloeser = (ausloeser*) xmalloc (sizeof (struct ausloeser));
tmp_ausloeser -> ausloeser_typ = ausloeser_harmonie;
tmp_ausloeser -> u.ausloeser_harmonie.vortaste = tmp_vor_taste;
tmp_ausloeser -> u.ausloeser_harmonie.name = tmp_name;
tmp_ausloeser -> u.ausloeser_harmonie.nachtaste = tmp_nach_taste;
}
| void get_ausloeser_harmonie_form | ( | void | ) |
Definiert in Zeile 2058 der Datei Parser.cpp.
Benutzt ausloeser_harmonie_form, tmp_nach_taste, tmp_name, tmp_vor_taste, ausloeser::u und xmalloc().
Wird benutzt von yyparse().
{
tmp_ausloeser = (ausloeser*) xmalloc (sizeof (struct ausloeser));
tmp_ausloeser -> ausloeser_typ = ausloeser_harmonie_form;
tmp_ausloeser -> u.ausloeser_harmonie_form.vortaste = tmp_vor_taste;
tmp_ausloeser -> u.ausloeser_harmonie_form.name = tmp_name;
tmp_ausloeser -> u.ausloeser_harmonie_form.nachtaste = tmp_nach_taste;
}
| void get_ausloeser_midi_in | ( | void | ) |
Definiert in Zeile 2081 der Datei Parser.cpp.
Benutzt ausloeser_midi_in, get_last_integersequenz(), ausloeser::u und xmalloc().
Wird benutzt von yyparse().
{
tmp_ausloeser = (ausloeser*) xmalloc (sizeof (struct ausloeser));
tmp_ausloeser -> ausloeser_typ = ausloeser_midi_in;
tmp_ausloeser -> u.ausloeser_midi_in.midi_code
= get_last_integersequenz ();
}
| void get_ausloeser_taste | ( | const char * | name | ) |
Definiert in Zeile 2068 der Datei Parser.cpp.
Benutzt ausloeser_taste, fatal_error(), mutC_STR, name, ausloeser::u und xmalloc().
Wird benutzt von yyparse().
{
tmp_ausloeser = (ausloeser*) xmalloc (sizeof (struct ausloeser));
tmp_ausloeser -> ausloeser_typ = ausloeser_taste;
tmp_ausloeser -> u.ausloeser_taste.taste = name;
if (strlen (name) != 1) {
fatal_error (52, mutC_STR(name));
}
}
| static int(* get_cache_konstante | ( | int | wert | ) | )[MAX_BOX] [static] |
Definiert in Zeile 185 der Datei TabGen.cpp.
Benutzt cache_konstanten::konstante, MAX_BOX, cache_konstanten::next und xmalloc().
Wird benutzt von gen_parameter_liste() und get_wert_of_argument().
{
struct cache_konstanten ** lauf;
int i;
for (lauf = & cache_konstanten; *lauf; lauf = & (*lauf)->next) {
if ((*lauf)->konstante[0] == wert)
return & (*lauf)->konstante;
}
*lauf = (struct cache_konstanten*) xmalloc (sizeof (struct cache_konstanten));
for (i=0; i<MAX_BOX; i++)
(*lauf)->konstante[i] = wert;
(*lauf)->next = NULL;
return & (*lauf)->konstante;
}
| static struct harmonie_ereignis** get_ende_harmonie | ( | struct harmonie_ereignis ** | lauf | ) | [static, read] |
Definiert in Zeile 1177 der Datei TabGen.cpp.
Benutzt harmonie_ereignis::next.
Wird benutzt von mutabor_tabellen_generator().
{
if (*lauf == NULL) return lauf;
return get_ende_harmonie (& (*lauf) -> next);
}
| static struct keyboard_ereignis** get_ende_keyboard | ( | struct keyboard_ereignis ** | lauf | ) | [static, read] |
Definiert in Zeile 1186 der Datei TabGen.cpp.
Benutzt keyboard_ereignis::next.
Wird benutzt von mutabor_tabellen_generator().
{
if (*lauf == NULL) return lauf;
return get_ende_keyboard (& (*lauf) -> next);
}
| static struct midi_ereignis** get_ende_midi | ( | struct midi_ereignis ** | lauf | ) | [static, read] |
Definiert in Zeile 1195 der Datei TabGen.cpp.
Benutzt midi_ereignis::next.
Wird benutzt von mutabor_tabellen_generator().
{
if (*lauf == NULL) return lauf;
return get_ende_midi (& (*lauf) -> next);
}
Definiert in Zeile 197 der Datei Parser.cpp.
Benutzt harmonie::name und harmonie::next.
Wird benutzt von check_ausloeser() und expand_pattern().
{
if (liste == NULL) return NULL;
if ( ! strcmp (name, liste->name)) return liste;
return get_harmonie (name, liste->next);
}
| void get_harmoniebezeichner | ( | int | vor_taste, |
| const char * | name, | ||
| int | nach_taste | ||
| ) |
Definiert in Zeile 2019 der Datei Parser.cpp.
Benutzt name.
Wird benutzt von yyparse().
{
tmp_vor_taste = vor_taste;
tmp_name = name;
tmp_nach_taste = nach_taste;
}
| void get_instrument_dekl | ( | int | midi_in, |
| int | midi_von, | ||
| int | midi_bis, | ||
| int | midi_umleit, | ||
| struct instrument ** | list_to_insert | ||
| ) |
Definiert in Zeile 2162 der Datei Parser.cpp.
Benutzt fatal_error(), logik::next, instrument::next und xmalloc().
Wird benutzt von mutabor_programm_einlesen(), SetChannels() und yyparse().
{
int temp;
//for (list_to_insert = & list_of_instrumente;
for (;
* list_to_insert;
list_to_insert = & (*list_to_insert)->next)
{
if ( midi_in == (*list_to_insert)->midi_in) {
fatal_error(18, midi_in); /* MIDI-Instrument doppelt */
}
}
if ( midi_von > midi_bis )
{
temp=midi_von; /* Vertauschen der Reihenfolge */
midi_von=midi_bis;
midi_bis=temp;
}
if ( (midi_in < 1) || (midi_in > 16) )
{
fatal_error(45);
}
if ( midi_von && midi_bis )
{
if ( (midi_von < 1) || (midi_von > 16) )
fatal_error(45);
if ( (midi_bis < 1) || (midi_bis > 16) )
fatal_error(45);
}
if ( (midi_umleit < 0) || (midi_umleit > 16) )
{
fatal_error(45);
}
(* list_to_insert) = (instrument*) xmalloc (sizeof (struct instrument));
(* list_to_insert) -> midi_in = midi_in;
(* list_to_insert) -> midi_von = midi_von;
(* list_to_insert) -> midi_bis = midi_bis;
(* list_to_insert) -> midi_umleit = midi_umleit;
(* list_to_insert) -> next = NULL;
}
Definiert in Zeile 164 der Datei Parser.cpp.
Benutzt intervall::name und intervall::next.
Wird benutzt von check_komplex_intervall() und get_komplex_faktor().
{
if (liste == NULL) return NULL;
if ( ! strcmp (name, liste->name)) return liste;
return get_intervall (name, liste->next);
}
| double get_komplex_faktor | ( | struct komplex_intervall * | lauf | ) |
Definiert in Zeile 90 der Datei TabGen.cpp.
Benutzt komplex_intervall::faktor, fatal_error(), get_intervall(), intervall_absolut, list_of_intervalle, komplex_intervall::name, do_aktion::next und intervall::u.
Wird benutzt von expand_tonliste() und get_komplex_frequenz().
{
double ret = 1.0;
for ( ; lauf ; lauf = lauf -> next )
{
struct intervall * help = get_intervall (lauf->name, list_of_intervalle);
if (help && help -> intervall_typ == intervall_absolut) {
ret *= pow (help -> u.intervall_absolut.intervall_wert,
lauf->faktor);
} else {
fatal_error (0, __FILE__, __LINE__);
}
}
return ret;
}
| double get_komplex_frequenz | ( | struct ton * | dieser | ) |
Definiert in Zeile 112 der Datei TabGen.cpp.
Benutzt get_komplex_faktor(), get_ton(), list_of_toene, ton::ton_komplex, intervall::u und ton::u.
Wird benutzt von expand_tonliste().
{
double ret = get_ton (dieser->u.ton_komplex.bezugston, list_of_toene)
-> u.ton_absolut.ton_wert;
ret *= get_komplex_faktor (dieser->u.ton_komplex.komplex_liste);
return ret;
}
| static struct aktions_liste* get_last_aktions_liste | ( | void | ) | [static, read] |
Definiert in Zeile 404 der Datei Parser.cpp.
Benutzt list_of_aktionen.
Wird benutzt von get_new_anweisung(), get_umstimmung_umstimmungs_bund(), get_umstimmungs_case_default_element() und get_umstimmungs_case_zahl_element().
{
return list_of_aktionen;
}
| struct anweisung* get_last_anweisungs_liste | ( | void | ) | [read] |
Definiert in Zeile 2105 der Datei Parser.cpp.
Benutzt tmp_anweisungsliste.
Wird benutzt von vervollstaendige_logik().
{
return tmp_anweisungsliste ;
}
| static struct argument_liste* get_last_argument_liste | ( | void | ) | [static, read] |
Definiert in Zeile 359 der Datei Parser.cpp.
Benutzt list_of_argumente.
Wird benutzt von get_new_aktion_aufruf_element().
{
return list_of_argumente;
}
| struct ausloeser* get_last_ausloeser | ( | void | ) | [read] |
Definiert in Zeile 2035 der Datei Parser.cpp.
Benutzt tmp_ausloeser.
Wird benutzt von get_new_anweisung() und get_new_logik().
{
return tmp_ausloeser;
}
| static struct midiliste* get_last_integersequenz | ( | void | ) | [static, read] |
Definiert in Zeile 242 der Datei Parser.cpp.
Benutzt list_of_integers.
Wird benutzt von get_ausloeser_midi_in(), get_new_aktion_midi_out_element() und get_umstimmung_midi_out().
{
return list_of_integers;
}
| struct komplex_intervall* get_last_komplex_intervall | ( | void | ) | [read] |
Definiert in Zeile 437 der Datei Parser.cpp.
Benutzt the_komplex_liste.
Wird benutzt von get_new_intervall_komplex(), get_new_ton_komplex_negative(), get_new_ton_komplex_positive(), get_new_tonsystem(), get_new_tonsystem_negative(), get_new_umstimm_expression_negative(), get_new_umstimm_expression_positive(), get_umstimmung_wiederholung_abs(), get_umstimmung_wiederholung_abs_negative(), get_umstimmung_wiederholung_rel_negative() und get_umstimmung_wiederholung_rel_positive().
{
return the_komplex_liste;
}
| static struct parameter_liste* get_last_parameter_liste | ( | void | ) | [static, read] |
Definiert in Zeile 278 der Datei Parser.cpp.
Benutzt list_of_names.
Wird benutzt von eintrage_parameterliste_in_umstimmung().
{
return list_of_names;
}
Definiert in Zeile 207 der Datei Parser.cpp.
Benutzt logik::name und logik::next.
Wird benutzt von check_aktionen(), check_konsistenz() und expandiere_name().
Definiert in Zeile 124 der Datei Parser.cpp.
Benutzt fatal_error(), logik::name und logik::next.
Wird benutzt von expandiere_logik().
{
if (liste == NULL)
{
fatal_error (0, _T(__FILE__), __LINE__);
return 0;
} else if ( ! strcmp (name, liste->name))
return 0;
else
return 1 + get_logik_nummer (name, liste->next);
}
| void get_new_aktion_aufruf_element | ( | const char * | name | ) |
Definiert in Zeile 375 der Datei Parser.cpp.
Benutzt aktion_aufruf, get_last_argument_liste(), name, aktions_liste::next, aktions_liste::u und xmalloc().
Wird benutzt von yyparse().
{
struct aktions_liste * * lauf;
for (lauf= & list_of_aktionen; * lauf; lauf= & (*lauf)->next) {}
(* lauf) = (aktions_liste*) xmalloc ((size_t) sizeof (struct aktions_liste));
(* lauf) -> aktions_typ = aktion_aufruf;
(* lauf) -> u.aktion_aufruf.name = name;
(* lauf) -> u.aktion_aufruf.argument_liste = get_last_argument_liste ();
(* lauf) -> next = NULL;
}
| void get_new_aktion_midi_out_element | ( | void | ) |
Definiert in Zeile 390 der Datei Parser.cpp.
Benutzt aktion_midi_out, get_last_integersequenz(), aktions_liste::next, aktions_liste::u und xmalloc().
Wird benutzt von yyparse().
{
struct aktions_liste * * lauf;
for (lauf= & list_of_aktionen; * lauf; lauf= & (*lauf)->next) {}
(* lauf) = (aktions_liste*) xmalloc ((size_t) sizeof (struct aktions_liste));
(* lauf) -> aktions_typ = aktion_midi_out;
(* lauf) -> u.aktion_midi_out.midi_code = get_last_integersequenz ();
(* lauf) -> next = NULL;
}
| void get_new_anweisung | ( | void | ) |
Definiert in Zeile 2110 der Datei Parser.cpp.
Benutzt get_last_aktions_liste(), get_last_ausloeser(), anweisung::next und xmalloc().
Wird benutzt von yyparse().
{
struct anweisung * * lauf;
for (lauf= & tmp_anweisungsliste; * lauf; lauf= & (*lauf)->next)
/* Nur Ende der Liste finden */ ;
(* lauf) = (anweisung*) xmalloc (sizeof (struct anweisung));
(* lauf) -> ausloeser = get_last_ausloeser ();
(* lauf) -> aktion = get_last_aktions_liste ();
(* lauf) -> next = NULL;
}
| void get_new_faktor_anteil | ( | double | f, |
| const char * | name | ||
| ) |
Definiert in Zeile 418 der Datei Parser.cpp.
Benutzt komplex_intervall::faktor, name, komplex_intervall::next und xmalloc().
Wird benutzt von yyparse().
{
struct komplex_intervall * * lauf;
for (lauf= & the_komplex_liste; * lauf; lauf= & (*lauf)->next)
/* nur ende der Liste finden */ ;
(* lauf) = (komplex_intervall*) xmalloc ((size_t) sizeof (struct komplex_intervall));
(* lauf) -> faktor = f;
(* lauf) -> name = name;
(* lauf) -> next = NULL;
}
| void get_new_harmonie | ( | const char * | name, |
| int | bezugstaste | ||
| ) |
Definiert in Zeile 1956 der Datei Parser.cpp.
Benutzt harmonie::bezugstaste, fatal_error(), mutC_STR, name, harmonie::next, harmonie::tastenliste, tmp_tastenliste und xmalloc().
Wird benutzt von yyparse().
{
struct harmonie * * lauf;
for (lauf= & list_of_harmonien; * lauf; lauf= & (*lauf)->next) {
if ( ! strcmp (name, (*lauf)->name)) {
fatal_error(14, mutC_STR(name)); /* Harmoniename doppelt */
}
}
(* lauf) = (harmonie*) xmalloc (sizeof (struct harmonie));
(* lauf) -> name = name;
(* lauf) -> tastenliste = tmp_tastenliste;
(* lauf) -> bezugstaste = bezugstaste;
(* lauf) -> next = NULL;
}
| void get_new_integer_in_integersequenz | ( | int | wert | ) |
Definiert in Zeile 229 der Datei Parser.cpp.
Benutzt midiliste::midi_code, midiliste::next und xmalloc().
Wird benutzt von yyparse().
| void get_new_intervall | ( | const char * | name, |
| double | wert | ||
| ) |
Definiert in Zeile 1014 der Datei Parser.cpp.
Benutzt fatal_error(), intervall_absolut, mutC_STR, name, intervall::next, intervall::u und xmalloc().
Wird benutzt von mutabor_programm_einlesen() und yyparse().
{
struct intervall * * lauf;
for (lauf= & list_of_intervalle; * lauf; lauf= &(*lauf)->next) {
if ( ! strcmp (name, (*lauf)->name)) {
fatal_error(10,mutC_STR(name)); /* Intervallname doppelt */
}
}
if (fabs (wert) < 0.001)
fatal_error (46, mutC_STR(name));
(* lauf) = (intervall*) xmalloc ((size_t) sizeof (struct intervall));
(* lauf) -> name = name;
(* lauf) -> intervall_typ = intervall_absolut;
(* lauf) -> u.intervall_absolut.intervall_wert = wert;
(* lauf) -> next = NULL;
}
| void get_new_intervall_komplex | ( | const char * | name | ) |
Definiert in Zeile 1040 der Datei Parser.cpp.
Benutzt fatal_error(), get_last_komplex_intervall(), intervall_komplex, mutC_STR, name, intervall::next, intervall::u und xmalloc().
Wird benutzt von yyparse().
{
struct intervall * * lauf;
for (lauf= & list_of_intervalle; * lauf; lauf= &(*lauf)->next) {
if ( ! strcmp (name, (*lauf)->name)) {
fatal_error(10,mutC_STR(name)); /* Intervallname doppelt */
}
}
(* lauf) = (intervall*) xmalloc ((size_t) sizeof (struct intervall));
(* lauf) -> name = name;
(* lauf) -> intervall_typ = intervall_komplex;
(* lauf) -> u.intervall_komplex.komplex_liste =
get_last_komplex_intervall ();
(* lauf) -> next = NULL;
}
Definiert in Zeile 2129 der Datei Parser.cpp.
Benutzt logik::anweisungsliste, logik::einstimmungs_name, fatal_error(), get_last_ausloeser(), mutC_STR, name, logik::next und xmalloc().
Wird benutzt von yyparse().
{
struct logik * * lauf;
for (lauf= & list_of_logiken; * lauf; lauf= & (*lauf)->next) {
if ( ! strcmp (name, (*lauf)->name)) {
fatal_error(15, mutC_STR(name)); /* Logikname doppelt */
}
}
(* lauf) = (logik*) xmalloc (sizeof (struct logik));
(* lauf) -> name = name;
(* lauf) -> ausloeser = get_last_ausloeser ();
(* lauf) -> einstimmungs_name = einstimmung;
(* lauf) -> anweisungsliste = NULL;
(* lauf) -> next = NULL;
}
| void get_new_name_in_argument_list | ( | const char * | parameter | ) |
Definiert in Zeile 337 der Datei Parser.cpp.
Benutzt argument::argument_typ, fatal_error(), mutC_STR, name, argument_liste::next, argument::parameter, parameter, argument::u und xmalloc().
Wird benutzt von yyparse().
{
struct argument_liste * * lauf;
for (lauf= & list_of_argumente; * lauf; lauf= & (*lauf)->next) {
#if 0
if ( ! strcmp (name, (*lauf)->name)) {
fatal_error(17,mutC_STR(name)); /* Parametername doppelt: name */
}
#endif
}
(* lauf) = (argument_liste*) xmalloc ((size_t) sizeof (struct argument_liste));
(* lauf) -> argument.argument_typ = parameter;
(* lauf) -> argument.u.parameter.parameter_nummer = 0;
(* lauf) -> argument.u.parameter.parameter_name = parameter_name;
(* lauf) -> next = NULL;
}
| void get_new_name_in_parameterlist | ( | const char * | name | ) |
Definiert in Zeile 261 der Datei Parser.cpp.
Benutzt fatal_error(), mutC_STR, name, parameter_liste::next und xmalloc().
Wird benutzt von yyparse().
{
struct parameter_liste * * lauf;
for (lauf= & list_of_names; * lauf; lauf= & (*lauf)->next) {
if ( ! strcmp (name, (*lauf)->name)) {
fatal_error(17,mutC_STR(name)); /* Parametername doppelt: name */
}
}
(* lauf) = (parameter_liste*) xmalloc ((size_t) sizeof (struct parameter_liste));
(* lauf) -> name = name;
(* lauf) -> next = NULL;
}
| void get_new_number_in_argument_list | ( | double | parameter | ) |
Definiert in Zeile 322 der Datei Parser.cpp.
Benutzt argument::argument_typ, argument_liste::next, argument::u, xmalloc(), argument::zahl und zahl.
Wird benutzt von yyparse().
{
struct argument_liste * * lauf;
for (lauf= & list_of_argumente; * lauf; lauf= & (*lauf)->next) {}
(* lauf) = (argument_liste*) xmalloc ((size_t) sizeof (struct argument_liste));
(* lauf) -> argument.argument_typ = zahl;
(* lauf) -> argument.u.zahl.zahl = (int) parameter_zahl;
(* lauf) -> next = NULL;
}
| void get_new_number_in_parameterlist | ( | double | wert | ) |
| void get_new_taste | ( | int | taste, |
| char | stern | ||
| ) |
Definiert in Zeile 1937 der Datei Parser.cpp.
Benutzt taste::code, taste::next, taste::stern und xmalloc().
Wird benutzt von yyparse().
| void get_new_ton_absolut | ( | const char * | name, |
| double | wert | ||
| ) |
Definiert in Zeile 1065 der Datei Parser.cpp.
Benutzt fatal_error(), mutC_STR, name, ton::next, ton_absolut, ton::u und xmalloc().
Wird benutzt von mutabor_programm_einlesen() und yyparse().
{
struct ton * * lauf;
for (lauf= & list_of_toene; * lauf; lauf= & (*lauf)->next) {
if ( ! strcmp (name, (* lauf)->name)) {
fatal_error(11,mutC_STR(name)); /* Tonname doppelt */
}
}
(* lauf) = (ton*) xmalloc ((size_t) sizeof (struct ton));
(* lauf) -> name = name;
(* lauf) -> ton_typ = ton_absolut;
(* lauf) -> u.ton_absolut.ton_wert = wert;
(* lauf) -> next = NULL;
}
| void get_new_ton_in_tonsystem | ( | const char * | name | ) |
Definiert in Zeile 1106 der Datei Parser.cpp.
Benutzt ton::bezugston, komplex_intervall::faktor, fatal_error(), get_last_komplex_intervall(), mutC_STR, name, komplex_intervall::next, ton::next, ton_komplex, ton::u und xmalloc().
Wird benutzt von yyparse().
{
struct ton * * lauf;
for (lauf= & list_of_toene; * lauf; lauf= & (*lauf)->next) {
if ( ! strcmp (name, (*lauf)->name)) {
fatal_error(11,mutC_STR(name)); /* Tonname doppelt */
}
}
(* lauf) = (ton*) xmalloc ((size_t) sizeof (struct ton));
(* lauf) -> name = name;
(* lauf) -> ton_typ = ton_komplex;
(* lauf) -> u.ton_komplex.bezugston = bezugston;
{
struct komplex_intervall * help = get_last_komplex_intervall ();
if (help == NULL) {
fatal_error (0, _T(__FILE__), __LINE__);
}
help -> faktor *= -1.0 ;
(* lauf) -> u.ton_komplex.komplex_liste = help;
}
(* lauf) -> next = NULL;
}
void get_new_relativ_anteil (double f, char *linke_grenze, char *rechte_grenze);
Definiert in Zeile 1085 der Datei Parser.cpp.
Benutzt ton::bezugston, fatal_error(), get_last_komplex_intervall(), mutC_STR, name, ton::next, ton_komplex, ton::u und xmalloc().
Wird benutzt von yyparse().
{
struct ton * * lauf;
for (lauf= & list_of_toene; * lauf; lauf= & (*lauf)->next) {
if ( ! strcmp (name, (*lauf)->name)) {
fatal_error(11,mutC_STR(name)); /* Tonname doppelt */
}
}
(* lauf) = (ton*) xmalloc ((size_t) sizeof (struct ton));
(* lauf) -> name = name;
(* lauf) -> ton_typ = ton_komplex;
(* lauf) -> u.ton_komplex.bezugston = bezugston;
(* lauf) -> u.ton_komplex.komplex_liste = get_last_komplex_intervall ();
(* lauf) -> next = NULL;
}
| void get_new_tonsystem | ( | const char * | name, |
| int | taste | ||
| ) |
Definiert in Zeile 1170 der Datei Parser.cpp.
Benutzt fatal_error(), get_last_komplex_intervall(), mutC_STR, name, tonsystem::next, tonsystem::periode, tonsystem::taste, toene, ton_liste und xmalloc().
Wird benutzt von yyparse().
{
struct tonsystem * * lauf;
for (lauf= & list_of_tonsysteme; * lauf; lauf= & (*lauf)->next) {
if ( ! strcmp (name, (*lauf)->name)) {
fatal_error(12,mutC_STR(name)); /* Tonsystemname doppelt */
}
}
(* lauf) = (struct tonsystem*) xmalloc ((size_t) sizeof (struct tonsystem));
(* lauf) -> name = name;
(* lauf) -> taste = taste;
(* lauf) -> periode = get_last_komplex_intervall ();
(* lauf) -> toene = ton_liste;
(* lauf) -> next = NULL;
}
| void get_new_tonsystem_negative | ( | const char * | name, |
| int | taste | ||
| ) |
Definiert in Zeile 1191 der Datei Parser.cpp.
Benutzt komplex_intervall::faktor, fatal_error(), get_last_komplex_intervall(), mutC_STR, name, komplex_intervall::next, tonsystem::next, tonsystem::taste, toene, ton_liste und xmalloc().
Wird benutzt von yyparse().
{
struct tonsystem * * lauf;
for (lauf= & list_of_tonsysteme; * lauf; lauf= & (*lauf)->next) {
if ( ! strcmp (name, (*lauf)->name)) {
fatal_error(12,mutC_STR(name)); /* Tonsystemname doppelt */
}
}
(* lauf) = (struct tonsystem*) xmalloc ((size_t) sizeof (struct tonsystem));
(* lauf) -> name = name;
(* lauf) -> taste = taste;
{
struct komplex_intervall * help = get_last_komplex_intervall ();
if (help == NULL)
fatal_error (0, _T(__FILE__), __LINE__);
help -> faktor *= -1.0 ;
(* lauf) -> periode = help;
}
(* lauf) -> toene = ton_liste;
(* lauf) -> next = NULL;
}
| void get_new_umstimm_expression | ( | const char * | bezugston | ) |
Definiert in Zeile 1433 der Datei Parser.cpp.
Benutzt ton::bezugston, name, ton::next, ton_komplex, ton::u und xmalloc().
Wird benutzt von yyparse().
{
struct ton * * lauf;
for (lauf= & tmp_tonliste; * lauf; lauf= & (*lauf)->next)
/* Nur Ende der Liste finden */ ;
(* lauf) = (ton*) xmalloc ((size_t) sizeof (struct ton));
(* lauf) -> name = bezugston;
(* lauf) -> ton_typ = ton_komplex;
(* lauf) -> u.ton_komplex.bezugston = bezugston;
(* lauf) -> u.ton_komplex.komplex_liste = NULL;
(* lauf) -> next = NULL;
}
| void get_new_umstimm_expression_negative | ( | const char * | bezugston | ) |
Definiert in Zeile 1481 der Datei Parser.cpp.
Benutzt ton::bezugston, komplex_intervall::faktor, get_last_komplex_intervall(), name, komplex_intervall::next, ton::next, ton_komplex, ton::u und xmalloc().
Wird benutzt von yyparse().
{
struct ton * * lauf;
for (lauf= & tmp_tonliste; * lauf; lauf= & (*lauf)->next)
/* Nur Ende der Liste finden */ ;
(* lauf) = (ton*) xmalloc ((size_t) sizeof (struct ton));
(* lauf) -> name = bezugston;
(* lauf) -> ton_typ = ton_komplex;
(* lauf) -> u.ton_komplex.bezugston = bezugston;
{
struct komplex_intervall * help = get_last_komplex_intervall ();
help->faktor *= -1.0;
(* lauf) -> u.ton_komplex.komplex_liste = help;
}
(* lauf) -> next = NULL;
}
| void get_new_umstimm_expression_positive | ( | const char * | bezugston | ) |
Definiert in Zeile 1457 der Datei Parser.cpp.
Benutzt ton::bezugston, get_last_komplex_intervall(), name, ton::next, ton_komplex, ton::u und xmalloc().
Wird benutzt von yyparse().
{
struct ton * * lauf;
for (lauf= & tmp_tonliste; * lauf; lauf= & (*lauf)->next)
/* Nur Ende der Liste finden */ ;
(* lauf) = (ton*) xmalloc ((size_t) sizeof (struct ton));
(* lauf) -> name = bezugston;
(* lauf) -> ton_typ = ton_komplex;
(* lauf) -> u.ton_komplex.bezugston = bezugston;
(* lauf) -> u.ton_komplex.komplex_liste = get_last_komplex_intervall ();
(* lauf) -> next = NULL;
}
| void get_new_umstimmung | ( | void | ) |
Definiert in Zeile 1252 der Datei Parser.cpp.
Benutzt umstimmung::next und tmp_umstimmung.
Wird benutzt von yyparse().
{
struct umstimmung * * lauf;
for (lauf= & list_of_umstimmungen; * lauf; lauf= & (*lauf)->next) {}
(* lauf) = tmp_umstimmung;
}
| PATTERNN* get_pattern | ( | int | instr | ) |
Definiert in Zeile 152 der Datei Parser.cpp.
Benutzt ton::name und ton::next.
Wird benutzt von check_konsistenz(), expandiere_tonsystem() und get_komplex_frequenz().
| struct umstimmung * get_umstimmung | ( | const char * | name, |
| struct umstimmung * | liste | ||
| ) | [read] |
Definiert in Zeile 186 der Datei Parser.cpp.
Benutzt umstimmung::name und umstimmung::next.
Wird benutzt von check_aktionen(), check_konsistenz(), expandiere_logik() und expandiere_name().
{
if (liste == NULL) return NULL;
if ( ! strcmp (name, liste->name)) return liste;
return get_umstimmung (name, liste->next);
}
| void get_umstimmung_breite_abs | ( | enum argument_typ | argument, |
| double | zahl_wert, | ||
| const char * | parameter | ||
| ) |
Definiert in Zeile 1349 der Datei Parser.cpp.
Benutzt umstimmung::argument, fatal_error(), mutC_STR, umstimmung::name, parameter, umstimmung::parameter_liste, parameter_nummer(), umstimmung::u, umstimmung_breite_abs und zahl.
Wird benutzt von yyparse().
{
tmp_umstimmung -> umstimmung_typ = umstimmung_breite_abs;
tmp_umstimmung -> u.umstimmung_breite_abs.
argument.argument_typ
= argument;
if (argument == zahl) {
tmp_umstimmung -> u.umstimmung_breite_abs.
argument.u.zahl.zahl = (int) zahl_wert;
} else {
int i = parameter_nummer (0, parameter,
tmp_umstimmung->parameter_liste);
if (i == EOF) {
fatal_error(31,
mutC_STR(parameter),
mutC_STR(tmp_umstimmung->name)); /* Parameter n.dekl. */
}
tmp_umstimmung -> u.umstimmung_breite_abs.
argument.u.parameter.
parameter_nummer = i;
tmp_umstimmung -> u.umstimmung_breite_abs.
argument.u.parameter.
parameter_name = parameter;
}
}
| void get_umstimmung_breite_rel | ( | enum argument_typ | argument, |
| double | zahl_wert, | ||
| const char * | parameter, | ||
| char | vorzeichen | ||
| ) |
Definiert in Zeile 1383 der Datei Parser.cpp.
Benutzt umstimmung::argument, fatal_error(), mutC_STR, umstimmung::name, parameter, umstimmung::parameter_liste, parameter_nummer(), umstimmung::u, umstimmung_breite_rel und zahl.
Wird benutzt von yyparse().
{
tmp_umstimmung -> umstimmung_typ = umstimmung_breite_rel;
tmp_umstimmung -> u.umstimmung_breite_rel.
argument.argument_typ
= argument;
if (argument == zahl) {
tmp_umstimmung -> u.umstimmung_breite_rel.
argument.u.zahl.zahl = (int) zahl_wert;
} else {
int i = parameter_nummer (0, parameter,
tmp_umstimmung->parameter_liste);
if (i == EOF) {
fatal_error(31,
mutC_STR(parameter),
mutC_STR(tmp_umstimmung->name)); /* Parameter n.dekl. */
}
tmp_umstimmung -> u.umstimmung_breite_rel.
argument.u.parameter.
parameter_nummer = i;
tmp_umstimmung -> u.umstimmung_breite_rel.
argument.u.parameter.
parameter_name = parameter;
}
tmp_umstimmung -> u.umstimmung_breite_rel.rechenzeichen
= vorzeichen;
}
| void get_umstimmung_midi_out | ( | void | ) |
Definiert in Zeile 1915 der Datei Parser.cpp.
Benutzt get_last_integersequenz(), umstimmung::umstimmung_midi_out und umstimmung_midi_out.
Wird benutzt von yyparse().
{
tmp_umstimmung -> umstimmung_typ = umstimmung_midi_out;
tmp_umstimmung -> u.umstimmung_midi_out.out_liste
= get_last_integersequenz ();
}
| void get_umstimmung_taste_abs | ( | enum argument_typ | argument, |
| double | zahl_wert, | ||
| const char * | parameter | ||
| ) |
Definiert in Zeile 1278 der Datei Parser.cpp.
Benutzt umstimmung::argument, fatal_error(), mutC_STR, umstimmung::name, parameter, umstimmung::parameter_liste, parameter_nummer(), umstimmung::u, umstimmung_taste_abs und zahl.
Wird benutzt von yyparse().
{
tmp_umstimmung -> umstimmung_typ = umstimmung_taste_abs;
tmp_umstimmung -> u.umstimmung_taste_abs.
argument.argument_typ
= argument;
if (argument == zahl) {
tmp_umstimmung -> u.umstimmung_taste_abs.
argument.u.zahl.zahl = (int) zahl_wert;
} else {
int i = parameter_nummer (0, parameter,
tmp_umstimmung->parameter_liste);
if (i == EOF) {
fatal_error(31,
mutC_STR(parameter),
mutC_STR(tmp_umstimmung->name)); /* Parameter n.dekl. */
}
tmp_umstimmung -> u.umstimmung_taste_abs.
argument.u.parameter.
parameter_nummer = i;
tmp_umstimmung -> u.umstimmung_taste_abs.
argument.u.parameter.
parameter_name = parameter;
}
}
| void get_umstimmung_taste_rel | ( | enum argument_typ | argument, |
| double | zahl_wert, | ||
| const char * | parameter, | ||
| char | vorzeichen | ||
| ) |
Definiert in Zeile 1311 der Datei Parser.cpp.
Benutzt umstimmung::argument, fatal_error(), mutC_STR, name, parameter, umstimmung::parameter_liste, parameter_nummer(), umstimmung::u, umstimmung_taste_rel und zahl.
Wird benutzt von yyparse().
{
tmp_umstimmung -> umstimmung_typ = umstimmung_taste_rel;
tmp_umstimmung -> u.umstimmung_taste_rel.
argument.argument_typ
= argument;
if (argument == zahl) {
tmp_umstimmung -> u.umstimmung_taste_rel.
argument.u.zahl.zahl = (int) zahl_wert;
} else {
int i = parameter_nummer (0, parameter,
tmp_umstimmung->parameter_liste);
if (i == EOF) {
fatal_error(31,
mutC_STR(parameter),
mutC_STR(tmp_umstimmung -> name)); /* Parameter n.dekl. */
}
tmp_umstimmung -> u.umstimmung_taste_rel.
argument.u.parameter.
parameter_nummer = i;
tmp_umstimmung -> u.umstimmung_taste_rel.
argument.u.parameter.
parameter_name = parameter;
}
tmp_umstimmung -> u.umstimmung_taste_rel.rechenzeichen
= vorzeichen;
}
| void get_umstimmung_tonhoehe_veraendert | ( | void | ) |
Definiert in Zeile 1510 der Datei Parser.cpp.
Benutzt tmp_tonliste, umstimmung::umstimmung_toene_veraendert und umstimmung_toene_veraendert.
Wird benutzt von yyparse().
{
tmp_umstimmung -> umstimmung_typ = umstimmung_toene_veraendert;
tmp_umstimmung -> u.umstimmung_toene_veraendert.tonliste
= tmp_tonliste;
}
| void get_umstimmung_umstimm_case_parameter | ( | const char * | selector | ) |
Definiert in Zeile 1835 der Datei Parser.cpp.
Benutzt aktions_liste::aktion_aufruf, aktion_aufruf, argument_liste::argument, argument::argument_typ, fatal_error(), mutC_STR, umstimmung::name, argument_liste::next, aktions_liste::next, case_liste::next, argument::parameter, parameter, parameter_nummer(), tmp_umstimmungs_case_liste, argument::u, umstimmung::umstimmung_umstimmungs_case und umstimmung_umstimmungs_case.
Wird benutzt von yyparse().
{
tmp_umstimmung -> umstimmung_typ = umstimmung_umstimmungs_case;
tmp_umstimmung -> u.umstimmung_umstimmungs_case
.argument
.argument_typ = parameter;
tmp_umstimmung -> u.umstimmung_umstimmungs_case
.argument
.u.parameter.parameter_name = selector;
/* und test, ob selector als Parameter deklariert ist. */
{
int i = parameter_nummer (0,selector, tmp_umstimmung -> parameter_liste);
if (i == EOF ) {
fatal_error(31,
mutC_STR(selector),
mutC_STR(tmp_umstimmung->name)); /* Parameter n.dekl. */
} else {
tmp_umstimmung -> u.umstimmung_umstimmungs_case
.argument
.u.parameter.parameter_nummer = i;
}
}
tmp_umstimmung -> u.umstimmung_umstimmungs_case
.umstimmungs_case_liste = tmp_umstimmungs_case_liste;
/* check, ob die Parameter zulÑssig sind */
{
struct case_liste * case_lauf;
for (case_lauf = tmp_umstimmung -> u.umstimmung_umstimmungs_case
.umstimmungs_case_liste ;
case_lauf;
case_lauf = case_lauf -> next) {
struct aktions_liste * aktions_lauf;
for (aktions_lauf = case_lauf -> case_aktion;
aktions_lauf;
aktions_lauf = aktions_lauf -> next) {
if (aktions_lauf -> aktions_typ == aktion_aufruf) {
struct argument_liste * argument_lauf;
for (argument_lauf = aktions_lauf -> u.aktion_aufruf.argument_liste;
argument_lauf;
argument_lauf = argument_lauf -> next ) {
if (argument_lauf -> argument.argument_typ == parameter) {
int i = parameter_nummer (0,
argument_lauf->argument.u.parameter.parameter_name,
tmp_umstimmung -> parameter_liste);
if (i == EOF ) {
fatal_error(31,
mutC_STR(argument_lauf->argument.u.parameter.parameter_name),
mutC_STR(tmp_umstimmung -> name)); /* Parameter n.dekl. */
} else {
argument_lauf->argument.u.parameter.parameter_nummer = i;
} /* if */
} /* if */
} /* for argument_lauf */
} /* if (aktions_lauf .. */
} /* for aktions_lauf */
} /* for case_lauf */
}
}
| void get_umstimmung_umstimm_case_zahl | ( | int | selector | ) |
Definiert in Zeile 1775 der Datei Parser.cpp.
Benutzt aktions_liste::aktion_aufruf, aktion_aufruf, argument_liste::argument, argument::argument_typ, fatal_error(), mutC_STR, argument_liste::next, aktions_liste::next, case_liste::next, argument::parameter, parameter, parameter_nummer(), tmp_umstimmungs_case_liste, argument::u, umstimmung::umstimmung_umstimmungs_case, umstimmung_umstimmungs_case und zahl.
Wird benutzt von yyparse().
{
tmp_umstimmung -> umstimmung_typ = umstimmung_umstimmungs_case;
tmp_umstimmung -> u.umstimmung_umstimmungs_case
.argument
.argument_typ = zahl;
tmp_umstimmung -> u.umstimmung_umstimmungs_case
.argument
.u.zahl.zahl = selector;
tmp_umstimmung -> u.umstimmung_umstimmungs_case
.umstimmungs_case_liste = tmp_umstimmungs_case_liste;
/* check, ob die Parameter zulÑssig sind */
{
struct case_liste * case_lauf;
for (case_lauf = tmp_umstimmung -> u.umstimmung_umstimmungs_case
.umstimmungs_case_liste ;
case_lauf;
case_lauf = case_lauf -> next) {
struct aktions_liste * aktions_lauf;
for (aktions_lauf = case_lauf -> case_aktion;
aktions_lauf;
aktions_lauf = aktions_lauf -> next) {
if (aktions_lauf -> aktions_typ == aktion_aufruf) {
struct argument_liste * argument_lauf;
for (argument_lauf = aktions_lauf -> u.aktion_aufruf.argument_liste;
argument_lauf;
argument_lauf = argument_lauf -> next ) {
if (argument_lauf -> argument.argument_typ == parameter) {
int i = parameter_nummer (0,
argument_lauf->argument.u.parameter.parameter_name,
tmp_umstimmung -> parameter_liste);
if (i == EOF ) {
fatal_error(31,
mutC_STR(argument_lauf->argument.u.parameter.parameter_name),
mutC_STR(tmp_umstimmung -> name)); /* Parameter n.dekl. */
} else {
argument_lauf->argument.u.parameter.parameter_nummer = i;
} /* if */
} /* if */
} /* for argument_lauf */
} /* if (aktions_lauf ... */
} /* for aktions_lauf */
} /* for case_lauf */
}
}
| void get_umstimmung_umstimmungs_bund | ( | void | ) |
Definiert in Zeile 1611 der Datei Parser.cpp.
Benutzt aktions_liste::aktion_aufruf, aktion_aufruf, argument_liste::argument, argument::argument_typ, fatal_error(), get_last_aktions_liste(), mutC_STR, argument_liste::next, aktions_liste::next, argument::parameter, parameter, parameter_nummer(), argument::u, aktions_liste::u, umstimmung::umstimmung_umstimmungsbund und umstimmung_umstimmungsbund.
Wird benutzt von yyparse().
{
tmp_umstimmung -> umstimmung_typ = umstimmung_umstimmungsbund;
tmp_umstimmung -> u.umstimmung_umstimmungsbund
.aktions_liste = get_last_aktions_liste ();
/* check, ob die Parameter zulÑssig sind */
{
struct aktions_liste * aktions_lauf;
for (aktions_lauf = tmp_umstimmung -> u.umstimmung_umstimmungsbund.aktions_liste;
aktions_lauf;
aktions_lauf = aktions_lauf -> next) {
if (aktions_lauf -> aktions_typ == aktion_aufruf) {
struct argument_liste * argument_lauf;
for (argument_lauf = aktions_lauf -> u.aktion_aufruf.argument_liste;
argument_lauf;
argument_lauf = argument_lauf -> next ) {
if (argument_lauf -> argument.argument_typ == parameter) {
int i = parameter_nummer (0,
argument_lauf->argument.u.parameter.parameter_name,
tmp_umstimmung -> parameter_liste);
if (i == EOF ) {
fatal_error(31,
mutC_STR(argument_lauf->argument.u.parameter.parameter_name),
mutC_STR(tmp_umstimmung -> name)); /* Parameter n.dekl. */
} else {
argument_lauf->argument.u.parameter.parameter_nummer = i;
} /* if */
} /* if */
} /* for argument_lauf */
} /* if (aktions_lauf... */
} /* for aktions_lauf */
}
}
| void get_umstimmung_wiederholung_abs | ( | void | ) |
Definiert in Zeile 1518 der Datei Parser.cpp.
Benutzt get_last_komplex_intervall(), umstimmung::umstimmung_wiederholung_abs und umstimmung_wiederholung_abs.
Wird benutzt von yyparse().
{
tmp_umstimmung -> umstimmung_typ = umstimmung_wiederholung_abs;
tmp_umstimmung -> u.umstimmung_wiederholung_abs.komplex_liste
= get_last_komplex_intervall ();
}
| void get_umstimmung_wiederholung_abs_negative | ( | void | ) |
Definiert in Zeile 1525 der Datei Parser.cpp.
Benutzt komplex_intervall::faktor, fatal_error(), get_last_komplex_intervall(), umstimmung::umstimmung_wiederholung_abs und umstimmung_wiederholung_abs.
Wird benutzt von yyparse().
{
tmp_umstimmung -> umstimmung_typ = umstimmung_wiederholung_abs;
{
struct komplex_intervall * help = get_last_komplex_intervall ();
if (help == NULL)
fatal_error (0, _T(__FILE__), __LINE__);
help -> faktor *= -1.0;
tmp_umstimmung ->
u.umstimmung_wiederholung_abs.komplex_liste = help;
}
}
| void get_umstimmung_wiederholung_rel_negative | ( | void | ) |
Definiert in Zeile 1550 der Datei Parser.cpp.
Benutzt komplex_intervall::faktor, get_last_komplex_intervall(), umstimmung::umstimmung_wiederholung_rel und umstimmung_wiederholung_rel.
Wird benutzt von yyparse().
{
tmp_umstimmung -> umstimmung_typ = umstimmung_wiederholung_rel;
tmp_umstimmung -> u.umstimmung_wiederholung_rel.
komplex_liste = get_last_komplex_intervall ();
tmp_umstimmung -> u.umstimmung_wiederholung_rel.
komplex_liste -> faktor *= - 1.0 ;
}
| void get_umstimmung_wiederholung_rel_positive | ( | void | ) |
Definiert in Zeile 1543 der Datei Parser.cpp.
Benutzt get_last_komplex_intervall(), umstimmung::umstimmung_wiederholung_rel und umstimmung_wiederholung_rel.
Wird benutzt von yyparse().
{
tmp_umstimmung -> umstimmung_typ = umstimmung_wiederholung_rel;
tmp_umstimmung -> u.umstimmung_wiederholung_rel.
komplex_liste = get_last_komplex_intervall ();
}
| void get_umstimmungs_case_aktions_element | ( | const char * | aktion | ) |
| void get_umstimmungs_case_default_element | ( | void | ) |
Definiert in Zeile 1746 der Datei Parser.cpp.
Benutzt case_liste::case_aktion, case_liste::case_label, get_last_aktions_liste(), case_liste::is_default, case_liste::next und xmalloc().
Wird benutzt von yyparse().
{
struct case_liste * * lauf;
for (lauf= & tmp_umstimmungs_case_liste;
* lauf;
lauf= & (*lauf)->next)
/* Nur Ende der Liste finden */ ;
(* lauf) = (case_liste*) xmalloc (sizeof (struct case_liste));
(* lauf) -> case_label = -1000000; /* als dummy-wert */
(* lauf) -> is_default = 1;
(* lauf) -> case_aktion = get_last_aktions_liste ();
(* lauf) -> next = NULL;
}
| void get_umstimmungs_case_zahl_element | ( | int | konstante | ) |
Definiert in Zeile 1725 der Datei Parser.cpp.
Benutzt case_liste::case_aktion, case_liste::case_label, get_last_aktions_liste(), case_liste::is_default, case_liste::next und xmalloc().
Wird benutzt von yyparse().
{
struct case_liste * * lauf;
for (lauf= & tmp_umstimmungs_case_liste;
* lauf;
lauf= & (*lauf)->next)
/* Nur Ende der Liste finden */ ;
(* lauf) = (case_liste*) xmalloc (sizeof (struct case_liste));
(* lauf) -> case_label = konstante;
(* lauf) -> is_default = 0;
(* lauf) -> case_aktion = get_last_aktions_liste ();
(* lauf) -> next = NULL;
}
| double get_wert_komplex_intervall | ( | struct komplex_intervall * | intervall | ) |
Definiert in Zeile 68 der Datei Interval.cpp.
Benutzt fatal_error(), get_intervall_wert(), mutC_STR, name und intervall::next.
Wird benutzt von berechne_intervall_endgueltig(), berechne_ton_endgueltig(), expandiere_tonsystem() und expandiere_umstimmung().
{
double ret = 1.0;
for ( ; intervall ; intervall = intervall -> next )
{
double help = get_intervall_wert (intervall -> name);
if (help > 0)
ret *= pow (help, intervall -> faktor);
else {
fatal_error(46, mutC_STR(intervall -> name));
/* unzul. Intervallwert */
}
}
return ret;
}
| static int* get_wert_of_argument | ( | struct argument * | argument, |
| struct interpreter_parameter_liste * | aktuelle_parameter | ||
| ) | [static] |
Definiert in Zeile 257 der Datei TabGen.cpp.
Benutzt argument::argument_typ, fatal_error(), get_cache_konstante(), interpreter_parameter_liste::next, argument::parameter, parameter, argument::u, interpreter_parameter_liste::werte_feld, argument::zahl und zahl.
Wird benutzt von expandiere_umstimmung().
{
switch (argument->argument_typ)
{
case zahl:
return * get_cache_konstante (argument->u.zahl.zahl);
/* break; */
case parameter: {
struct interpreter_parameter_liste * lauf;
int i;
for (lauf=aktuelle_parameter, i=argument->u.parameter.parameter_nummer;
lauf && i;
lauf = lauf -> next, i--)
;
if (lauf)
return * lauf->werte_feld;
else {
fatal_error (0, __FILE__, __LINE__);
return NULL;
}
}
/* break; */
default:
fatal_error (0, __FILE__, __LINE__);
return NULL;
/* break; */
}
}
Definiert in Zeile 160 der Datei GrafKern.cpp.
Benutzt boxAktionen, lAktionen, nAktionen und sAktionen.
Wird benutzt von TakeOverAktions().
{
int n = nAktionen;
*box = boxAktionen;
*l = lAktionen;
*s = sAktionen;
nAktionen = 0;
return n;
}
| int GetChannel | ( | int | box, |
| int | taste | ||
| ) |
Definiert in Zeile 554 der Datei Device.cpp.
Benutzt OutDevice::GetChannel(), InDevice::GetDeviceList(), Route::GetNext() und InDevice::GetNext().
Wird benutzt von protokoll_liegende_frequenzen() und MutBoxShape::readDialog().
{
for (InDevice *In = InDevice::GetDeviceList(); In; In = In->GetNext()) {
for (Route *R = In->GetRoutes(); R; R = R->GetNext()) {
OutDevice * out;
if ( R->Box == box && (out = R->GetOutDevice())) {
int c = out->GetChannel(taste);
if ( c != -1 )
return c;
}
}
}
return -1;
}
| wxString getContextLocal | ( | const wxString & | s | ) | [inline] |
Definiert in Zeile 197 der Datei Defs.h.
Wird benutzt von MutApp::MakeFileMenu().
{
wxString ret = s.AfterFirst('|');
if (ret == wxEmptyString) return s;
else return ret;
}
| int pascal GetErrorLine | ( | ) |
Definiert in Zeile 391 der Datei GrafKern.cpp.
Definiert in Zeile 359 der Datei GrafKern.cpp.
Benutzt init_laufzeit_protokoll(), protokoll_liegende_frequenzen(), protokoll_liegende_relationen() und protokoll_string.
Wird benutzt von MutFrame::TextBoxOpen() und MutFrame::UpdateUI().
{
init_laufzeit_protokoll();
if ( asTS )
protokoll_liegende_frequenzen(box);
else
protokoll_liegende_relationen(box);
return protokoll_string;
}
| int pascal GetLineNumbers | ( | ) |
Definiert in Zeile 384 der Datei GrafKern.cpp.
Benutzt protokoll_ausgabezeile.
{
return protokoll_ausgabezeile;
}
Definiert in Zeile 371 der Datei GrafKern.cpp.
Benutzt init_laufzeit_protokoll(), protokoll_aktuelle_relationen(), protokoll_aktuelles_tonsystem() und protokoll_string.
Wird benutzt von MutFrame::TextBoxOpen() und MutFrame::UpdateUI().
{
init_laufzeit_protokoll();
if ( asTS )
protokoll_aktuelles_tonsystem(box);
else
protokoll_aktuelle_relationen(box);
return protokoll_string;
}
| void GlobalReset | ( | ) |
Definiert in Zeile 105 der Datei Execute.cpp.
Benutzt free_tonesystem, MAX_BOX, mut_box, MutResetKeys(), mutabor_box_type::tonesystem und tonesystem_init.
Wird benutzt von Activate() und Stop().
{
for (int i = 0; i < MAX_BOX; i++) {
tonesystem_memory[i] = tonesystem_init;
mut_box[i].tonesystem = tonesystem_memory + i;
}
tonesystem_memory[MAX_BOX] = tonesystem_init;
free_tonesystem = tonesystem_memory+MAX_BOX;
MutResetKeys ();
}
| void HARMONIE_analyse | ( | int | instr, |
| PATTERNN * | pattern | ||
| ) |
| void HarmonyAnalysis | ( | int | box, |
| PATTERNN * | pattern | ||
| ) |
Definiert in Zeile 477 der Datei Execute.cpp.
Benutzt harmonie_ereignis::aktion, TSYS::breite, compare_harmonie(), execute_aktion(), first_harmonie, GET_INDEX, hoechste_taste(), harmonie_ereignis::ist_harmonieform, laufzeit_abstand, laufzeit_zentrum, mut_box, harmonie_ereignis::nachtaste, harmonie_ereignis::next, harmonie_ereignis::pattern, tiefste_taste(), mutabor_box_type::tonesystem und harmonie_ereignis::vortaste.
Wird benutzt von AddKey(), DeleteKey() und execute_aktion().
{
struct harmonie_ereignis *help;
tone_system *tonsys = mut_box[box].tonesystem;
int i;
for (help = first_harmonie[box]; help; help=help->next ) {
switch ( help->ist_harmonieform ) {
case 0: // analysiere auf harmonie
if ( help->vortaste>=0 &&
GET_INDEX(tiefste_taste(box),tonsys ) != help->vortaste ) {
// failed
} else {
if ( help->nachtaste>=0 &&
GET_INDEX(hoechste_taste(box),tonsys)!=help->nachtaste ) {
// failed
} else {
// teste_harmonie
if ( compare_harmonie(tonsys->breite,0,pattern,help->pattern) ) {
// PASST !!!
execute_aktion(box,help->aktion);
return;
}
}
}
break;
case 1: // analysiere auf harmonieform
for (i=0; i<tonsys->breite; i++) {
if ( help->vortaste>=0 &&
GET_INDEX(tiefste_taste(box)-i, tonsys) != help->vortaste ) {
// failed
} else {
if ( help->nachtaste>=0 &&
GET_INDEX(hoechste_taste(box)-i, tonsys) != help->nachtaste ) {
// failed
} else {
// teste_harmonie
if (compare_harmonie(tonsys->breite, i, pattern, help->pattern)) {
// PASST !!!
laufzeit_abstand[box] = laufzeit_zentrum[box] = i;
execute_aktion(box, help->aktion);
return;
}
}
}
}
break;
case 2: // default
execute_aktion(box, help->aktion);
break;
}
}
}
| int hoechste_taste | ( | int | box | ) |
Definiert in Zeile 442 der Datei Execute.cpp.
Benutzt liegende_tasten, liegende_tasten_max und max.
Wird benutzt von HarmonyAnalysis().
{
int i, max = 0;
for (i = 0; i<liegende_tasten_max[box]; i++)
if ( liegende_tasten[box][i] > max )
max = liegende_tasten[box][i];
return max;
}
| void init_aktions_liste | ( | void | ) |
Definiert in Zeile 369 der Datei Parser.cpp.
Wird benutzt von yyparse().
{
list_of_aktionen = NULL;
}
| void init_anweisungs_liste | ( | void | ) |
Definiert in Zeile 2100 der Datei Parser.cpp.
Wird benutzt von yyparse().
{
tmp_anweisungsliste = NULL;
}
| void init_argument_liste | ( | void | ) |
Definiert in Zeile 316 der Datei Parser.cpp.
Wird benutzt von yyparse().
{
list_of_argumente = NULL;
}
| void init_ausloeser | ( | void | ) |
| void init_integersequenz | ( | void | ) |
Definiert in Zeile 223 der Datei Parser.cpp.
Wird benutzt von yyparse().
{
list_of_integers = NULL;
}
| void init_komplex_ton_list | ( | void | ) |
Definiert in Zeile 413 der Datei Parser.cpp.
Wird benutzt von yyparse().
{
the_komplex_liste = NULL;
}
| void init_laufzeit_protokoll | ( | void | ) |
Definiert in Zeile 336 der Datei GrafKern.cpp.
Benutzt protokoll_ausgabezeile und protokoll_string.
Wird benutzt von GetKeyString(), GetTSString(), protokoll_aktuelle_relationen(), protokoll_aktuelles_tonsystem(), protokoll_liegende_frequenzen() und protokoll_liegende_relationen().
{
protokoll_ausgabezeile = 0;
strcpy(protokoll_string, "");
}
| int init_laufzeit_speicher | ( | void | ) |
Definiert in Zeile 348 der Datei Hilfs.cpp.
Benutzt loesche_laufzeit_speicher().
{
return loesche_laufzeit_speicher ();
}
| void init_parameter_liste | ( | void | ) |
| int init_speicher_total | ( | void | ) |
| int init_syntax_speicher | ( | void | ) |
Definiert in Zeile 276 der Datei Hilfs.cpp.
Benutzt loesche_syntax_speicher().
{
return loesche_syntax_speicher ();
}
| void init_tastenliste | ( | void | ) |
Definiert in Zeile 1932 der Datei Parser.cpp.
Wird benutzt von yyparse().
{
tmp_tastenliste = NULL;
}
| void init_ton_liste | ( | void | ) |
| void init_umstimm_expression_list | ( | void | ) |
| void init_umstimmung | ( | const char * | name | ) |
Definiert in Zeile 1234 der Datei Parser.cpp.
Benutzt fatal_error(), mutC_STR, name, umstimmung::next und xmalloc().
Wird benutzt von yyparse().
{
struct umstimmung * lauf;
for (lauf= list_of_umstimmungen; lauf; lauf= lauf -> next) {
if ( ! strcmp (name, lauf -> name)) {
fatal_error(13,mutC_STR(name)); /* Umstimmungsname doppelt */
}
}
tmp_umstimmung = (umstimmung*) xmalloc ((size_t) sizeof (struct umstimmung));
tmp_umstimmung -> name = name;
tmp_umstimmung -> parameter_liste = NULL;
tmp_umstimmung -> next = NULL;
}
| void init_umstimmungs_case_aktions_liste | ( | void | ) |
| void init_umstimmungs_case_liste | ( | void | ) |
Definiert in Zeile 1770 der Datei Parser.cpp.
Wird benutzt von yyparse().
{
tmp_umstimmungs_case_liste = NULL;
}
| void init_yylex | ( | void | ) |
Definiert in Zeile 3142 der Datei mut.cpp.
Benutzt anzahl_eingelesene_zeichen und YYLTYPE::first_line.
Wird benutzt von Compile().
{
yylloc.first_line = 0;
anzahl_eingelesene_zeichen = 0;
}
| void InitCompDia | ( | HWND | compDiaLine | ) |
Definiert in Zeile 181 der Datei GrafKern.cpp.
Benutzt CompDiaLine.
Wird benutzt von Compile().
{
CompDiaLine = compDiaLine;
}
| void insert_in_globale_liste | ( | int | instrument, |
| struct logik * | lauf | ||
| ) |
Definiert in Zeile 823 der Datei TabGen.cpp.
Benutzt midi_ereignis::aktion, keyboard_ereignis::aktion, harmonie_ereignis::aktion, logik::ausloeser, ausloeser::ausloeser_harmonie, ausloeser_harmonie, ausloeser::ausloeser_harmonie_form, ausloeser_harmonie_form, ausloeser::ausloeser_midi_in, ausloeser_midi_in, ausloeser_taste, create_midi_scan_liste(), expand_pattern(), fatal_error(), midi_ereignis::first_pos, harmonie_ereignis::ist_harmonieform, harmonie_ereignis::nachtaste, logik::name, name, midi_ereignis::next, keyboard_ereignis::next, harmonie_ereignis::next, harmonie_ereignis::pattern, midi_ereignis::scan_pos, midi_ereignis::the_logik_to_expand, keyboard_ereignis::the_logik_to_expand, harmonie_ereignis::the_logik_to_expand, ausloeser::u, harmonie_ereignis::vortaste und xmalloc().
Wird benutzt von mutabor_tabellen_generator().
{
struct harmonie_ereignis ** temp_harmonie;
struct keyboard_ereignis ** temp_keyboard;
struct midi_ereignis ** temp_midi;
if (lauf->ausloeser)
{
switch ((lauf->ausloeser)->ausloeser_typ) {
case ausloeser_harmonie:
if (lauf->ausloeser->u.ausloeser_harmonie.vortaste == -2)
/* Dann unmöglicher Harmonieauslöser */
break;
/* Neuen Eintrag erzeugen */
for (temp_harmonie = & first_harmonie[instrument];
*temp_harmonie;
temp_harmonie = & (*temp_harmonie)->next)
;
*temp_harmonie = (harmonie_ereignis*) xmalloc( (size_t)sizeof(struct harmonie_ereignis));
(*temp_harmonie) -> pattern=expand_pattern ((lauf->ausloeser)->u.ausloeser_harmonie.name) ;
(*temp_harmonie) -> ist_harmonieform=0;
(*temp_harmonie) -> vortaste=(lauf->ausloeser)->u.ausloeser_harmonie.vortaste ;
(*temp_harmonie) -> nachtaste=(lauf->ausloeser)->u.ausloeser_harmonie.nachtaste ;
(*temp_harmonie) -> name=lauf->name;
(*temp_harmonie) -> aktion=NULL;
(*temp_harmonie) -> the_logik_to_expand=lauf;
(*temp_harmonie) -> next=NULL;
break;
case ausloeser_harmonie_form:
if (lauf->ausloeser->u.ausloeser_harmonie_form.vortaste == -2)
/* Dann unmöglicher Harmonieauslöser */
break;
/* Neuen Eintrag erzeugen */
for (temp_harmonie = & first_harmonie[instrument];
*temp_harmonie;
temp_harmonie = & (*temp_harmonie)->next)
;
*temp_harmonie = (harmonie_ereignis*) xmalloc((size_t)sizeof(struct harmonie_ereignis));
(*temp_harmonie) -> pattern=expand_pattern ((lauf->ausloeser)->u.ausloeser_harmonie_form.name) ;
(*temp_harmonie) -> ist_harmonieform=1;
(*temp_harmonie) -> vortaste=(lauf->ausloeser)->u.ausloeser_harmonie_form.vortaste ;
(*temp_harmonie) -> nachtaste=(lauf->ausloeser)->u.ausloeser_harmonie_form.nachtaste ;
(*temp_harmonie) -> name=lauf->name;
(*temp_harmonie) -> aktion=NULL;
(*temp_harmonie) -> the_logik_to_expand=lauf;
(*temp_harmonie) -> next=NULL;
break;
case ausloeser_taste:
/* Neuen Eintrag erzeugen */
for (temp_keyboard = & first_keyboard[instrument];
*temp_keyboard;
temp_keyboard = & (*temp_keyboard)->next)
;
*temp_keyboard = (keyboard_ereignis*) xmalloc((size_t)sizeof(struct keyboard_ereignis));
(*temp_keyboard) -> taste= (*((lauf->ausloeser)->u.ausloeser_taste.taste)) ;
(*temp_keyboard) -> name=lauf->name;
(*temp_keyboard) -> aktion=NULL;
(*temp_keyboard) -> the_logik_to_expand=lauf;
(*temp_keyboard) -> next=NULL;
break;
case ausloeser_midi_in:
/* Neuen Eintrag erzeugen */
for (temp_midi = & first_midi[instrument];
*temp_midi;
temp_midi = & (*temp_midi)->next)
;
*temp_midi = (midi_ereignis*) xmalloc((size_t)sizeof(struct midi_ereignis));
/* Werte eintragen */
(*temp_midi) -> first_pos =
(*temp_midi) -> scan_pos =
create_midi_scan_liste (lauf->ausloeser->u.ausloeser_midi_in.midi_code);
(*temp_midi) -> name = lauf->name;
(*temp_midi) -> aktion=NULL;
(*temp_midi) -> the_logik_to_expand=lauf;
(*temp_midi) -> next = NULL;
break;
default:
fatal_error(0, __FILE__, __LINE__);
}
}
}
| void insert_in_lokale_liste | ( | int | instrument, |
| struct anweisung * | lauf, | ||
| const char * | name_der_logik | ||
| ) |
Definiert in Zeile 951 der Datei TabGen.cpp.
Benutzt midi_ereignis::aktion, keyboard_ereignis::aktion, anweisung::aktion, harmonie_ereignis::aktion, anweisung::ausloeser, ausloeser_default, ausloeser::ausloeser_harmonie, ausloeser_harmonie, ausloeser::ausloeser_harmonie_form, ausloeser_harmonie_form, ausloeser::ausloeser_midi_in, ausloeser_midi_in, ausloeser_taste, create_midi_scan_liste(), expand_aktions_liste(), expand_pattern(), fatal_error(), midi_ereignis::first_pos, harmonie_ereignis::ist_harmonieform, harmonie_ereignis::nachtaste, name, midi_ereignis::next, keyboard_ereignis::next, harmonie_ereignis::next, harmonie_ereignis::pattern, midi_ereignis::scan_pos, ausloeser::u, harmonie_ereignis::vortaste und xmalloc().
Wird benutzt von mutabor_tabellen_generator().
{
struct harmonie_ereignis ** temp_harmonie;
struct keyboard_ereignis ** temp_keyboard;
struct midi_ereignis ** temp_midi;
if (lauf->ausloeser)
{
switch ((lauf->ausloeser)->ausloeser_typ) {
case ausloeser_harmonie:
if (lauf->ausloeser->u.ausloeser_harmonie.vortaste == -2)
/* Dann unmöglicher Harmonieauslöser */
break;
/* Neuen Eintrag erzeugen */
for (temp_harmonie = & first_lokal_harmonie[instrument];
*temp_harmonie;
temp_harmonie = & (*temp_harmonie)->next)
;
*temp_harmonie = (harmonie_ereignis*) xmalloc( (size_t)sizeof(struct harmonie_ereignis));
(*temp_harmonie) -> pattern =expand_pattern ((lauf->ausloeser)->u.ausloeser_harmonie.name) ;
(*temp_harmonie) -> ist_harmonieform=0;
(*temp_harmonie) -> vortaste=(lauf->ausloeser)->u.ausloeser_harmonie.vortaste ;
(*temp_harmonie) -> nachtaste=(lauf->ausloeser)->u.ausloeser_harmonie.nachtaste ;
(*temp_harmonie) -> name=name_der_logik;
(*temp_harmonie) -> aktion=
expand_aktions_liste (lauf->aktion, start_parameter_liste);
(*temp_harmonie) -> next=NULL;
break;
case ausloeser_harmonie_form:
if (lauf->ausloeser->u.ausloeser_harmonie_form.vortaste == -2)
/* Dann unmöglicher Harmonieauslöser */
break;
/* Neuen Eintrag erzeugen */
for (temp_harmonie = & first_lokal_harmonie[instrument];
*temp_harmonie;
temp_harmonie = & (*temp_harmonie)->next)
;
*temp_harmonie = (harmonie_ereignis*) xmalloc((size_t)sizeof(struct harmonie_ereignis));
(*temp_harmonie) -> pattern=expand_pattern ((lauf->ausloeser)->u.ausloeser_harmonie_form.name) ;
(*temp_harmonie) -> ist_harmonieform=1;
(*temp_harmonie) -> vortaste=(lauf->ausloeser)->u.ausloeser_harmonie_form.vortaste ;
(*temp_harmonie) -> nachtaste=(lauf->ausloeser)->u.ausloeser_harmonie_form.nachtaste ;
(*temp_harmonie) -> name=name_der_logik;
(*temp_harmonie) -> aktion=
expand_aktions_liste (lauf->aktion, start_parameter_liste);
(*temp_harmonie) -> next=NULL;
break;
case ausloeser_default:
/* Neuen Eintrag erzeugen */
for (temp_harmonie = & first_lokal_harmonie[instrument];
*temp_harmonie;
temp_harmonie = & (*temp_harmonie)->next)
;
*temp_harmonie = (harmonie_ereignis*) xmalloc((size_t)sizeof(struct harmonie_ereignis));
(*temp_harmonie) -> pattern=NULL ;
(*temp_harmonie) -> ist_harmonieform=2;
/* 2 als Wert für ANSONSTEN */
(*temp_harmonie) -> vortaste=0 ;
(*temp_harmonie) -> nachtaste=0 ;
(*temp_harmonie) -> name=name_der_logik;
(*temp_harmonie) -> aktion=
expand_aktions_liste (lauf->aktion, start_parameter_liste);
(*temp_harmonie) -> next=NULL;
break;
case ausloeser_taste:
/* Neuen Eintrag erzeugen */
for (temp_keyboard = & first_lokal_keyboard[instrument];
*temp_keyboard;
temp_keyboard = & (*temp_keyboard)->next)
;
*temp_keyboard = (keyboard_ereignis*) xmalloc((size_t)sizeof(struct keyboard_ereignis));
(*temp_keyboard) -> taste= (*((lauf->ausloeser)->u.ausloeser_taste.taste)) ;
(*temp_keyboard) -> name=name_der_logik;
(*temp_keyboard) -> aktion=
expand_aktions_liste (lauf->aktion, start_parameter_liste);
(*temp_keyboard) -> next=NULL;
break;
case ausloeser_midi_in:
/* Neuen Eintrag erzeugen */
for (temp_midi = & first_lokal_midi[instrument];
*temp_midi;
temp_midi = & (*temp_midi)->next)
;
*temp_midi = (midi_ereignis*) xmalloc((size_t)sizeof(struct midi_ereignis));
/* Werte eintragen */
(*temp_midi) -> first_pos =
(*temp_midi) -> scan_pos =
create_midi_scan_liste (lauf->ausloeser->u.ausloeser_midi_in.midi_code);
(*temp_midi) -> name=name_der_logik;
(*temp_midi) -> aktion=
expand_aktions_liste (lauf->aktion, start_parameter_liste);
(*temp_midi) -> next = NULL;
break;
default:
fatal_error(0, __FILE__, __LINE__);
}
}
}
| int intern_fgetc | ( | FILE * | stream | ) |
Definiert in Zeile 45 der Datei Hilfs.cpp.
Benutzt DEBUGLOG2, is_valid und the_character.
Wird benutzt von yylex().
{
int zeichen;
if (is_valid) {
is_valid = 0;
DEBUGLOG2(other,_T("old character: %x"),the_character);
return the_character;
}
zeichen = fgetc(stream);
DEBUGLOG2(other,_T("new character: %x, EOF %d"),zeichen,feof(stream));
return zeichen;
}
| int intern_ungetc | ( | int | c, |
| FILE * | stream | ||
| ) |
Definiert in Zeile 62 der Datei Hilfs.cpp.
Benutzt is_valid, SeRiEnNuMmEr und the_character.
Wird benutzt von yylex().
{
SeRiEnNuMmEr[0] = the_character;
is_valid = 1;
the_character = c;
return 0;
}
| void KEYB_analyse | ( | int | key | ) |
| void keyboard_analyse | ( | int | taste | ) |
Definiert in Zeile 620 der Datei Execute.cpp.
Benutzt aktuelle_keyboard_box und KeyboardAnalyseSimple().
| void pascal _export KeyboardAnalyse | ( | int | box, |
| int | taste, | ||
| char | isLogic | ||
| ) |
Definiert in Zeile 611 der Datei Execute.cpp.
Benutzt execute_aktion(), first_keyboard und keyboard_ereignis::next.
Wird benutzt von KeyboardIn() und MutLogicWnd::UpDate().
{
for (struct keyboard_ereignis *help = first_keyboard[box]; help ; help=help->next)
if ( toupper(taste)==help->taste && isLogic == ( help->the_logik_to_expand != NULL ) ) {
execute_aktion(box, help->aktion);
return;
}
}
| void pascal _export KeyboardAnalyseSimple | ( | int | box, |
| int | taste | ||
| ) |
Definiert in Zeile 625 der Datei Execute.cpp.
Benutzt execute_aktion(), first_keyboard und keyboard_ereignis::next.
Wird benutzt von keyboard_analyse() und KeyboardIn().
{
for (struct keyboard_ereignis *help = first_keyboard[box]; help ; help=help->next)
if ( toupper(taste)==help->taste ) {
execute_aktion(box, help->aktion);
return;
}
}
| void KeyboardIn | ( | int | box, |
| const mutChar * | keys | ||
| ) |
Definiert in Zeile 567 der Datei Execute.cpp.
Benutzt aktuelle_keyboard_box, KeyboardAnalyse(), KeyboardAnalyseSimple(), mutChar, mutStrLen und mutT.
Wird benutzt von MutaborTag().
{
aktuelle_keyboard_box = box;
char TonSystem = 0;
for (size_t i= 0; i < mutStrLen(keys); i++) {
mutChar c = keys[i];
if ( c == mutT('&') ) {
TonSystem = 1;
continue;
}
if ( mutT('0') <= c && c <= mutT('z') ) {
if ( TonSystem )
KeyboardAnalyse(box, (int) c, 0);
else
KeyboardAnalyseSimple(box, (int) c);
}
TonSystem = 0;
}
}
| void laufzeit_message | ( | const char * | Meldung | ) |
Definiert in Zeile 325 der Datei GrafKern.cpp.
Benutzt PROT_MAXCHARS, protokoll_ausgabezeile und protokoll_string.
Wird benutzt von laufzeit_protokoll().
{
if ( strlen(protokoll_string) + strlen(Meldung) <= PROT_MAXCHARS - 2 ) {
if ( protokoll_ausgabezeile ) strcat(protokoll_string, "\n");
strcat(protokoll_string, Meldung);
protokoll_ausgabezeile++;
}
}
| void laufzeit_protokoll | ( | const char * | formatstring, |
| ... | |||
| ) |
Definiert in Zeile 347 der Datei GrafKern.cpp.
Benutzt Fmeldung und laufzeit_message().
Wird benutzt von protokoll_aktuelle_relationen(), protokoll_aktuelles_tonsystem(), protokoll_liegende_frequenzen() und protokoll_liegende_relationen().
{
char Fmeldung[255];
va_list arglist;
va_start(arglist, formatstring); /* hier 0 statt nr */
vsprintf(Fmeldung, formatstring, arglist );
laufzeit_message (Fmeldung);
}
| int loesche_laufzeit_speicher | ( | void | ) |
Definiert in Zeile 353 der Datei Hilfs.cpp.
Benutzt laufzeit_heap, mini_heap::next und mini_heap::pointer.
Wird benutzt von init_laufzeit_speicher().
{
struct mini_heap * lauf = laufzeit_heap;
while (lauf) {
struct mini_heap * help = lauf;
#ifdef ACS_VERSION
Ax_ifree (lauf -> pointer);
#else
free (lauf -> pointer);
#endif
lauf = lauf -> next;
#ifdef ACS_VERSION
Ax_ifree (help);
#else
free (help);
#endif
}
laufzeit_heap = NULL;
return 0; /* 0=ok, 1=fehler */
}
| int loesche_speicher_total | ( | void | ) |
| int loesche_syntax_speicher | ( | void | ) |
Definiert in Zeile 253 der Datei Hilfs.cpp.
Benutzt heap_element::next und syntax_heap.
Wird benutzt von Compile() und init_syntax_speicher().
{
struct heap_element * lauf = syntax_heap;
while (lauf) {
struct heap_element * help = lauf->next;
#ifdef ACS_VERSION
Ax_ifree (lauf);
#else
free (lauf);
#endif
lauf = help;
}
syntax_heap = NULL;
heap_to_use_syntax = NULL;
return 0; /* 0=ok, 1=fehler */
}
| int logik_list_laenge | ( | struct logik * | list | ) |
Definiert in Zeile 110 der Datei Parser.cpp.
Benutzt ton::next.
Wird benutzt von calc_declaration_numbers(), check_konsistenz() und mutabor_tabellen_generator().
{
if (list) return 1 + logik_list_laenge (list -> next);
return 0;
}
| tone_system* lz_get_tonsystem | ( | int | instr | ) |
| void MAUS_analyse | ( | int | mx, |
| int | my | ||
| ) |
| void message_tasten_liste | ( | void | ) |
| void MIDI_analyse | ( | int | code | ) |
| int midi_list_laenge | ( | struct midiliste * | list | ) |
Definiert in Zeile 117 der Datei Parser.cpp.
Benutzt ton::next.
Wird benutzt von create_midi_scan_liste().
{
if (list) return 1 + midi_list_laenge (list -> next);
return 0;
}
| void MidiAnalysis | ( | int | box, |
| BYTE | midiByte | ||
| ) |
Definiert in Zeile 590 der Datei Execute.cpp.
Benutzt midi_ereignis::aktion, execute_aktion(), first_midi, midi_ereignis::first_pos, midi_ereignis::next und midi_ereignis::scan_pos.
Wird benutzt von InMidiPort::ProceedRoute() und InMidiFile::ProceedRoute().
{
struct midi_ereignis * lauf;
if ( midiByte & 0x80 )
midiByte &= 0xF0;
for (lauf = first_midi[box]; lauf; lauf=lauf->next) {
if ( *(lauf->scan_pos) != midiByte )
lauf->scan_pos = lauf->first_pos;
else {
lauf->scan_pos++;
if ( *(lauf->scan_pos) == -1 )
break;
}
}
if ( lauf )
execute_aktion( box, lauf->aktion);
}
| void MidiOut | ( | int | box, |
| DWORD | data, | ||
| char | n | ||
| ) |
Definiert in Zeile 536 der Datei Device.cpp.
Benutzt InDevice::GetDeviceList(), Route::GetNext(), InDevice::GetNext() und MidiOut().
Wird benutzt von execute_aktion(), MidiOut() und compat30::SaveRoutes().
| void mutabor_codegenerator | ( | const char * | filename | ) |
| void mutabor_programm_einlesen | ( | const wxChar * | filename | ) |
Wird benutzt von Compile().
| void mutabor_programm_einlesen | ( | const mutChar * | filename | ) |
Definiert in Zeile 567 der Datei Parser.cpp.
Benutzt anweisung::aktion, logik::anweisungsliste, argument_liste::argument, aktions_liste::argument_liste, anweisung::ausloeser, logik::ausloeser, berechne_intervalle_absolut(), berechne_toene_absolut(), case_liste::case_label, check_konsistenz(), logik::einstimmungs_name, fatal_error(), get_instrument_dekl(), get_new_intervall(), get_new_ton_absolut(), intervall::intervall_wert, case_liste::is_default, list_of_config_instrumente, instrument::midi_bis, instrument::midi_in, instrument::midi_von, logik::name, aktions_liste::name, parameter_liste::name, umstimmung::name, ton::name, tonsystem::name, intervall::name, instrument::next, anweisung::next, logik::next, harmonie::next, case_liste::next, argument_liste::next, aktions_liste::next, parameter_liste::next, umstimmung::next, tonsystem::next, ton::next, intervall::next, umstimmung::parameter_liste, tonsystem::periode, setze_nummer_von_abstand_und_zentrum(), tonsystem::taste, tonsystem::toene, ton_list_laenge(), umstimmung::u, ton::u, umstimmung::umstimmung_breite_abs, umstimmung_breite_abs, umstimmung::umstimmung_breite_rel, umstimmung_breite_rel, umstimmung::umstimmung_taste_abs, umstimmung_taste_abs, umstimmung::umstimmung_taste_rel, umstimmung_taste_rel, umstimmung_toene_veraendert, umstimmung::umstimmung_umstimmungs_case, umstimmung_umstimmungs_case, umstimmung::umstimmung_umstimmungsbund, umstimmung_umstimmungsbund, umstimmung_wiederholung_abs, umstimmung_wiederholung_rel und yyparse().
{
if ((quelldatei = wxFopen (filename, _T("r"))) == NULL) {
fatal_error(3,filename);
}
list_of_intervalle = NULL;
list_of_toene = NULL;
list_of_tonsysteme = NULL;
list_of_umstimmungen = NULL;
list_of_harmonien = NULL;
list_of_logiken = NULL;
list_of_instrumente = NULL;
list_of_config_instrumente = NULL;
#ifdef DEBUG_ANZEIGE
printf ("\nStart parsing\n");
#endif
if (yyparse()) {
fatal_error(1,-999); /* Wird sowieso nie aufgerufen ... */
}
fclose (quelldatei);
// NEU: wenn kein Intervall oder Ton da, dann Speichermangel
// also evtl. Dummy
// (das Problem l‰flt sich sicher auch direkt lˆsen ...)
if ( !list_of_intervalle )
get_new_intervall("__TopSecret__RK__Intervall__", 1.0);
berechne_intervalle_absolut (list_of_intervalle);
if ( !list_of_toene )
get_new_ton_absolut("__TopSecret__RK__Ton__", 440.0);
berechne_toene_absolut (list_of_toene);
/* Falls kein Instrument angegeben ist: Dann 1 -> 1-16 */
if (list_of_instrumente == NULL &&
list_of_config_instrumente == NULL) {
get_instrument_dekl (1, 1, 16, 0, & list_of_instrumente);
} else if (list_of_instrumente == NULL) {
list_of_instrumente = list_of_config_instrumente;
}
setze_nummer_von_abstand_und_zentrum ();
check_konsistenz ();
#ifdef DEBUG_ANZEIGE
{ struct intervall * lauf;
printf ("\n");
for (lauf=list_of_intervalle; lauf; lauf=lauf->next) {
printf ("Name: %s, Wert: %lf:\n", lauf->name,
lauf->intervall_wert );
}
}
{ struct ton * lauf;
printf ("\n");
for (lauf=list_of_toene; lauf; lauf=lauf->next) {
drucke_ton (lauf);
}
}
{ struct tonsystem * lauf;
printf ("\n");
for (lauf=list_of_tonsysteme; lauf; lauf=lauf->next) {
struct ton * help;
printf ("Name: %s, Taste: %d, Periode: %s, "
"Tonleiter_breite: %d\n",
lauf->name,
lauf->taste,
lauf->periode,
ton_list_laenge (lauf->toene));
for (help = lauf->toene; help; help = help->next ) {
printf ("%s , ", help->name ? help->name : "(NULL)");
}
printf ("\n");
}
}
printf ("Umstimmungen:\n");
{
struct umstimmung * lauf;
printf ("\n");
for (lauf=list_of_umstimmungen; lauf; lauf=lauf->next) {
struct parameter_liste * help;
printf ("\nName: %s, Parameter: ", lauf->name);
for (help = lauf->parameter_liste; help; help = help->next ) {
printf ("%s , ", help->name ? help->name : "(NULL)");
}
printf ("\n");
switch (lauf -> umstimmung_typ) {
case umstimmung_taste_abs :
printf (" umstimmung_taste_abs : ");
drucke_argument (
& lauf -> u.umstimmung_taste_abs.argument);
printf ("\n");
break;
case umstimmung_taste_rel :
printf (" umstimmung_taste_rel : ");
drucke_argument (
& lauf -> u.umstimmung_taste_rel.argument);
printf (" Rechenzeichen: \"%c\"\n",
lauf -> u.umstimmung_taste_rel.rechenzeichen);
break;
case umstimmung_breite_abs :
printf (" umstimmung_breite_abs : ");
drucke_argument (
& lauf -> u.umstimmung_breite_abs.argument);
printf ("\n");
break;
case umstimmung_breite_rel :
printf (" umstimmung_breite_rel : ");
drucke_argument (
& lauf -> u.umstimmung_breite_rel.argument);
printf (" Rechenzeichen: \"%c\"\n",
lauf -> u.umstimmung_breite_rel.rechenzeichen);
break;
case umstimmung_toene_veraendert : {
struct ton * help;
printf (" umstimmung_toene_veraendert : \n");
for (help = lauf -> u.umstimmung_toene_veraendert.tonliste;
help;
help = help -> next) {
printf (" ");
drucke_ton (help);
}
break;
}
case umstimmung_wiederholung_abs :
printf (" umstimmung_wiederholung_abs :");
printf ("Name : %s \n",
lauf -> u.umstimmung_wiederholung_abs.name);
break;
case umstimmung_wiederholung_rel :
printf (" umstimmung_wiederholung_rel : ");
drucke_argument (
& lauf -> u.umstimmung_wiederholung_rel.argument);
printf (" R-zeichen: \"%c\"\n",
lauf -> u.umstimmung_wiederholung_rel.rechenzeichen);
break;
case umstimmung_umstimmungsbund : {
struct aktions_liste * help_umst;
printf (" umstimmung_umstimmungsbund : \n");
print_aktions_liste (lauf->u.umstimmung_umstimmungsbund.aktions_liste);
for (help_umst = lauf->u.umstimmung_umstimmungsbund.aktions_liste;
help_umst;
help_umst = help_umst -> next ) {
struct argument_liste * help;
printf (" Umstimmungs-name: %s, Parameter: ",
help_umst->name ? help_umst->name : "(NULL)");
for (help = help_umst->argument_liste; help; help = help->next ) {
drucke_argument ( & help -> argument );
}
printf ("\n");
}
}
break;
case umstimmung_umstimmungs_case : {
struct case_liste * help_case;
printf (" umstimmung_umstimmungs_case : \n");
drucke_argument (
& lauf -> u.umstimmung_umstimmungs_case.argument);
for (help_case = lauf -> u.umstimmung_umstimmungs_case.umstimmungs_case_liste;
help_case;
help_case = help_case -> next) {
struct aufruf_liste * help_umst;
if (help_case->is_default)
printf ("(ANSONSTEN)");
else
printf ("%lf ", help_case->case_label);
for (help_umst = help_case->case_aufruf;
help_umst;
help_umst = help_umst -> next ) {
struct argument_liste * help;
printf (" Aktions-name: %s, Parameter: ",
help_umst->name ? help_umst->name : "(NULL)");
for (help = help_umst->argument_liste; help; help = help->next ) {
drucke_argument ( & help->argument);
}
printf ("\n");
}
}
}
break;
} /* end of switch */
}
}
printf ("\nHarmonien:\n");
{
struct harmonie * lauf;
for (lauf=list_of_harmonien; lauf; lauf=lauf->next) {
printf ("\n");
drucke_harmonie (lauf);
printf ("\n");
}
}
printf ("\nLogiken:\n");
{
struct logik * lauf;
for (lauf=list_of_logiken; lauf; lauf=lauf->next) {
struct anweisung * anw_lauf;
print_ausloeser (lauf->ausloeser);
printf ("\nName: %s Einstimmung : %s\n",
lauf->name,
lauf->einstimmungs_name ?
lauf->einstimmungs_name :
"(NULL)");
for (anw_lauf = lauf->anweisungsliste;
anw_lauf;
anw_lauf = anw_lauf -> next) {
print_ausloeser (anw_lauf->ausloeser);
print_aktion (anw_lauf->aktion);
}
}
}
printf ("\nInstrumente:\n");
{
struct instrument * lauf;
for (lauf=list_of_instrumente; lauf; lauf=lauf->next) {
printf ("Instrument %d -> %d - %d\n", lauf->midi_in,
lauf->midi_von, lauf->midi_bis);
}
}
#endif
}
| void mutabor_tabellen_generator | ( | void | ) |
Definiert in Zeile 1206 der Datei TabGen.cpp.
Benutzt logik::anweisungsliste, expandiere_in_globale_liste(), get_ende_harmonie(), get_ende_keyboard(), get_ende_midi(), insert_in_globale_liste(), insert_in_lokale_liste(), list_of_logiken, logik_list_laenge(), MAX_BOX, logik::name, logik::next, anweisung::next und xcalloc().
Wird benutzt von Compile().
{
//Neu: extra Löschungen
cache_konstanten = NULL;
/* Ausgabe der Pointer-Setz-Prozeduren */
struct logik * lauf;
struct anweisung * lauf_anweisung;
int i;
for (i=0; i<MAX_BOX; i++) {
first_midi [i] = NULL;
first_keyboard [i] = NULL;
first_harmonie [i] = NULL;
}
for (i=0;i<MAX_BOX;i++) {
/* Die globalen Listen werden initialisiert: */
/* Die globalen Auslöser werden in die vorbereiteten Listen eingetragen: */
for (lauf = list_of_logiken; lauf; lauf = lauf -> next) {
insert_in_globale_liste (i, lauf);
}
last_global_harmonie[i]=get_ende_harmonie (& first_harmonie[i]);
last_global_keyboard[i]=get_ende_keyboard (& first_keyboard[i]);
last_global_midi[i]=get_ende_midi (& first_midi[i]);
}
/* Die lokalen Listen werden erzeugt: */
/* Es wird ein Array mit Anfangszeigern auf die lokalen
Auslöser angelegt. Die Nummer der Logik ist index */
i = logik_list_laenge (list_of_logiken);
first_lokal_harmonie = (harmonie_ereignis* *) xcalloc ((size_t)i, sizeof(first_lokal_harmonie[0]));
first_lokal_keyboard = (keyboard_ereignis* *) xcalloc ((size_t)i, sizeof(first_lokal_keyboard[0]));
first_lokal_midi = (midi_ereignis* *) xcalloc ((size_t)i, sizeof(first_lokal_midi[0]));
/* #### Wichtig ist, daß calloc alles auf 0 setzt (NULL) */
for (lauf=list_of_logiken, i=0;
lauf;
lauf=lauf->next, i++ ) {
for (lauf_anweisung=lauf->anweisungsliste; lauf_anweisung;
lauf_anweisung=lauf_anweisung->next) {
insert_in_lokale_liste (i, lauf_anweisung, lauf->name);
}
}
expandiere_in_globale_liste ();
} /* end of mutabor_tabellen_generator */
| void MutResetKeys | ( | ) |
Definiert in Zeile 80 der Datei Execute.cpp.
Benutzt keys_changed, keys_changed_sum, last_global_harmonie, last_global_keyboard, last_global_midi, liegende_tasten_max, logic_changed, MAX_BOX, MAX_BREITE und mut_box.
Wird benutzt von GlobalReset() und Panic().
{
for (int i = 0; i<MAX_BOX; i++) {
if ( last_global_harmonie[i] && *last_global_harmonie[i] )
*last_global_harmonie[i] = NULL;
if ( last_global_keyboard[i] && *last_global_keyboard[i] )
*last_global_keyboard[i] = NULL;
if ( last_global_midi[i] && *last_global_midi[i] )
*last_global_midi[i]=NULL;
liegende_tasten_max[i] = 0;
for (int j = 0; j < MAX_BREITE; j++)
mut_box[i].pattern.tonigkeit[j] = 0;
keys_changed[i] = 0;
logic_changed[i] = 0;
}
keys_changed_sum = 0;
}
| void NotesCorrect | ( | int | box | ) |
Definiert in Zeile 548 der Datei Device.cpp.
Benutzt OutDevice::GetDeviceList() und OutDevice::GetNext().
Wird benutzt von execute_aktion().
{
for (OutDevice *Out = OutDevice::GetDeviceList(); Out; Out = Out->GetNext())
Out->NotesCorrect(box);
}
| int frac::operator!= | ( | const frac & | f | ) |
Definiert in Zeile 129 der Datei Frac.cpp.
Benutzt frac::d, frac::frac(), frac::gcd() und frac::n.
| int frac::operator< | ( | const frac & | f | ) |
| int frac::operator<= | ( | const frac & | f | ) |
| frac & frac::operator= | ( | const int & | i | ) |
| int frac::operator== | ( | const frac & | f | ) |
| int frac::operator> | ( | const frac & | f | ) |
| int frac::operator>= | ( | const frac & | f | ) |
| int parameter_list_laenge | ( | struct parameter_liste * | list | ) |
Definiert in Zeile 136 der Datei Parser.cpp.
Benutzt ton::next.
Wird benutzt von check_aktionen() und check_konsistenz().
{
if (list) return 1 + parameter_list_laenge (list -> next);
return 0;
}
| static int parameter_nummer | ( | int | aktueller_index, |
| const char * | such_name, | ||
| struct parameter_liste * | knoten | ||
| ) | [static] |
Definiert in Zeile 284 der Datei Parser.cpp.
Benutzt name und parameter_liste::next.
Wird benutzt von get_umstimmung_breite_abs(), get_umstimmung_breite_rel(), get_umstimmung_taste_abs(), get_umstimmung_taste_rel(), get_umstimmung_umstimm_case_parameter(), get_umstimmung_umstimm_case_zahl() und get_umstimmung_umstimmungs_bund().
{
if (knoten == NULL) return EOF;
if ( ! strcmp (such_name, knoten -> name))
return aktueller_index;
return parameter_nummer (aktueller_index + 1, such_name,
knoten -> next);
}
Definiert in Zeile 175 der Datei Parser.cpp.
Benutzt tonsystem::name und tonsystem::next.
Wird benutzt von check_aktionen(), check_konsistenz(), expandiere_logik() und expandiere_name().
{
if (liste == NULL) return NULL;
if ( ! strcmp (name, liste->name)) return liste;
return parser_get_tonsystem (name, liste->next);
}
| void print_argumentliste | ( | struct argument_liste * | this_ | ) |
Definiert in Zeile 297 der Datei Parser.cpp.
Benutzt argument::argument_typ, parameter_liste::next, argument::parameter, argument::u, argument::zahl und zahl.
| void print_integersequenz | ( | struct midiliste * | this_ | ) |
Definiert in Zeile 941 der Datei Parser.cpp.
Benutzt midiliste::midi_code und midiliste::next.
{
if (this_)
{
printf (" %d ",this_->midi_code);
print_integersequenz (this_->next);
}
}
| void protokoll_aktion | ( | const char * | name | ) |
| void protokoll_aktuelle_relationen | ( | int | box | ) |
Definiert in Zeile 697 der Datei Execute.cpp.
Benutzt TSYS::breite, exit_laufzeit_protokoll(), init_laufzeit_protokoll(), laufzeit_protokoll(), LONG_TO_CENT, mut_box, TSYS::ton und mutabor_box_type::tonesystem.
Wird benutzt von GetTSString().
{
tone_system * tonsys = mut_box[box].tonesystem;
int i,j;
init_laufzeit_protokoll();
for (i=0;i<tonsys->breite && tonsys->ton[i]==0;i++);
/* sucht erstes Intervall != 0 */
laufzeit_protokoll("Reference [%d]",i);
for (j=i+1;j<tonsys->breite; j++) {
if (tonsys->ton[j]!=0) {
laufzeit_protokoll("%2d:%.1f cent",j,
LONG_TO_CENT( tonsys->ton[j] -
tonsys->ton[i] ) );
} else {
laufzeit_protokoll("%2d:%%",j);
}
}
exit_laufzeit_protokoll( );
}
| void protokoll_aktuelles_tonsystem | ( | int | box | ) |
Definiert in Zeile 637 der Datei Execute.cpp.
Benutzt TSYS::anker, TSYS::breite, exit_laufzeit_protokoll(), init_laufzeit_protokoll(), laufzeit_protokoll(), LONG_TO_CENT, LONG_TO_HERTZ, mut_box, TSYS::periode, TSYS::ton, mutabor_box_type::tonesystem und zugriff.
Wird benutzt von GetTSString().
{
tone_system * tonsys = mut_box[box].tonesystem;
long freq;
unsigned char * zugriff = (unsigned char*) & freq;
int i;
init_laufzeit_protokoll();
// laufzeit_protokoll("Tonsystem: (#%d)",box);
laufzeit_protokoll("Anker= %d",tonsys->anker);
laufzeit_protokoll("Breite= %d",tonsys->breite);
laufzeit_protokoll("Periode= %.1f cent",
LONG_TO_CENT(tonsys->periode));
for (i=0;i<tonsys->breite;i++) {
if ( (freq=tonsys->ton[i])!=0) {
laufzeit_protokoll("%2d : %.1f Hz (%.2f)",
i, LONG_TO_HERTZ(tonsys->ton[i]) ,
(zugriff[3]+(((float)zugriff[2])/256.0)) );
} else {
laufzeit_protokoll("%2d : %%",i);
}
}
exit_laufzeit_protokoll( );
}
| void protokoll_liegende_frequenzen | ( | int | box | ) |
Definiert in Zeile 664 der Datei Execute.cpp.
Benutzt bcopy, exit_laufzeit_protokoll(), GET_FREQ, GetChannel(), init_laufzeit_protokoll(), laufzeit_protokoll(), liegende_tasten, liegende_tasten_max, LONG_TO_HERTZ, mut_box, mutabor_box_type::tonesystem und zugriff.
Wird benutzt von GetKeyString().
{
tone_system * tonsys = mut_box[box].tonesystem;
int i, imax, lts[64], lt;
long freq;
unsigned char * zugriff = (unsigned char*) & freq;
imax = liegende_tasten_max[box];
bcopy(liegende_tasten[box], lts, imax*sizeof(int));
init_laufzeit_protokoll();
for (i = 0; i < imax; i++) {
lt = lts[i];
if ( (freq=GET_FREQ( lt ,tonsys ))!=0) {
#ifndef SHOW_CHANNEL
laufzeit_protokoll("%2d : %8.1f Hz (%6.2f)",
lt,
LONG_TO_HERTZ(freq),
(zugriff[3]+(((float)zugriff[2])/256.0)) );
#else
laufzeit_protokoll("%2d : %8.1f Hz (%6.2f)[ch: %d]",
lt,
LONG_TO_HERTZ(freq),
(zugriff[3]+(((float)zugriff[2])/256.0)), GetChannel(box, lt));
#endif
} else {
laufzeit_protokoll("%2d : %%",lt);
}
}
exit_laufzeit_protokoll();
}
| void protokoll_liegende_relationen | ( | int | box | ) |
Definiert in Zeile 721 der Datei Execute.cpp.
Benutzt exit_laufzeit_protokoll(), GET_FREQ, init_laufzeit_protokoll(), laufzeit_protokoll(), liegende_tasten, liegende_tasten_max, LONG_TO_CENT, mut_box und mutabor_box_type::tonesystem.
Wird benutzt von GetKeyString().
{
tone_system * tonsys = mut_box[box].tonesystem;
int i;
init_laufzeit_protokoll();
// laufzeit_protokoll("Liegende Relationen (#%d):",box);
for (i=0;i<(liegende_tasten_max[box]-1);i++) {
if ( (GET_FREQ( liegende_tasten[box][i+1] , tonsys )) !=0 ) {
laufzeit_protokoll("%.2f cent",
LONG_TO_CENT( GET_FREQ(liegende_tasten[box][i+1], tonsys ) -
GET_FREQ(liegende_tasten[box][i], tonsys) ));
} else {
laufzeit_protokoll(" %%");
}
}
exit_laufzeit_protokoll( );
}
| void scanner_protokoll | ( | int | zeichen | ) |
| void setze_nummer_von_abstand_und_zentrum | ( | void | ) |
Definiert in Zeile 474 der Datei Parser.cpp.
Benutzt anweisung::aktion, aktions_liste::aktion_aufruf, aktion_aufruf, aktions_liste::aktions_typ, logik::anweisungsliste, argument_liste::argument, argument::argument_typ, fatal_error(), mutC_STR, logik::name, argument_liste::next, anweisung::next, logik::next, argument::parameter, parameter, argument::u, aktions_liste::u und zahl.
Wird benutzt von mutabor_programm_einlesen().
{
struct logik * lauf;
for (lauf=list_of_logiken; lauf; lauf=lauf->next) {
struct anweisung * lauf_anw;
for (lauf_anw=lauf->anweisungsliste; lauf_anw; lauf_anw=lauf_anw->next) {
if (lauf_anw->aktion->aktions_typ == aktion_aufruf) {
struct argument_liste * lauf_arg;
for (lauf_arg=lauf_anw->aktion->u.aktion_aufruf.argument_liste;
lauf_arg;
lauf_arg=lauf_arg->next) {
switch (lauf_arg->argument.argument_typ) {
case zahl:
/* OK */
break;
case parameter:
if ( ! strcmp (lauf_arg->argument.u.parameter.parameter_name,
"ABSTAND")) {
lauf_arg->argument.u.parameter.parameter_nummer
= 0;
} else
if ( ! strcmp (lauf_arg->argument.u.parameter.parameter_name,
"DISTANCE")) {
lauf_arg->argument.u.parameter.parameter_nummer
= 0;
} else
if ( ! strcmp (lauf_arg->argument.u.parameter.parameter_name,
"ZENTRUM")) {
lauf_arg->argument.u.parameter.parameter_nummer
= 1;
} else
if ( ! strcmp (lauf_arg->argument.u.parameter.parameter_name,
"CENTER")) {
lauf_arg->argument.u.parameter.parameter_nummer
= 1;
} else
fatal_error (39,
mutC_STR(lauf_arg->argument.u.parameter.parameter_name),
mutC_STR(lauf_anw->aktion->u.aktion_aufruf.name),
mutC_STR(lauf->name));
break;
default:
fatal_error (0, _T(__FILE__), __LINE__);
break;
}
}
}
}
}
}
| void show_line_number | ( | int | n | ) |
Definiert in Zeile 246 der Datei GrafKern.cpp.
Benutzt CompDiaLine und DEBUGLOG2.
Wird benutzt von yylex().
{
#ifdef WX
#ifdef DEBUG
std::cerr << "show_line_number(" << n << ") in WX mode " << std::endl;
#endif
if ( !CompDiaLine ) return;
#ifdef DEBUG
std::cerr << "setting number ";
#endif
wxString s = _T("");
if ( n != -1 ) s << n;
DEBUGLOG2(other,_T("s = %s"), s.c_str());
CompDiaLine->SetLabel(s);
CompDiaLine->Refresh();
#else
#ifdef DEBUG
std::cerr << "show_line_number(" << n << ") in non-WX mode " << std::endl;
#endif
#ifdef MUTWIN
if ( !CompDiaLine ) return;
char s[20] = "--- ";
if ( n != -1 ) sprintf(s, "%d ", n);
::SetWindowText(CompDiaLine, s);
#endif
#endif
}
| static void test_zyklen | ( | int | startknoten | ) | [static] |
Definiert in Zeile 2271 der Datei Parser.cpp.
Benutzt adjazent, anzahl_toene, fatal_error() und mutC_STR.
Wird benutzt von berechne_toene_absolut().
{
int i;
for (i=0; i<anzahl_toene; i++) {
if (adjazent (startknoten, i)) {
if (visited [i]) {
fatal_error(65,
mutC_STR(toene [startknoten]->name),
mutC_STR(toene [i]->name));
}
visited [i] = 1;
test_zyklen (i);
visited [i] = 0;
}
}
}
| static int test_zyklen_nummer | ( | const char * | name | ) | [static] |
Definiert in Zeile 2720 der Datei Parser.cpp.
Benutzt anzahl_umstimmungen_und_logiken, fatal_error(), mutC_STR, typ_logik, typ_umstimmung, umst_oder_logik::u und umst_oder_logik::umst_oder_logik_typ.
Wird benutzt von check_konsistenz().
{
int i;
for (i=0; i<anzahl_umstimmungen_und_logiken; i++)
if ( ((zyklen_feld[i].umst_oder_logik_typ == typ_umstimmung) &&
(! strcmp (name, zyklen_feld[i].u.umstimmung->name)))
||
((zyklen_feld[i].umst_oder_logik_typ == typ_logik) &&
(! strcmp (name, zyklen_feld[i].u.logik->name)))
) return i;
fatal_error(29,mutC_STR(name)); /* Umst.n.dekl. */
return 0; /* to prevent warnings */
}
| int tiefste_taste | ( | int | box | ) |
Definiert in Zeile 430 der Datei Execute.cpp.
Benutzt liegende_tasten und liegende_tasten_max.
Wird benutzt von HarmonyAnalysis().
{
int i, min = 9999;
for (i = 0; i < liegende_tasten_max[box]; i++)
if ( liegende_tasten[box][i] < min )
min = liegende_tasten[box][i];
return min;
}
| int ton_list_laenge | ( | struct ton * | list | ) |
Definiert in Zeile 88 der Datei Parser.cpp.
Benutzt ton::next.
Wird benutzt von berechne_toene_absolut(), calc_declaration_numbers(), expandiere_tonsystem() und mutabor_programm_einlesen().
{
if (list) return 1 + ton_list_laenge (list -> next);
return 0;
}
| static int ton_nummer | ( | const char * | name | ) | [static] |
Definiert in Zeile 2259 der Datei Parser.cpp.
Benutzt anzahl_toene, fatal_error() und mutC_STR.
Wird benutzt von berechne_toene_absolut() und berechne_ton_endgueltig().
{
int i;
for (i=0; i<anzahl_toene; i++)
if ( ! strcmp (name, toene[i]->name)) return i;
fatal_error(27, mutC_STR(name)); /* Ton n.dekl. */
return 0; /* to prevent warnings */
}
| int tonsystem_list_laenge | ( | struct tonsystem * | list | ) |
Definiert in Zeile 96 der Datei Parser.cpp.
Benutzt ton::next.
Wird benutzt von calc_declaration_numbers().
{
if (list) return 1 + tonsystem_list_laenge (list -> next);
return 0;
}
| static void u_test_zyklen | ( | int | startknoten | ) | [static] |
Definiert in Zeile 2737 der Datei Parser.cpp.
Benutzt anzahl_umstimmungen_und_logiken, fatal_error(), mutC_STR, typ_umstimmung, umst_oder_logik::u, u_adjazent und umst_oder_logik::umst_oder_logik_typ.
Wird benutzt von check_konsistenz().
{
int i;
for (i=0; i<anzahl_umstimmungen_und_logiken; i++) {
if (u_adjazent (startknoten, i)) {
if (u_visited [i]) {
fatal_error(66,
zyklen_feld [startknoten].umst_oder_logik_typ == typ_umstimmung ?
mutC_STR(zyklen_feld [startknoten].u.umstimmung->name) :
mutC_STR(zyklen_feld [startknoten].u.logik->name),
zyklen_feld [i].umst_oder_logik_typ == typ_umstimmung ?
mutC_STR(zyklen_feld [i].u.umstimmung->name) :
mutC_STR(zyklen_feld [i].u.logik->name));
}
u_visited [i] = 1;
u_test_zyklen (i);
u_visited [i] = 0;
}
}
}
| int umstimmungs_list_laenge | ( | struct umstimmung * | list | ) |
Definiert in Zeile 103 der Datei Parser.cpp.
Benutzt ton::next.
Wird benutzt von calc_declaration_numbers() und check_konsistenz().
{
if (list) return 1 + umstimmungs_list_laenge (list -> next);
return 0;
}
| void update_keyboard_liste | ( | int | instr | ) |
| void update_pattern | ( | int | instr | ) |
Definiert in Zeile 370 der Datei Execute.cpp.
Benutzt TSYS::breite, GET_INDEX, liegende_tasten, liegende_tasten_max, mut_box, mutabor_box_type::pattern, mutabor_box_type::tonesystem und PTRN::tonigkeit.
Wird benutzt von execute_aktion().
{
PATTERNN * temp_pattern = &(mut_box[box].pattern);
tone_system * tonsys = mut_box[box].tonesystem;
int i;
for (i=0;i<tonsys->breite;i++) temp_pattern->tonigkeit[i]=0;
for (i=0;i<liegende_tasten_max[box];i++)
(temp_pattern->tonigkeit[GET_INDEX( liegende_tasten[box][i]
,tonsys )])++;
}
| void vervollstaendige_logik | ( | void | ) |
Definiert in Zeile 2149 der Datei Parser.cpp.
Benutzt logik::anweisungsliste, get_last_anweisungs_liste() und logik::next.
Wird benutzt von yyparse().
{
struct logik * lauf;
for (lauf = list_of_logiken; lauf -> next; lauf = lauf->next) {}
lauf -> anweisungsliste = get_last_anweisungs_liste ();
}
| void write_kompletten_code | ( | FILE * | zieldatei | ) |
| void * xalloca | ( | size_t | size | ) |
Definiert in Zeile 78 der Datei Hilfs.cpp.
Benutzt DEBUGLOG2, fatal_error() und MUT_ERR_MALLOC_FAILED.
Wird benutzt von berechne_intervalle_absolut(), berechne_toene_absolut() und check_konsistenz().
{
#ifdef ACS_VERSION
void * help = Ax_malloc (size);
#else
void * help = malloc (size);
#endif
if (help == NULL) {
DEBUGLOG2(other,_T("malloc(%d) failed."),size);
fatal_error (MUT_ERR_MALLOC_FAILED);
return NULL;
}
return help;
}
| void * xcalloc | ( | size_t | anzahl, |
| size_t | size | ||
| ) |
Definiert in Zeile 239 der Datei Hilfs.cpp.
Benutzt DEBUGLOG2, fatal_error() und xmalloc().
Wird benutzt von create_midi_scan_liste() und mutabor_tabellen_generator().
{
void * help = xmalloc (anzahl * size);
if (help) {
memset (help, 0, anzahl * size);
return help;
} else {
DEBUGLOG2(other,_T("xmalloc(%d * %d) failed"),anzahl,size);
fatal_error (4);
return NULL;
}
}
| void xde_alloca | ( | void * | pointer | ) |
Definiert in Zeile 95 der Datei Hilfs.cpp.
Wird benutzt von berechne_intervalle_absolut(), berechne_toene_absolut() und check_konsistenz().
{
#ifdef ACS_VERSION
Ax_ifree (pointer);
#else
free (pointer);
#endif
}
| void xfree | ( | void * | pointer | ) |
Definiert in Zeile 131 der Datei Hilfs.cpp.
Wird benutzt von expandiere_umstimmung() und yylex().
{
/* Nichts, wenn eigene Speicherverwaltung */
/* free (pointer); */
}
| void * xmalloc | ( | size_t | size | ) |
Definiert in Zeile 140 der Datei Hilfs.cpp.
Benutzt heap_element::anzahl_belegt, DEBUGLOG2, fatal_error(), HEAP_PORTION_SYNTAX, heap_element::inhalt, heap_element::next, OFFSET und syntax_heap.
Wird benutzt von allgemeine_initialisierungen(), expand_case_liste(), expand_pattern(), expand_tonliste(), expandiere_logik(), expandiere_midi(), expandiere_tonsystem(), expandiere_umstimmung(), gen_parameter_liste(), get_ausloeser_default(), get_ausloeser_harmonie(), get_ausloeser_harmonie_form(), get_ausloeser_midi_in(), get_ausloeser_taste(), get_cache_konstante(), get_instrument_dekl(), get_new_aktion_aufruf_element(), get_new_aktion_midi_out_element(), get_new_anweisung(), get_new_faktor_anteil(), get_new_harmonie(), get_new_integer_in_integersequenz(), get_new_intervall(), get_new_intervall_komplex(), get_new_logik(), get_new_name_in_argument_list(), get_new_name_in_parameterlist(), get_new_number_in_argument_list(), get_new_taste(), get_new_ton_absolut(), get_new_ton_in_tonsystem(), get_new_ton_komplex_negative(), get_new_ton_komplex_positive(), get_new_tonsystem(), get_new_tonsystem_negative(), get_new_umstimm_expression(), get_new_umstimm_expression_negative(), get_new_umstimm_expression_positive(), get_umstimmungs_case_default_element(), get_umstimmungs_case_zahl_element(), init_umstimmung(), insert_in_globale_liste(), insert_in_lokale_liste(), xcalloc(), xrealloc() und yylex().
{
if (size + OFFSET > HEAP_PORTION_SYNTAX) {
DEBUGLOG2(other,_T("Error: %d + %d > %d"),size,OFFSET, HEAP_PORTION_SYNTAX);
fatal_error (4);
return NULL;
}
if (syntax_heap == NULL) {
#ifdef ACS_VERSION
syntax_heap = Ax_malloc (sizeof (struct heap_element));
memset(syntax_heap,0,sizeof (struct heap_element));
#else
syntax_heap = (heap_element*) calloc (1,sizeof (struct heap_element));
#endif
if (syntax_heap == NULL) {
DEBUGLOG2(other,_T("calloc(1,%d) failed"),
sizeof (struct heap_element));
fatal_error (4);
return NULL;
}
heap_to_use_syntax = syntax_heap;
heap_to_use_syntax -> anzahl_belegt = 0;
heap_to_use_syntax -> next = NULL;
}
/**** Jetzt ist zumindest ein Block da ******/
if (heap_to_use_syntax -> anzahl_belegt + size + OFFSET
< HEAP_PORTION_SYNTAX) {
void * help = & heap_to_use_syntax ->
inhalt [ heap_to_use_syntax -> anzahl_belegt + OFFSET ] ;
heap_to_use_syntax -> anzahl_belegt += size + OFFSET;
((size_t *)help) [ - 1 ] = size;
return help;
} else {
#ifdef ACS_VERSION
heap_to_use_syntax -> next = Ax_malloc (sizeof (struct heap_element));
memset(heap_to_use_syntax -> next,0,sizeof (struct heap_element));
#else
heap_to_use_syntax -> next = (heap_element*) calloc (1,sizeof (struct heap_element));
#endif
if (heap_to_use_syntax -> next == NULL) {
DEBUGLOG2(other,_T("heap_to_use_syntax -> nex == NULL"));
fatal_error (4);
return NULL;
}
heap_to_use_syntax = heap_to_use_syntax -> next;
heap_to_use_syntax -> next = NULL;
heap_to_use_syntax -> anzahl_belegt = size + OFFSET;
*(size_t *)&(heap_to_use_syntax -> inhalt [ 0 ]) = size;
return & heap_to_use_syntax -> inhalt [ OFFSET ] ;
}
}
| void * xrealloc | ( | void * | block, |
| size_t | newsize | ||
| ) |
Definiert in Zeile 208 der Datei Hilfs.cpp.
Benutzt heap_element::anzahl_belegt, DEBUGLOG2, fatal_error(), HEAP_PORTION_SYNTAX, heap_element::inhalt und xmalloc().
Wird benutzt von yylex().
{
if ( ((size_t *)block) [ - 1 ] + (char*)block
== & heap_to_use_syntax ->
inhalt [heap_to_use_syntax -> anzahl_belegt]
&&
(char*)block + newsize <
&(heap_to_use_syntax -> inhalt [ HEAP_PORTION_SYNTAX ])) {
/* Dann war block der vorherige xmalloc und es passt noch rein */
heap_to_use_syntax -> anzahl_belegt +=
newsize - ((size_t *)block) [ - 1 ] ;
((size_t *)block) [ - 1 ] = newsize;
return block;
} else {
void * help = xmalloc (newsize);
if (help) {
memmove (help, block, newsize);
return help;
} else {
DEBUGLOG2(other,_T("xmalloc (%d) failed"),newsize);
fatal_error (4);
return NULL;
}
}
}
| void * ycalloc | ( | size_t | anzahl, |
| size_t | size | ||
| ) |
| void * ymalloc | ( | size_t | size | ) |
Definiert in Zeile 304 der Datei Hilfs.cpp.
Benutzt DEBUGLOG2, fatal_error(), laufzeit_heap, mini_heap::next und mini_heap::pointer.
Wird benutzt von ycalloc() und yrealloc().
{
#ifdef ACS_VERSION
void * help1 = Ax_malloc (size);
#else
void * help1 = malloc (size);
#endif
struct mini_heap * help2 = (mini_heap*) malloc (sizeof (struct mini_heap));
if (help1 == NULL || help2 == NULL) {
DEBUGLOG2(other,_T("help1 == %x(%d) ; help2 == %x(%d)"),
help1,size,help2,sizeof(struct mini_heap));
fatal_error (4);
return NULL;
}
help2 -> pointer = help1;
help2 -> next = laufzeit_heap;
laufzeit_heap = help2;
return help1;
}
| void * yrealloc | ( | void * | block, |
| size_t | newsize | ||
| ) |
| void yyerror | ( | const char * | ) |
| int yylex | ( | void | ) |
Definiert in Zeile 2919 der Datei mut.cpp.
Benutzt ANSONSTEN, anzahl_eingelesene_zeichen, DEBUGLOG2, F_NUMBER, YYSTYPE::f_value, fatal_error(), YYLTYPE::first_line, FORM, HARMONIE, IDENTIFIER, YYSTYPE::identifier, INSTRUMENT, INTEGER, YYSTYPE::integer, intern_fgetc(), intern_ungetc(), INTERVALL, LINE_DRAW_QUANTUM, LOGIK, MAX_IDENTIFIER_LEN, MIDI_IN, MIDI_OUT, quelldatei, show_line_number(), TASTE, TON, ton_system, TONSYSTEM, UMSTIMMUNG, WURZEL, xfree(), xmalloc(), xrealloc() und zahl.
{
int c;
start_lex:
/* Ignore whitespace, get first nonwhitespace character */
while ( anzahl_eingelesene_zeichen ++,
isspace(c = toupper( intern_fgetc(quelldatei) ))) {
DEBUGLOG2(other,_T("char %x"),c);
if (c == '\n') {
DEBUGLOG2(other,_T("New line"));
if (!(yylloc.first_line ++ % LINE_DRAW_QUANTUM))
show_line_number(yylloc.first_line);
}
}
if (c == '"') {
while (anzahl_eingelesene_zeichen ++,
(c=intern_fgetc(quelldatei)) != '"' && c != EOF )
if (c == '\n') yylloc.first_line ++;
goto start_lex;
}
if (c == EOF) {
show_line_number(yylloc.first_line);
return 0;
}
/* char starts a number => parse the number. */
if (isdigit(c)) {
#if 1
double zahl = 0.0;
while (isdigit(c)) {
zahl *= 10;
zahl += ( c - '0' );
anzahl_eingelesene_zeichen ++;
c = intern_fgetc (quelldatei);
}
if (c == '.') { /* dann nachkommastellen */
double faktor = 1.0;
while (anzahl_eingelesene_zeichen ++,
isdigit (c = intern_fgetc (quelldatei))) {
faktor /= 10;
zahl += faktor * ( c - '0' );
}
intern_ungetc (c, quelldatei);
anzahl_eingelesene_zeichen --;
yylval.f_value = zahl;
return F_NUMBER;
}
else {
intern_ungetc (c, quelldatei);
anzahl_eingelesene_zeichen --;
if (zahl > INT_MAX) {
yylval.f_value = zahl;
return F_NUMBER;
}
else {
yylval.integer = (int)zahl;
return INTEGER;
}
}
#else
intern_ungetc (c, quelldatei);
anzahl_eingelesene_zeichen --;
fscanf (quelldatei, "%lf", &yylval.f_value);
#endif
/*
printf("f_number:%lf:\n", yylval.f_value);
*/
}
/* # starts a HEX-number => parse the number. */
if (c == '#') {
int help;
if (fscanf (quelldatei, "%x", &help) == 0) {
fatal_error (78, yylloc.first_line + 1);
exit (1);
}
yylval.integer = help;
/* printf("f_number:%lf:\n", yylval.f_value); */
return INTEGER;
}
/* Test auf reserved word oder einen Identifier */
if (isalpha (c) || (c == '_') || (c == '\'') ) {
static struct {
const char *word;
int token;
} reserved_words [] = {
/* German keywords : */
{ "INTERVALL" , INTERVALL },
{ "WURZEL" , WURZEL },
{ "TON" , TON },
{ "TONSYSTEM" , TONSYSTEM },
{ "UMSTIMMUNG" , UMSTIMMUNG },
{ "HARMONIE" , HARMONIE },
{ "LOGIK" , LOGIK },
{ "FORM" , FORM },
{ "MIDIKANAL" , INSTRUMENT },
{ "TASTE" , TASTE },
{ "MIDIIN" , MIDI_IN },
{ "MIDIOUT" , MIDI_OUT },
{ "ANSONSTEN" , ANSONSTEN },
/* English keywords : */
{ "INTERVAL" , INTERVALL },
{ "ROOT" , WURZEL },
{ "TONE" , TON },
{ "TONESYSTEM" , TONSYSTEM },
{ "RETUNING" , UMSTIMMUNG },
{ "PATTERN" , HARMONIE },
{ "LOGIC" , LOGIK },
{ "SHIFTED" , FORM },
{ "MIDICHANNEL", INSTRUMENT },
{ "KEY" , TASTE },
{ "ELSE" , ANSONSTEN },
{ NULL , 0 }
};
#if 0
char *symbuffer = xmalloc ((size_t)(MAX_IDENTIFIER_LEN + 1));
int i=0;
do {
if (c == '\'') c = 'i';
symbuffer[i++] = c;
c = toupper(intern_fgetc (quelldatei));
} while (c != EOF &&
i < MAX_IDENTIFIER_LEN &&
(isalnum (c) || (c == '_') || (c == '\'') ) );
intern_ungetc (c, quelldatei);
symbuffer[i] = '\0';
#else
int i = 0;
int max_identifier_len = 10;
char *symbuffer = (char*) xmalloc ((size_t) max_identifier_len);
do {
if (c == '\'') c = 'i';
if ( i + 1 == max_identifier_len ) {
char * help = (char*) xrealloc (symbuffer, (size_t) (max_identifier_len += 10));
memmove (help, symbuffer, (size_t) max_identifier_len);
symbuffer = help;
}
symbuffer[i++] = c;
DEBUGLOG2(other,_T("character #%d = %x"),i,c);
c = intern_fgetc(quelldatei);
DEBUGLOG2(other,_T("character #%d = %x"),i,c);
c = toupper(c);
DEBUGLOG2(other,_T("character #%d = %x"),i,c);
anzahl_eingelesene_zeichen ++;
} while ((c != EOF) &&
(isalnum (c) || (c == '_') || (c == '\'') ) );
intern_ungetc (c, quelldatei);
anzahl_eingelesene_zeichen --;
symbuffer[i] = '\0';
#endif
/* printf("symbuffer:%s:\n", symbuffer); */
for (i=0; reserved_words[i].word; i++) {
if ( ! strcmp (symbuffer, reserved_words[i].word)) {
xfree (symbuffer);
return reserved_words[i].token;
}
}
yylval.identifier = symbuffer;
return IDENTIFIER;
}
/* Any other character is a token by itself */
switch (c) {
case '+':
case '-':
case '*':
case '/':
case '[':
case ']':
case ':':
case '=':
case '(':
case ')':
case ',':
case '~':
case '@':
case '<':
case '>':
case '{':
case '}':
case ';':
return c;
}
fatal_error(2,c,yylloc.first_line + 1);
return 0; /* um Compilerwarnungen zu vermeiden */
} /* yylex */
| int yyparse | ( | ) |
Definiert in Zeile 1517 der Datei mut.cpp.
Benutzt alloca, bcopy, eintrage_parameterliste_in_umstimmung(), YYSTYPE::f_value, fatal_error(), FEHLERZEILE, YYLTYPE::first_column, YYLTYPE::first_line, get_ausloeser_default(), get_ausloeser_harmonie(), get_ausloeser_harmonie_form(), get_ausloeser_midi_in(), get_ausloeser_taste(), get_harmoniebezeichner(), get_instrument_dekl(), get_new_aktion_aufruf_element(), get_new_aktion_midi_out_element(), get_new_anweisung(), get_new_faktor_anteil(), get_new_harmonie(), get_new_integer_in_integersequenz(), get_new_intervall(), get_new_intervall_komplex(), get_new_logik(), get_new_name_in_argument_list(), get_new_name_in_parameterlist(), get_new_number_in_argument_list(), get_new_taste(), get_new_ton_absolut(), get_new_ton_in_tonsystem(), get_new_ton_komplex_negative(), get_new_ton_komplex_positive(), get_new_tonsystem(), get_new_tonsystem_negative(), get_new_umstimm_expression(), get_new_umstimm_expression_negative(), get_new_umstimm_expression_positive(), get_new_umstimmung(), get_umstimmung_breite_abs(), get_umstimmung_breite_rel(), get_umstimmung_midi_out(), get_umstimmung_taste_abs(), get_umstimmung_taste_rel(), get_umstimmung_tonhoehe_veraendert(), get_umstimmung_umstimm_case_parameter(), get_umstimmung_umstimm_case_zahl(), get_umstimmung_umstimmungs_bund(), get_umstimmung_wiederholung_abs(), get_umstimmung_wiederholung_abs_negative(), get_umstimmung_wiederholung_rel_negative(), get_umstimmung_wiederholung_rel_positive(), get_umstimmungs_case_default_element(), get_umstimmungs_case_zahl_element(), init_aktions_liste(), init_anweisungs_liste(), init_argument_liste(), init_ausloeser(), init_integersequenz(), init_komplex_ton_list(), init_parameter_liste(), init_tastenliste(), init_ton_liste(), init_umstimm_expression_list(), init_umstimmung(), init_umstimmungs_case_liste(), YYSTYPE::integer, YYLTYPE::last_column, YYLTYPE::last_line, list_of_instrumente, mutC_STR, parameter, vervollstaendige_logik(), YY_, YY_REDUCE_PRINT, YY_STACK_PRINT, YY_SYMBOL_PRINT, YYABORT, YYACCEPT, yychar, yycheck, yydefact, yydefgoto, yydestruct(), YYDPRINTF, YYEMPTY, YYEOF, yyerror(), YYFINAL, YYFLAG, YYID, YYINITDEPTH, YYLAST, YYLEX, yylloc, YYLLOC_DEFAULT, yylval, YYMAXDEPTH, YYMAXLIMIT, yynerrs, YYNTBASE, YYNTOKENS, yypact, YYPACT_NINF, yypgoto, YYPOPSTACK, yyr1, yyr2, yyrline, YYSIZE_T, YYSTACK_ALLOC, YYSTACK_ALLOC_MAXIMUM, YYSTACK_BYTES, YYSTACK_FREE, YYSTACK_RELOCATE, yytable, YYTABLE_NINF, YYTERROR, yytname, YYTRANSLATE und zahl.
Wird benutzt von mutabor_programm_einlesen().
{
int yystate;
int yyn;
int yyresult;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
/* Look-ahead token as an internal (translated) token number. */
int yytoken = 0;
#if YYERROR_VERBOSE
/* Buffer for error messages, and its allocated size. */
char yymsgbuf[128];
char *yymsg = yymsgbuf;
YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
#endif
/* Three stacks and their tools:
`yyss': related to states,
`yyvs': related to semantic values,
`yyls': related to locations.
Refer to the stacks thru separate pointers, to allow yyoverflow
to reallocate them elsewhere. */
/* The state stack. */
yytype_int16 yyssa[YYINITDEPTH];
yytype_int16 *yyss = yyssa;
yytype_int16 *yyssp;
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs = yyvsa;
YYSTYPE *yyvsp;
/* The location stack. */
YYLTYPE yylsa[YYINITDEPTH];
YYLTYPE *yyls = yylsa;
YYLTYPE *yylsp;
/* The locations where the error started and ended. */
YYLTYPE yyerror_range[2];
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
YYSIZE_T yystacksize = YYINITDEPTH;
/* The variables used to return semantic value and location from the
action routines. */
YYSTYPE yyval;
YYLTYPE yyloc;
/* The number of symbols on the RHS of the reduced rule.
Keep to zero when no symbol should be popped. */
int yylen = 0;
YYDPRINTF ((stderr, "Starting parse\n"));
yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
yychar = YYEMPTY; /* Cause a token to be read. */
/* Initialize stack pointers.
Waste one element of value and location stack
so that they stay on the same level as the state stack.
The wasted elements are never initialized. */
yyssp = yyss;
yyvsp = yyvs;
yylsp = yyls;
#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
/* Initialize the default location before parsing starts. */
yylloc.first_line = yylloc.last_line = 1;
yylloc.first_column = yylloc.last_column = 0;
#endif
goto yysetstate;
/*------------------------------------------------------------.
| yynewstate -- Push a new state, which is found in yystate. |
`------------------------------------------------------------*/
yynewstate:
/* In all cases, when you get here, the value and location stacks
have just been pushed. So pushing a state here evens the stacks. */
yyssp++;
yysetstate:
*yyssp = yystate;
if (yyss + yystacksize - 1 <= yyssp)
{
/* Get the current used size of the three stacks, in elements. */
YYSIZE_T yysize = yyssp - yyss + 1;
#ifdef yyoverflow
{
/* Give user a chance to reallocate the stack. Use copies of
these so that the &'s don't force the real ones into
memory. */
YYSTYPE *yyvs1 = yyvs;
yytype_int16 *yyss1 = yyss;
YYLTYPE *yyls1 = yyls;
/* Each stack pointer address is followed by the size of the
data in use in that stack, in bytes. This used to be a
conditional around just the two extra args, but that might
be undefined if yyoverflow is a macro. */
yyoverflow (YY_("memory exhausted"),
&yyss1, yysize * sizeof (*yyssp),
&yyvs1, yysize * sizeof (*yyvsp),
&yyls1, yysize * sizeof (*yylsp),
&yystacksize);
yyls = yyls1;
yyss = yyss1;
yyvs = yyvs1;
}
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
goto yyexhaustedlab;
# else
/* Extend the stack our own way. */
if (YYMAXDEPTH <= yystacksize)
goto yyexhaustedlab;
yystacksize *= 2;
if (YYMAXDEPTH < yystacksize)
yystacksize = YYMAXDEPTH;
{
yytype_int16 *yyss1 = yyss;
union yyalloc *yyptr =
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
if (! yyptr)
goto yyexhaustedlab;
YYSTACK_RELOCATE (yyss);
YYSTACK_RELOCATE (yyvs);
YYSTACK_RELOCATE (yyls);
# undef YYSTACK_RELOCATE
if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);
}
# endif
#endif /* no yyoverflow */
yyssp = yyss + yysize - 1;
yyvsp = yyvs + yysize - 1;
yylsp = yyls + yysize - 1;
YYDPRINTF ((stderr, "Stack size increased to %lu\n",
(unsigned long int) yystacksize));
if (yyss + yystacksize - 1 <= yyssp)
YYABORT;
}
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
goto yybackup;
/*-----------.
| yybackup. |
`-----------*/
yybackup:
/* Do appropriate processing given the current state. Read a
look-ahead token if we need one and don't already have one. */
/* First try to decide what to do without reference to look-ahead token. */
yyn = yypact[yystate];
if (yyn == YYPACT_NINF)
goto yydefault;
/* Not known => get a look-ahead token if don't already have one. */
/* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
if (yychar == YYEMPTY)
{
YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
}
if (yychar <= YYEOF)
{
yychar = yytoken = YYEOF;
YYDPRINTF ((stderr, "Now at end of input.\n"));
}
else
{
yytoken = YYTRANSLATE (yychar);
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
}
/* If the proper action on seeing token YYTOKEN is to reduce or to
detect an error, take that action. */
yyn += yytoken;
if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
goto yydefault;
yyn = yytable[yyn];
if (yyn <= 0)
{
if (yyn == 0 || yyn == YYTABLE_NINF)
goto yyerrlab;
yyn = -yyn;
goto yyreduce;
}
if (yyn == YYFINAL)
YYACCEPT;
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus)
yyerrstatus--;
/* Shift the look-ahead token. */
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
/* Discard the shifted token unless it is eof. */
if (yychar != YYEOF)
yychar = YYEMPTY;
yystate = yyn;
*++yyvsp = yylval;
*++yylsp = yylloc;
goto yynewstate;
/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state. |
`-----------------------------------------------------------*/
yydefault:
yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;
goto yyreduce;
/*-----------------------------.
| yyreduce -- Do a reduction. |
`-----------------------------*/
yyreduce:
/* yyn is the number of a rule to reduce with. */
yylen = yyr2[yyn];
/* If YYLEN is nonzero, implement the default value of the action:
`$$ = $1'.
Otherwise, the following line sets YYVAL to garbage.
This behavior is undocumented and Bison
users should not rely upon it. Assigning to YYVAL
unconditionally makes the parser a bit smaller, and it avoids a
GCC warning that YYVAL may be used uninitialized. */
yyval = yyvsp[1-yylen];
/* Default location. */
YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
YY_REDUCE_PRINT (yyn);
switch (yyn)
{
case 10:
#line 106 "../mu32/mut.y"
{ fatal_error(1,FEHLERZEILE); }
break;
case 14:
#line 118 "../mu32/mut.y"
{ init_komplex_ton_list (); }
break;
case 16:
#line 123 "../mu32/mut.y"
{ if ( fabs((yyvsp[(5) - (5)].f_value)) > 0.001 )
get_new_intervall ((yyvsp[(1) - (5)].identifier), (yyvsp[(3) - (5)].f_value) / (yyvsp[(5) - (5)].f_value));
else
fatal_error (46, mutC_STR((yyvsp[(1) - (5)].identifier)) ); }
break;
case 17:
#line 129 "../mu32/mut.y"
{ if ( fabs ((yyvsp[(3) - (5)].f_value)) > 0.001 )
get_new_intervall ((yyvsp[(1) - (5)].identifier), pow ((yyvsp[(5) - (5)].f_value), 1 / (yyvsp[(3) - (5)].f_value)));
else
fatal_error (46, mutC_STR((yyvsp[(1) - (5)].identifier))); }
break;
case 18:
#line 138 "../mu32/mut.y"
{ get_new_intervall_komplex ((yyvsp[(1) - (3)].identifier)); }
break;
case 19:
#line 139 "../mu32/mut.y"
{ fatal_error(71, mutC_STR((yyvsp[(1) - (3)].identifier))); }
break;
case 20:
#line 140 "../mu32/mut.y"
{ fatal_error(70,"'='",FEHLERZEILE); }
break;
case 24:
#line 152 "../mu32/mut.y"
{ init_komplex_ton_list (); }
break;
case 26:
#line 157 "../mu32/mut.y"
{ get_new_ton_absolut ((yyvsp[(1) - (3)].identifier), (yyvsp[(3) - (3)].f_value)); }
break;
case 27:
#line 161 "../mu32/mut.y"
{ get_new_ton_komplex_negative ((yyvsp[(1) - (5)].identifier), (yyvsp[(3) - (5)].identifier)); }
break;
case 28:
#line 165 "../mu32/mut.y"
{ get_new_ton_komplex_positive ((yyvsp[(1) - (3)].identifier), (yyvsp[(3) - (3)].identifier)); }
break;
case 29:
#line 169 "../mu32/mut.y"
{ get_new_ton_komplex_positive ((yyvsp[(1) - (5)].identifier), (yyvsp[(3) - (5)].identifier)); }
break;
case 30:
#line 171 "../mu32/mut.y"
{ fatal_error( 72, mutC_STR((yyvsp[(1) - (3)].identifier)) ); }
break;
case 34:
#line 185 "../mu32/mut.y"
{ get_new_faktor_anteil ( (double) 1, (yyvsp[(2) - (2)].identifier)); }
break;
case 35:
#line 188 "../mu32/mut.y"
{ get_new_faktor_anteil ( (double) -1, (yyvsp[(2) - (2)].identifier)); }
break;
case 36:
#line 191 "../mu32/mut.y"
{ get_new_faktor_anteil ( (yyvsp[(2) - (3)].f_value), (yyvsp[(3) - (3)].identifier)); }
break;
case 37:
#line 194 "../mu32/mut.y"
{ get_new_faktor_anteil ( -((yyvsp[(2) - (3)].f_value)), (yyvsp[(3) - (3)].identifier)); }
break;
case 38:
#line 197 "../mu32/mut.y"
{ if ( fabs((yyvsp[(3) - (4)].f_value)) > 0.001 )
get_new_faktor_anteil ( (double) 1 / ((yyvsp[(3) - (4)].f_value)), (yyvsp[(4) - (4)].identifier));
else
fatal_error(53, FEHLERZEILE); }
break;
case 39:
#line 203 "../mu32/mut.y"
{ if ( fabs((yyvsp[(3) - (4)].f_value)) > 0.001 )
get_new_faktor_anteil ( (double) -1 / ((yyvsp[(3) - (4)].f_value)), (yyvsp[(4) - (4)].identifier));
else
fatal_error(53, FEHLERZEILE); }
break;
case 40:
#line 209 "../mu32/mut.y"
{ if ( fabs((yyvsp[(4) - (5)].f_value)) > 0.001 )
get_new_faktor_anteil ( ((yyvsp[(2) - (5)].f_value)) / ((yyvsp[(4) - (5)].f_value)), (yyvsp[(5) - (5)].identifier));
else
fatal_error(53, FEHLERZEILE); }
break;
case 41:
#line 215 "../mu32/mut.y"
{ if ( fabs((yyvsp[(4) - (5)].f_value)) > 0.001 )
get_new_faktor_anteil ( -((yyvsp[(2) - (5)].f_value)) / ((yyvsp[(4) - (5)].f_value)), (yyvsp[(5) - (5)].identifier));
else
fatal_error(53, FEHLERZEILE); }
break;
case 42:
#line 236 "../mu32/mut.y"
{ get_new_faktor_anteil ( (double) 1.0 , (yyvsp[(1) - (1)].identifier)); }
break;
case 43:
#line 244 "../mu32/mut.y"
{ get_new_faktor_anteil ( (yyvsp[(1) - (2)].f_value), (yyvsp[(2) - (2)].identifier)); }
break;
case 44:
#line 247 "../mu32/mut.y"
{ if ( fabs((yyvsp[(2) - (3)].f_value)) > 0.001 )
get_new_faktor_anteil ( (double) 1 / ((yyvsp[(2) - (3)].f_value)), (yyvsp[(3) - (3)].identifier));
else
fatal_error(53, FEHLERZEILE); }
break;
case 45:
#line 253 "../mu32/mut.y"
{ if ( fabs((yyvsp[(3) - (4)].f_value)) > 0.001 )
get_new_faktor_anteil ( ((yyvsp[(1) - (4)].f_value)) / ((yyvsp[(3) - (4)].f_value)), (yyvsp[(4) - (4)].identifier));
else
fatal_error(53, FEHLERZEILE); }
break;
case 49:
#line 286 "../mu32/mut.y"
{ init_ton_liste (); }
break;
case 51:
#line 291 "../mu32/mut.y"
{ init_komplex_ton_list (); }
break;
case 52:
#line 293 "../mu32/mut.y"
{ get_new_tonsystem ((yyvsp[(1) - (8)].identifier), (yyvsp[(3) - (8)].integer)); }
break;
case 53:
#line 295 "../mu32/mut.y"
{ init_komplex_ton_list (); }
break;
case 54:
#line 297 "../mu32/mut.y"
{ get_new_tonsystem_negative ((yyvsp[(1) - (9)].identifier), (yyvsp[(3) - (9)].integer)); }
break;
case 57:
#line 303 "../mu32/mut.y"
{ get_new_ton_in_tonsystem ((yyvsp[(1) - (1)].identifier)); }
break;
case 58:
#line 304 "../mu32/mut.y"
{ get_new_ton_in_tonsystem (NULL); }
break;
case 59:
#line 305 "../mu32/mut.y"
{ fatal_error(73,FEHLERZEILE); }
break;
case 60:
#line 309 "../mu32/mut.y"
{ get_new_name_in_parameterlist ((yyvsp[(1) - (1)].identifier)); }
break;
case 61:
#line 311 "../mu32/mut.y"
{ get_new_name_in_parameterlist ((yyvsp[(3) - (3)].identifier)); }
break;
case 62:
#line 312 "../mu32/mut.y"
{ fatal_error(74,FEHLERZEILE); }
break;
case 63:
#line 317 "../mu32/mut.y"
{}
break;
case 64:
#line 318 "../mu32/mut.y"
{}
break;
case 65:
#line 319 "../mu32/mut.y"
{ fatal_error(74,FEHLERZEILE); }
break;
case 66:
#line 324 "../mu32/mut.y"
{ get_new_name_in_argument_list ((yyvsp[(1) - (1)].identifier)) ; }
break;
case 67:
#line 325 "../mu32/mut.y"
{ get_new_number_in_argument_list ((yyvsp[(1) - (1)].integer)) ; }
break;
case 68:
#line 326 "../mu32/mut.y"
{ get_new_number_in_argument_list (-((yyvsp[(2) - (2)].integer))); }
break;
case 72:
#line 341 "../mu32/mut.y"
{ init_umstimmung ((yyvsp[(1) - (1)].identifier));
init_parameter_liste (); }
break;
case 73:
#line 343 "../mu32/mut.y"
{ eintrage_parameterliste_in_umstimmung (); }
break;
case 74:
#line 345 "../mu32/mut.y"
{ get_new_umstimmung (); }
break;
case 75:
#line 348 "../mu32/mut.y"
{ init_umstimmung ((yyvsp[(1) - (1)].identifier));
init_parameter_liste (); }
break;
case 76:
#line 351 "../mu32/mut.y"
{ eintrage_parameterliste_in_umstimmung (); }
break;
case 77:
#line 353 "../mu32/mut.y"
{ get_new_umstimmung (); }
break;
case 78:
#line 357 "../mu32/mut.y"
{}
break;
case 79:
#line 358 "../mu32/mut.y"
{}
break;
case 80:
#line 359 "../mu32/mut.y"
{}
break;
case 81:
#line 360 "../mu32/mut.y"
{}
break;
case 82:
#line 361 "../mu32/mut.y"
{}
break;
case 83:
#line 362 "../mu32/mut.y"
{}
break;
case 84:
#line 363 "../mu32/mut.y"
{}
break;
case 85:
#line 364 "../mu32/mut.y"
{}
break;
case 86:
#line 365 "../mu32/mut.y"
{}
break;
case 87:
#line 366 "../mu32/mut.y"
{}
break;
case 88:
#line 367 "../mu32/mut.y"
{fatal_error(75,FEHLERZEILE);}
break;
case 89:
#line 373 "../mu32/mut.y"
{ get_umstimmung_taste_abs (zahl, (yyvsp[(1) - (3)].integer), NULL); }
break;
case 90:
#line 375 "../mu32/mut.y"
{ get_umstimmung_taste_abs (parameter, 0.0, (yyvsp[(1) - (3)].identifier)); }
break;
case 91:
#line 380 "../mu32/mut.y"
{ get_umstimmung_taste_rel (zahl, (yyvsp[(3) - (5)].integer), NULL, '+'); }
break;
case 92:
#line 382 "../mu32/mut.y"
{ get_umstimmung_taste_rel (parameter, 0.0, (yyvsp[(3) - (5)].identifier), '+'); }
break;
case 93:
#line 384 "../mu32/mut.y"
{ get_umstimmung_taste_rel (zahl, (yyvsp[(3) - (5)].integer), NULL, '-'); }
break;
case 94:
#line 386 "../mu32/mut.y"
{ get_umstimmung_taste_rel (parameter, 0.0, (yyvsp[(3) - (5)].identifier), '-'); }
break;
case 95:
#line 391 "../mu32/mut.y"
{ get_umstimmung_breite_abs (zahl, (yyvsp[(4) - (7)].integer), NULL); }
break;
case 96:
#line 393 "../mu32/mut.y"
{ get_umstimmung_breite_abs (parameter, 0.0, (yyvsp[(4) - (7)].identifier)); }
break;
case 97:
#line 398 "../mu32/mut.y"
{ get_umstimmung_breite_rel (zahl, (yyvsp[(6) - (9)].integer), NULL, '+'); }
break;
case 98:
#line 400 "../mu32/mut.y"
{ get_umstimmung_breite_rel (parameter, 0.0, (yyvsp[(6) - (9)].identifier), '+'); }
break;
case 99:
#line 402 "../mu32/mut.y"
{ get_umstimmung_breite_rel (zahl, (yyvsp[(6) - (9)].integer), NULL, '-'); }
break;
case 100:
#line 404 "../mu32/mut.y"
{ get_umstimmung_breite_rel (parameter, 0.0, (yyvsp[(6) - (9)].identifier), '-'); }
break;
case 101:
#line 406 "../mu32/mut.y"
{ get_umstimmung_breite_rel (zahl, (yyvsp[(6) - (9)].integer), NULL, '*'); }
break;
case 102:
#line 408 "../mu32/mut.y"
{ get_umstimmung_breite_rel (parameter, 0.0, (yyvsp[(6) - (9)].identifier), '*'); }
break;
case 103:
#line 410 "../mu32/mut.y"
{ get_umstimmung_breite_rel (zahl, (yyvsp[(6) - (9)].integer), NULL, '/'); }
break;
case 104:
#line 412 "../mu32/mut.y"
{ get_umstimmung_breite_rel (parameter, 0.0, (yyvsp[(6) - (9)].identifier), '/'); }
break;
case 105:
#line 417 "../mu32/mut.y"
{ init_umstimm_expression_list (); }
break;
case 106:
#line 419 "../mu32/mut.y"
{ get_umstimmung_tonhoehe_veraendert (); }
break;
case 107:
#line 426 "../mu32/mut.y"
{}
break;
case 108:
#line 427 "../mu32/mut.y"
{}
break;
case 109:
#line 429 "../mu32/mut.y"
{ init_komplex_ton_list();
get_new_umstimm_expression (NULL);
}
break;
case 110:
#line 432 "../mu32/mut.y"
{}
break;
case 111:
#line 436 "../mu32/mut.y"
{}
break;
case 112:
#line 437 "../mu32/mut.y"
{}
break;
case 113:
#line 442 "../mu32/mut.y"
{ init_komplex_ton_list();
get_new_umstimm_expression (NULL);
}
break;
case 115:
#line 450 "../mu32/mut.y"
{ get_new_umstimm_expression ((yyvsp[(1) - (1)].identifier)); }
break;
case 116:
#line 451 "../mu32/mut.y"
{ get_new_umstimm_expression ("@"); }
break;
case 117:
#line 453 "../mu32/mut.y"
{ init_komplex_ton_list (); }
break;
case 118:
#line 455 "../mu32/mut.y"
{ get_new_umstimm_expression_positive ((yyvsp[(1) - (4)].identifier)); }
break;
case 119:
#line 456 "../mu32/mut.y"
{ init_komplex_ton_list (); }
break;
case 120:
#line 458 "../mu32/mut.y"
{ get_new_umstimm_expression_positive ( "@" ); }
break;
case 121:
#line 459 "../mu32/mut.y"
{ init_komplex_ton_list (); }
break;
case 122:
#line 461 "../mu32/mut.y"
{ get_new_umstimm_expression_negative ((yyvsp[(1) - (4)].identifier)); }
break;
case 123:
#line 462 "../mu32/mut.y"
{ init_komplex_ton_list (); }
break;
case 124:
#line 464 "../mu32/mut.y"
{ get_new_umstimm_expression_negative ( "@" ); }
break;
case 125:
#line 469 "../mu32/mut.y"
{ init_komplex_ton_list (); }
break;
case 126:
#line 471 "../mu32/mut.y"
{ get_umstimmung_wiederholung_abs (); }
break;
case 127:
#line 472 "../mu32/mut.y"
{ init_komplex_ton_list (); }
break;
case 128:
#line 474 "../mu32/mut.y"
{ get_umstimmung_wiederholung_abs_negative (); }
break;
case 129:
#line 478 "../mu32/mut.y"
{ init_komplex_ton_list (); }
break;
case 130:
#line 480 "../mu32/mut.y"
{ get_umstimmung_wiederholung_rel_positive (); }
break;
case 131:
#line 481 "../mu32/mut.y"
{ init_komplex_ton_list (); }
break;
case 132:
#line 483 "../mu32/mut.y"
{ get_umstimmung_wiederholung_rel_negative (); }
break;
case 133:
#line 487 "../mu32/mut.y"
{ init_aktions_liste (); }
break;
case 134:
#line 489 "../mu32/mut.y"
{ get_umstimmung_umstimmungs_bund (); }
break;
case 135:
#line 493 "../mu32/mut.y"
{}
break;
case 136:
#line 494 "../mu32/mut.y"
{}
break;
case 137:
#line 498 "../mu32/mut.y"
{ init_argument_liste ();
get_new_aktion_aufruf_element ((yyvsp[(1) - (1)].identifier)); }
break;
case 138:
#line 500 "../mu32/mut.y"
{ init_argument_liste (); }
break;
case 139:
#line 502 "../mu32/mut.y"
{ get_new_aktion_aufruf_element ((yyvsp[(1) - (5)].identifier)); }
break;
case 140:
#line 504 "../mu32/mut.y"
{ init_integersequenz ();}
break;
case 141:
#line 506 "../mu32/mut.y"
{ get_new_aktion_midi_out_element (); }
break;
case 142:
#line 510 "../mu32/mut.y"
{ init_umstimmungs_case_liste (); }
break;
case 143:
#line 512 "../mu32/mut.y"
{ get_umstimmung_umstimm_case_zahl ((yyvsp[(1) - (5)].integer)); }
break;
case 144:
#line 513 "../mu32/mut.y"
{ init_umstimmungs_case_liste (); }
break;
case 145:
#line 515 "../mu32/mut.y"
{ get_umstimmung_umstimm_case_parameter ((yyvsp[(1) - (5)].identifier)); }
break;
case 146:
#line 519 "../mu32/mut.y"
{}
break;
case 147:
#line 520 "../mu32/mut.y"
{}
break;
case 148:
#line 525 "../mu32/mut.y"
{ init_aktions_liste (); }
break;
case 149:
#line 527 "../mu32/mut.y"
{ get_umstimmungs_case_zahl_element ((yyvsp[(1) - (5)].integer)); }
break;
case 150:
#line 529 "../mu32/mut.y"
{ init_aktions_liste (); }
break;
case 151:
#line 531 "../mu32/mut.y"
{ get_umstimmungs_case_zahl_element (-((yyvsp[(2) - (6)].integer))); }
break;
case 152:
#line 533 "../mu32/mut.y"
{ init_aktions_liste (); }
break;
case 153:
#line 535 "../mu32/mut.y"
{ get_umstimmungs_case_default_element (); }
break;
case 154:
#line 540 "../mu32/mut.y"
{ init_integersequenz ();}
break;
case 155:
#line 542 "../mu32/mut.y"
{ get_umstimmung_midi_out (); }
break;
case 156:
#line 547 "../mu32/mut.y"
{}
break;
case 157:
#line 551 "../mu32/mut.y"
{}
break;
case 158:
#line 552 "../mu32/mut.y"
{}
break;
case 159:
#line 557 "../mu32/mut.y"
{ init_tastenliste (); }
break;
case 160:
#line 559 "../mu32/mut.y"
{ get_new_harmonie ((yyvsp[(1) - (7)].identifier), (yyvsp[(7) - (7)].integer)); }
break;
case 161:
#line 561 "../mu32/mut.y"
{ fatal_error(76, mutC_STR((yyvsp[(1) - (3)].identifier))); }
break;
case 162:
#line 565 "../mu32/mut.y"
{ (yyval.integer) = -1; }
break;
case 163:
#line 566 "../mu32/mut.y"
{ (yyval.integer) = (yyvsp[(2) - (2)].integer); }
break;
case 164:
#line 570 "../mu32/mut.y"
{}
break;
case 165:
#line 571 "../mu32/mut.y"
{}
break;
case 166:
#line 575 "../mu32/mut.y"
{ get_new_taste ( (yyvsp[(1) - (1)].integer), '+'); }
break;
case 167:
#line 576 "../mu32/mut.y"
{ get_new_taste ( (yyvsp[(2) - (2)].integer), '*'); }
break;
case 168:
#line 580 "../mu32/mut.y"
{}
break;
case 169:
#line 584 "../mu32/mut.y"
{}
break;
case 170:
#line 585 "../mu32/mut.y"
{ init_ausloeser ();
/* fr die Anfangsausloesung der Logik */
}
break;
case 171:
#line 588 "../mu32/mut.y"
{}
break;
case 172:
#line 593 "../mu32/mut.y"
{ get_new_logik ((yyvsp[(1) - (4)].identifier), NULL);
init_anweisungs_liste (); }
break;
case 173:
#line 596 "../mu32/mut.y"
{ vervollstaendige_logik (); }
break;
case 174:
#line 598 "../mu32/mut.y"
{ get_new_logik ((yyvsp[(1) - (5)].identifier), (yyvsp[(4) - (5)].identifier));
init_anweisungs_liste (); }
break;
case 175:
#line 601 "../mu32/mut.y"
{ vervollstaendige_logik (); }
break;
case 176:
#line 605 "../mu32/mut.y"
{}
break;
case 177:
#line 606 "../mu32/mut.y"
{}
break;
case 178:
#line 611 "../mu32/mut.y"
{ init_aktions_liste (); }
break;
case 179:
#line 613 "../mu32/mut.y"
{ get_new_anweisung (); }
break;
case 180:
#line 615 "../mu32/mut.y"
{ init_aktions_liste (); }
break;
case 181:
#line 617 "../mu32/mut.y"
{ get_new_anweisung (); }
break;
case 182:
#line 622 "../mu32/mut.y"
{ get_harmoniebezeichner ( (yyvsp[(1) - (5)].integer), (yyvsp[(3) - (5)].identifier), (yyvsp[(5) - (5)].integer)); }
break;
case 183:
#line 624 "../mu32/mut.y"
{ get_harmoniebezeichner (-1, (yyvsp[(1) - (3)].identifier), (yyvsp[(3) - (3)].integer)); }
break;
case 184:
#line 626 "../mu32/mut.y"
{ get_harmoniebezeichner ( (yyvsp[(1) - (3)].integer), (yyvsp[(3) - (3)].identifier), -1); }
break;
case 185:
#line 628 "../mu32/mut.y"
{ get_harmoniebezeichner (-1, (yyvsp[(1) - (1)].identifier), -1); }
break;
case 186:
#line 632 "../mu32/mut.y"
{ get_ausloeser_default (); }
break;
case 187:
#line 633 "../mu32/mut.y"
{ get_ausloeser_harmonie (); }
break;
case 188:
#line 634 "../mu32/mut.y"
{ get_ausloeser_harmonie_form (); }
break;
case 189:
#line 635 "../mu32/mut.y"
{ get_ausloeser_taste ((yyvsp[(2) - (2)].identifier)); }
break;
case 190:
#line 636 "../mu32/mut.y"
{ init_integersequenz (); }
break;
case 191:
#line 638 "../mu32/mut.y"
{ get_ausloeser_midi_in (); }
break;
case 192:
#line 643 "../mu32/mut.y"
{ get_new_integer_in_integersequenz ((yyvsp[(1) - (1)].integer));}
break;
case 193:
#line 645 "../mu32/mut.y"
{ get_new_integer_in_integersequenz ((yyvsp[(3) - (3)].integer));}
break;
case 194:
#line 646 "../mu32/mut.y"
{ fatal_error( 77, FEHLERZEILE ); }
break;
case 195:
#line 651 "../mu32/mut.y"
{}
break;
case 196:
#line 655 "../mu32/mut.y"
{}
break;
case 197:
#line 656 "../mu32/mut.y"
{}
break;
case 198:
#line 661 "../mu32/mut.y"
{ get_instrument_dekl ((yyvsp[(1) - (4)].integer), (yyvsp[(4) - (4)].integer), (yyvsp[(4) - (4)].integer), 0, & list_of_instrumente); }
break;
case 199:
#line 663 "../mu32/mut.y"
{ get_instrument_dekl ((yyvsp[(1) - (6)].integer), (yyvsp[(4) - (6)].integer), (yyvsp[(6) - (6)].integer), 0, & list_of_instrumente); }
break;
case 200:
#line 665 "../mu32/mut.y"
{ get_instrument_dekl ((yyvsp[(1) - (6)].integer), 0, 0, (yyvsp[(5) - (6)].integer), & list_of_instrumente); }
break;
case 201:
#line 667 "../mu32/mut.y"
{ get_instrument_dekl ((yyvsp[(1) - (7)].integer), (yyvsp[(4) - (7)].integer), (yyvsp[(4) - (7)].integer), (yyvsp[(6) - (7)].integer), & list_of_instrumente); }
break;
case 202:
#line 669 "../mu32/mut.y"
{ get_instrument_dekl ((yyvsp[(1) - (9)].integer), (yyvsp[(4) - (9)].integer), (yyvsp[(6) - (9)].integer), (yyvsp[(8) - (9)].integer), & list_of_instrumente); }
break;
case 203:
#line 673 "../mu32/mut.y"
{ (yyval.f_value) = (yyvsp[(1) - (1)].f_value) ; }
break;
case 204:
#line 674 "../mu32/mut.y"
{ (yyval.f_value) = (double) (yyvsp[(1) - (1)].integer) ; }
break;
/* Line 1267 of yacc.c. */
#line 2686 "y.tab.c"
default: break;
}
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
YYPOPSTACK (yylen);
yylen = 0;
YY_STACK_PRINT (yyss, yyssp);
*++yyvsp = yyval;
*++yylsp = yyloc;
/* Now `shift' the result of the reduction. Determine what state
that goes to, based on the state we popped back to and the rule
number reduced by. */
yyn = yyr1[yyn];
yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
yystate = yytable[yystate];
else
yystate = yydefgoto[yyn - YYNTOKENS];
goto yynewstate;
/*------------------------------------.
| yyerrlab -- here on detecting error |
`------------------------------------*/
yyerrlab:
/* If not already recovering from an error, report this error. */
if (!yyerrstatus)
{
++yynerrs;
#if ! YYERROR_VERBOSE
yyerror (YY_("syntax error"));
#else
{
YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
{
YYSIZE_T yyalloc = 2 * yysize;
if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
yyalloc = YYSTACK_ALLOC_MAXIMUM;
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
yymsg = (char *) YYSTACK_ALLOC (yyalloc);
if (yymsg)
yymsg_alloc = yyalloc;
else
{
yymsg = yymsgbuf;
yymsg_alloc = sizeof yymsgbuf;
}
}
if (0 < yysize && yysize <= yymsg_alloc)
{
(void) yysyntax_error (yymsg, yystate, yychar);
yyerror (yymsg);
}
else
{
yyerror (YY_("syntax error"));
if (yysize != 0)
goto yyexhaustedlab;
}
}
#endif
}
yyerror_range[0] = yylloc;
if (yyerrstatus == 3)
{
/* If just tried and failed to reuse look-ahead token after an
error, discard it. */
if (yychar <= YYEOF)
{
/* Return failure if at end of input. */
if (yychar == YYEOF)
YYABORT;
}
else
{
yydestruct ("Error: discarding",
yytoken, &yylval, &yylloc);
yychar = YYEMPTY;
}
}
/* Else will try to reuse look-ahead token after shifting the error
token. */
goto yyerrlab1;
/*---------------------------------------------------.
| yyerrorlab -- error raised explicitly by YYERROR. |
`---------------------------------------------------*/
yyerrorlab:
/* Pacify compilers like GCC when the user code never invokes
YYERROR and the label yyerrorlab therefore never appears in user
code. */
if (/*CONSTCOND*/ 0)
goto yyerrorlab;
yyerror_range[0] = yylsp[1-yylen];
/* Do not reclaim the symbols of the rule which action triggered
this YYERROR. */
YYPOPSTACK (yylen);
yylen = 0;
YY_STACK_PRINT (yyss, yyssp);
yystate = *yyssp;
goto yyerrlab1;
/*-------------------------------------------------------------.
| yyerrlab1 -- common code for both syntax error and YYERROR. |
`-------------------------------------------------------------*/
yyerrlab1:
yyerrstatus = 3; /* Each real token shifted decrements this. */
for (;;)
{
yyn = yypact[yystate];
if (yyn != YYPACT_NINF)
{
yyn += YYTERROR;
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
{
yyn = yytable[yyn];
if (0 < yyn)
break;
}
}
/* Pop the current state because it cannot handle the error token. */
if (yyssp == yyss)
YYABORT;
yyerror_range[0] = *yylsp;
yydestruct ("Error: popping",
yystos[yystate], yyvsp, yylsp);
YYPOPSTACK (1);
yystate = *yyssp;
YY_STACK_PRINT (yyss, yyssp);
}
if (yyn == YYFINAL)
YYACCEPT;
*++yyvsp = yylval;
yyerror_range[1] = yylloc;
/* Using YYLLOC is tempting, but would change the location of
the look-ahead. YYLOC is available though. */
YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
*++yylsp = yyloc;
/* Shift the error token. */
YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
yystate = yyn;
goto yynewstate;
/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here. |
`-------------------------------------*/
yyacceptlab:
yyresult = 0;
goto yyreturn;
/*-----------------------------------.
| yyabortlab -- YYABORT comes here. |
`-----------------------------------*/
yyabortlab:
yyresult = 1;
goto yyreturn;
#ifndef yyoverflow
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here. |
`-------------------------------------------------*/
yyexhaustedlab:
yyerror (YY_("memory exhausted"));
yyresult = 2;
/* Fall through. */
#endif
yyreturn:
if (yychar != YYEOF && yychar != YYEMPTY)
yydestruct ("Cleanup: discarding lookahead",
yytoken, &yylval, &yylloc);
/* Do not reclaim the symbols of the rule which action triggered
this YYABORT or YYACCEPT. */
YYPOPSTACK (yylen);
YY_STACK_PRINT (yyss, yyssp);
while (yyssp != yyss)
{
yydestruct ("Cleanup: popping",
yystos[*yyssp], yyvsp, yylsp);
YYPOPSTACK (1);
}
#ifndef yyoverflow
if (yyss != yyssa)
YYSTACK_FREE (yyss);
#endif
#if YYERROR_VERBOSE
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
#endif
/* Make sure YYID is used. */
return YYID (yyresult);
}
struct interpreter_parameter_liste abstands_knoten [static] |
{
& laufzeit_abstand, & zentrums_knoten
}
Definiert in Zeile 162 der Datei TabGen.cpp.
| int aktionen_ausgabezeile = 0 |
Definiert in Zeile 84 der Datei GrafKern.cpp.
| int aktuelle_keyboard_box = 0 |
Definiert in Zeile 28 der Datei box.cpp.
Wird benutzt von GetAktuellesKeyboardInstrument(), IsLogicKey(), keyboard_analyse(), KeyboardIn() und SetAktuellesKeyboardInstrument().
Definiert in Zeile 28 der Datei box.cpp.
Wird benutzt von GetAktuellesKeyboardInstrument(), IsLogicKey(), keyboard_analyse(), KeyboardIn() und SetAktuellesKeyboardInstrument().
| int aktuelles_midi_instrument = 0 |
Definiert in Zeile 63 der Datei TabGen.cpp.
Wird benutzt von calc_declaration_numbers(), init_yylex() und yylex().
Definiert in Zeile 63 der Datei TabGen.cpp.
Wird benutzt von calc_declaration_numbers(), init_yylex() und yylex().
int anzahl_toene [static] |
Definiert in Zeile 2232 der Datei Parser.cpp.
Wird benutzt von berechne_toene_absolut(), test_zyklen() und ton_nummer().
int anzahl_umstimmungen_und_logiken [static] |
Definiert in Zeile 2662 der Datei Parser.cpp.
Wird benutzt von check_konsistenz(), test_zyklen_nummer() und u_test_zyklen().
| unsigned char boxAktionen[AKTIONEN_MAX] |
Definiert in Zeile 96 der Datei GrafKern.cpp.
Wird benutzt von AktionenMessage() und GetActString().
struct cache_konstanten* cache_konstanten = NULL [static] |
Definiert in Zeile 183 der Datei TabGen.cpp.
| HWND CompDiaLine |
Definiert in Zeile 79 der Datei GrafKern.cpp.
Wird benutzt von InitCompDia() und show_line_number().
| const mutTranslationChar* Error_text[] |
Definiert in Zeile 178 der Datei Errors.cpp.
Wird benutzt von fatal_error().
| const mutTranslationChar* Error_text[] |
Definiert in Zeile 178 der Datei Errors.cpp.
Wird benutzt von fatal_error().
| struct harmonie_ereignis* first_harmonie[MAX_BOX] |
Definiert in Zeile 45 der Datei TabGen.cpp.
Wird benutzt von HarmonyAnalysis().
| struct harmonie_ereignis* first_harmonie[MAX_BOX] |
Definiert in Zeile 45 der Datei TabGen.cpp.
Wird benutzt von HarmonyAnalysis().
| struct keyboard_ereignis* first_keyboard[MAX_BOX] |
Definiert in Zeile 51 der Datei TabGen.cpp.
Wird benutzt von GetMutTag(), IsLogicKey(), KeyboardAnalyse() und KeyboardAnalyseSimple().
| struct keyboard_ereignis* first_keyboard[MAX_BOX] |
Definiert in Zeile 51 der Datei TabGen.cpp.
Wird benutzt von GetMutTag(), IsLogicKey(), KeyboardAnalyse() und KeyboardAnalyseSimple().
| struct harmonie_ereignis** first_lokal_harmonie |
Definiert in Zeile 49 der Datei TabGen.cpp.
| struct harmonie_ereignis** first_lokal_harmonie |
Definiert in Zeile 49 der Datei TabGen.cpp.
| struct keyboard_ereignis** first_lokal_keyboard |
Definiert in Zeile 55 der Datei TabGen.cpp.
| struct keyboard_ereignis** first_lokal_keyboard |
Definiert in Zeile 55 der Datei TabGen.cpp.
| struct midi_ereignis** first_lokal_midi |
Definiert in Zeile 61 der Datei TabGen.cpp.
| struct midi_ereignis** first_lokal_midi |
Definiert in Zeile 61 der Datei TabGen.cpp.
| struct midi_ereignis* first_midi[MAX_BOX] |
Definiert in Zeile 57 der Datei TabGen.cpp.
Wird benutzt von MidiAnalysis().
| struct midi_ereignis* first_midi[MAX_BOX] |
Definiert in Zeile 57 der Datei TabGen.cpp.
Wird benutzt von MidiAnalysis().
Definiert in Zeile 114 der Datei GrafKern.cpp.
Wird benutzt von Activate(), Compile(), compiler_warning(), fatal_error(), GetErrorLine() und laufzeit_protokoll().
Definiert in Zeile 114 der Datei GrafKern.cpp.
Wird benutzt von Activate(), Compile(), compiler_warning(), fatal_error(), GetErrorLine() und laufzeit_protokoll().
Definiert in Zeile 23 der Datei box.cpp.
Wird benutzt von change_anker() und GlobalReset().
Definiert in Zeile 23 der Datei box.cpp.
Wird benutzt von change_anker() und GlobalReset().
| int geheimcode |
struct heap_element* heap_to_use_syntax = NULL [static] |
| int is_valid |
Definiert in Zeile 43 der Datei Hilfs.cpp.
Wird benutzt von intern_fgetc() und intern_ungetc().
| int keys_changed[MAX_BOX] |
Definiert in Zeile 102 der Datei GrafKern.cpp.
Wird benutzt von FlushUpdateUI(), KeyChanged() und MutResetKeys().
| int keys_changed[MAX_BOX] |
Definiert in Zeile 102 der Datei GrafKern.cpp.
Wird benutzt von FlushUpdateUI(), KeyChanged() und MutResetKeys().
| int keys_changed_sum |
Definiert in Zeile 104 der Datei GrafKern.cpp.
Wird benutzt von FlushUpdateUI() und MutResetKeys().
| int keys_changed_sum |
Definiert in Zeile 104 der Datei GrafKern.cpp.
Wird benutzt von FlushUpdateUI() und MutResetKeys().
| int lAktionen[AKTIONEN_MAX] |
Definiert in Zeile 98 der Datei GrafKern.cpp.
Wird benutzt von AktionenMessage() und GetActString().
| struct harmonie_ereignis** last_global_harmonie[MAX_BOX] |
Definiert in Zeile 47 der Datei TabGen.cpp.
Wird benutzt von execute_aktion() und MutResetKeys().
| struct harmonie_ereignis** last_global_harmonie[MAX_BOX] |
Definiert in Zeile 47 der Datei TabGen.cpp.
Wird benutzt von execute_aktion() und MutResetKeys().
| struct keyboard_ereignis** last_global_keyboard[MAX_BOX] |
Definiert in Zeile 53 der Datei TabGen.cpp.
Wird benutzt von execute_aktion() und MutResetKeys().
| struct keyboard_ereignis** last_global_keyboard[MAX_BOX] |
Definiert in Zeile 53 der Datei TabGen.cpp.
Wird benutzt von execute_aktion() und MutResetKeys().
| struct midi_ereignis** last_global_midi[MAX_BOX] |
Definiert in Zeile 59 der Datei TabGen.cpp.
Wird benutzt von execute_aktion() und MutResetKeys().
| struct midi_ereignis** last_global_midi[MAX_BOX] |
Definiert in Zeile 59 der Datei TabGen.cpp.
Wird benutzt von execute_aktion() und MutResetKeys().
| long last_note_id[MAX_BOX] |
Definiert in Zeile 72 der Datei Execute.cpp.
Wird benutzt von AddKey() und DeleteKey().
| int laufzeit_abstand[256] |
Definiert in Zeile 75 der Datei Execute.cpp.
Wird benutzt von HarmonyAnalysis().
| int laufzeit_abstand[MAX_BOX] |
Definiert in Zeile 75 der Datei Execute.cpp.
Wird benutzt von HarmonyAnalysis().
struct mini_heap* laufzeit_heap = NULL [static] |
Definiert in Zeile 294 der Datei Hilfs.cpp.
Wird benutzt von loesche_laufzeit_speicher() und ymalloc().
| int laufzeit_meldungen_erlaubt = 0 |
| int laufzeit_zentrum[256] |
Definiert in Zeile 76 der Datei Execute.cpp.
Wird benutzt von change_anker() und HarmonyAnalysis().
| int laufzeit_zentrum[MAX_BOX] |
Definiert in Zeile 76 der Datei Execute.cpp.
Wird benutzt von change_anker() und HarmonyAnalysis().
| int liegende_tasten[MAX_BOX][64] |
Definiert in Zeile 70 der Datei Execute.cpp.
Wird benutzt von AddKey(), DeleteKey(), hoechste_taste(), protokoll_liegende_frequenzen(), protokoll_liegende_relationen(), tiefste_taste() und update_pattern().
| int liegende_tasten[MAX_BOX][64] |
Definiert in Zeile 70 der Datei Execute.cpp.
Wird benutzt von AddKey(), DeleteKey(), hoechste_taste(), protokoll_liegende_frequenzen(), protokoll_liegende_relationen(), tiefste_taste() und update_pattern().
| int liegende_tasten_max[MAX_BOX] |
Definiert in Zeile 71 der Datei Execute.cpp.
Wird benutzt von AddKey(), DeleteKey(), hoechste_taste(), MutResetKeys(), protokoll_liegende_frequenzen(), protokoll_liegende_relationen(), tiefste_taste() und update_pattern().
| int liegende_tasten_max[MAX_BOX] |
Definiert in Zeile 71 der Datei Execute.cpp.
Wird benutzt von AddKey(), DeleteKey(), hoechste_taste(), MutResetKeys(), protokoll_liegende_frequenzen(), protokoll_liegende_relationen(), tiefste_taste() und update_pattern().
struct aktions_liste* list_of_aktionen [static] |
Definiert in Zeile 367 der Datei Parser.cpp.
Wird benutzt von get_last_aktions_liste().
struct argument_liste* list_of_argumente [static] |
Definiert in Zeile 314 der Datei Parser.cpp.
Wird benutzt von get_last_argument_liste().
| struct instrument* list_of_config_instrumente |
Definiert in Zeile 56 der Datei Parser.cpp.
Wird benutzt von GetChannels(), mutabor_programm_einlesen() und SetChannels().
| struct instrument* list_of_config_instrumente |
Definiert in Zeile 56 der Datei Parser.cpp.
Wird benutzt von GetChannels(), mutabor_programm_einlesen() und SetChannels().
| struct harmonie* list_of_harmonien |
Definiert in Zeile 50 der Datei Parser.cpp.
Wird benutzt von expand_pattern().
| struct harmonie* list_of_harmonien |
Definiert in Zeile 50 der Datei Parser.cpp.
Wird benutzt von expand_pattern().
| struct instrument* list_of_instrumente |
Definiert in Zeile 54 der Datei Parser.cpp.
Wird benutzt von yyparse().
| struct instrument* list_of_instrumente |
Definiert in Zeile 54 der Datei Parser.cpp.
Wird benutzt von yyparse().
struct midiliste* list_of_integers [static] |
Definiert in Zeile 221 der Datei Parser.cpp.
Wird benutzt von get_last_integersequenz().
| struct intervall* list_of_intervalle |
Definiert in Zeile 42 der Datei Parser.cpp.
Wird benutzt von calc_declaration_numbers(), check_komplex_intervall(), get_intervall_wert() und get_komplex_faktor().
| struct intervall* list_of_intervalle |
Definiert in Zeile 42 der Datei Parser.cpp.
Wird benutzt von calc_declaration_numbers(), check_komplex_intervall(), get_intervall_wert() und get_komplex_faktor().
| struct logik* list_of_logiken |
Definiert in Zeile 52 der Datei Parser.cpp.
Wird benutzt von calc_declaration_numbers(), expandiere_logik(), expandiere_name() und mutabor_tabellen_generator().
| struct logik* list_of_logiken |
Definiert in Zeile 52 der Datei Parser.cpp.
Wird benutzt von calc_declaration_numbers(), expandiere_logik(), expandiere_name() und mutabor_tabellen_generator().
struct parameter_liste* list_of_names [static] |
Definiert in Zeile 253 der Datei Parser.cpp.
Wird benutzt von get_last_parameter_liste().
| struct ton* list_of_toene |
Definiert in Zeile 44 der Datei Parser.cpp.
Wird benutzt von calc_declaration_numbers(), expandiere_tonsystem() und get_komplex_frequenz().
| struct ton* list_of_toene |
Definiert in Zeile 44 der Datei Parser.cpp.
Wird benutzt von calc_declaration_numbers(), expandiere_tonsystem() und get_komplex_frequenz().
| struct tonsystem* list_of_tonsysteme |
Definiert in Zeile 46 der Datei Parser.cpp.
Wird benutzt von calc_declaration_numbers(), expandiere_logik() und expandiere_name().
| struct tonsystem* list_of_tonsysteme |
Definiert in Zeile 46 der Datei Parser.cpp.
Wird benutzt von calc_declaration_numbers(), expandiere_logik() und expandiere_name().
| struct umstimmung* list_of_umstimmungen |
Definiert in Zeile 48 der Datei Parser.cpp.
Wird benutzt von calc_declaration_numbers(), expandiere_logik() und expandiere_name().
| struct umstimmung* list_of_umstimmungen |
Definiert in Zeile 48 der Datei Parser.cpp.
Wird benutzt von calc_declaration_numbers(), expandiere_logik() und expandiere_name().
| bool logic_changed[MAX_BOX] |
Definiert in Zeile 73 der Datei Execute.cpp.
Wird benutzt von execute_aktion(), FlushUpdateUI() und MutResetKeys().
Definiert in Zeile 2240 der Datei Parser.cpp.
| mutabor_box_type mut_box[MAX_BOX] |
Definiert in Zeile 25 der Datei box.cpp.
Wird benutzt von AddKey(), change_anker(), change_breite(), DeleteKey(), execute_aktion(), GlobalReset(), HarmonyAnalysis(), MutResetKeys(), OutMidiPort::NoteOn(), OutMidiFile::NoteOn(), OutMidiPort::NotesCorrect(), OutMidiFile::NotesCorrect(), protokoll_aktuelle_relationen(), protokoll_aktuelles_tonsystem(), protokoll_liegende_frequenzen(), protokoll_liegende_relationen(), TSChanged() und update_pattern().
| mutabor_box_type mut_box[MAX_BOX] |
Definiert in Zeile 25 der Datei box.cpp.
Wird benutzt von AddKey(), change_anker(), change_breite(), DeleteKey(), execute_aktion(), GlobalReset(), HarmonyAnalysis(), MutResetKeys(), OutMidiPort::NoteOn(), OutMidiFile::NoteOn(), OutMidiPort::NotesCorrect(), OutMidiFile::NotesCorrect(), protokoll_aktuelle_relationen(), protokoll_aktuelles_tonsystem(), protokoll_liegende_frequenzen(), protokoll_liegende_relationen(), TSChanged() und update_pattern().
| int nAktionen = 0 |
Definiert in Zeile 100 der Datei GrafKern.cpp.
Wird benutzt von AktionenInit(), AktionenMessage() und GetActString().
| int protokoll_ausgabezeile = 0 |
Definiert in Zeile 83 der Datei GrafKern.cpp.
Wird benutzt von GetLineNumbers(), init_laufzeit_protokoll() und laufzeit_message().
| char protokoll_string[PROT_MAXCHARS] |
Definiert in Zeile 92 der Datei GrafKern.cpp.
Wird benutzt von GetKeyString(), GetTSString(), init_laufzeit_protokoll() und laufzeit_message().
| int protokollfunktion_aktionsausgabe = 0 |
Definiert in Zeile 51 der Datei Execute.cpp.
| int protokollfunktionen_aktiv = 0 |
Definiert in Zeile 50 der Datei Execute.cpp.
| FILE* quelldatei |
Definiert in Zeile 565 der Datei Parser.cpp.
Wird benutzt von yylex().
| FILE* quelldatei |
Definiert in Zeile 565 der Datei Parser.cpp.
Wird benutzt von yylex().
Definiert in Zeile 94 der Datei GrafKern.cpp.
Wird benutzt von AktionenMessage() und GetActString().
| int scanner_echo |
Definiert in Zeile 112 der Datei GrafKern.cpp.
Wird benutzt von calc_declaration_numbers() und Compile().
Definiert in Zeile 112 der Datei GrafKern.cpp.
Wird benutzt von calc_declaration_numbers() und Compile().
Definiert in Zeile 112 der Datei GrafKern.cpp.
Wird benutzt von calc_declaration_numbers() und Compile().
Definiert in Zeile 112 der Datei GrafKern.cpp.
Wird benutzt von calc_declaration_numbers() und Compile().
{ 4,3,70,2,11,61,
127
}
Definiert in Zeile 38 der Datei Hilfs.cpp.
Wird benutzt von intern_ungetc().
Definiert in Zeile 167 der Datei TabGen.cpp.
struct heap_element* syntax_heap = NULL [static] |
Definiert in Zeile 121 der Datei Hilfs.cpp.
Wird benutzt von loesche_syntax_speicher() und xmalloc().
| char tempstring[255] |
Definiert in Zeile 78 der Datei Execute.cpp.
int the_character [static] |
Definiert in Zeile 43 der Datei Hilfs.cpp.
Wird benutzt von intern_fgetc() und intern_ungetc().
struct komplex_intervall* the_komplex_liste [static] |
Definiert in Zeile 411 der Datei Parser.cpp.
Wird benutzt von get_last_komplex_intervall().
struct anweisung* tmp_anweisungsliste [static] |
Definiert in Zeile 2098 der Datei Parser.cpp.
Wird benutzt von get_last_anweisungs_liste().
struct ausloeser* tmp_ausloeser [static] |
Definiert in Zeile 2028 der Datei Parser.cpp.
Wird benutzt von get_last_ausloeser().
int tmp_nach_taste [static] |
Definiert in Zeile 2017 der Datei Parser.cpp.
Wird benutzt von get_ausloeser_harmonie() und get_ausloeser_harmonie_form().
Definiert in Zeile 2015 der Datei Parser.cpp.
Wird benutzt von get_ausloeser_harmonie() und get_ausloeser_harmonie_form().
struct taste* tmp_tastenliste [static] |
Definiert in Zeile 1930 der Datei Parser.cpp.
Wird benutzt von get_new_harmonie().
struct ton* tmp_tonliste [static] |
Definiert in Zeile 1426 der Datei Parser.cpp.
Wird benutzt von get_umstimmung_tonhoehe_veraendert().
struct umstimmung* tmp_umstimmung [static] |
Definiert in Zeile 1232 der Datei Parser.cpp.
Wird benutzt von get_new_umstimmung().
struct case_liste* tmp_umstimmungs_case_liste [static] |
Definiert in Zeile 1663 der Datei Parser.cpp.
Wird benutzt von get_umstimmung_umstimm_case_parameter() und get_umstimmung_umstimm_case_zahl().
int tmp_vor_taste [static] |
Definiert in Zeile 2013 der Datei Parser.cpp.
Wird benutzt von get_ausloeser_harmonie() und get_ausloeser_harmonie_form().
Definiert in Zeile 2234 der Datei Parser.cpp.
Wird benutzt von expandiere_tonsystem(), get_new_tonsystem() und get_new_tonsystem_negative().
Definiert in Zeile 1147 der Datei Parser.cpp.
Wird benutzt von get_new_tonsystem() und get_new_tonsystem_negative().
| struct ton* ton_ohne_namen |
Definiert in Zeile 58 der Datei Parser.cpp.
{60, 1, DOUBLE_TO_LONG(1), { DOUBLE_TO_LONG(60) }}
Definiert in Zeile 66 der Datei Execute.cpp.
Wird benutzt von GlobalReset().
| tone_system tonesystem_memory[MAX_BOX+1] |
Definiert in Zeile 64 der Datei Execute.cpp.
Definiert in Zeile 2686 der Datei Parser.cpp.
Definiert in Zeile 2684 der Datei Parser.cpp.
Definiert in Zeile 2238 der Datei Parser.cpp.
| const mutTranslationChar* Warning_text[] |
{
N_("Undefined compiler warning"),
N_("MIDI event in logic %s does not start with channel 0 status byte. Value corrected."),
N_("Non existent harmony event in logic %s"),
N_("Non well defined event %s in logic %s"),
N_("Event ELSE is last in %s"),
N_("MIDI channels wasted in channel assotiation"),
N_("No file given, trying test.mut"),
N_("Invalid configuration file"),
N_("Intersection of MIDI channels %d und %d"),
N_("Error in GMN-File %s position(%d, %d): %s")
}
Definiert in Zeile 279 der Datei Errors.cpp.
Wird benutzt von compiler_warning().
| const mutTranslationChar* Warning_text[] |
Definiert in Zeile 279 der Datei Errors.cpp.
Wird benutzt von compiler_warning().
| jmp_buf weiter_gehts_nach_compilerfehler |
Definiert in Zeile 118 der Datei Runtime.cpp.
Wird benutzt von fatal_error().
| int zeige_aktuelles_tonsystem = 0 |
Definiert in Zeile 52 der Datei Execute.cpp.
struct interpreter_parameter_liste zentrums_knoten [static] |
{
& laufzeit_zentrum, NULL
}
Definiert in Zeile 157 der Datei TabGen.cpp.
struct umst_oder_logik* zyklen_feld [static] |
Definiert in Zeile 2680 der Datei Parser.cpp.
1.7.4