/************************************************************* ************************************************************* **** **** **** 6 5 1 0 - D e v e l o p e r s - P a c k e t **** **** **** **** C R O S S A S S V 1 . 0 **** **** ------------------------------------- **** **** **** **** programmiert von Christian Krenner **** **** (C)opyright 1992 Markt & Technik Verlag AG **** **** **** ************************************************************* *************************************************************/ /************ * includes * ************/ #include #include #include #include #include #include #include #include #include #include /******************* * neue Strukturen * *******************/ struct Label { char name[32]; unsigned int wert; unsigned int aufruf; unsigned int macro; }; struct Macro { char name[32]; char *source; char paramcount; unsigned long lenght; unsigned int aufruf; }; struct MacroStack { char *pointer; char *endbuffer; long actlenght; char paramcount; unsigned int params[10]; BOOL defd[10]; long lineafter; unsigned int number; unsigned int aufruf; }; struct IncludeStack { char lastfile[256]; long lineafter; }; struct Block { unsigned int begin; unsigned int end; char name[32]; unsigned int labels; }; struct Einstellungen { unsigned long macromemlenght; unsigned long macrotablelenght; unsigned long labellenght; unsigned int delay; BOOL sort; unsigned char converttable[256]; }; /******************************** * globale Strukturen für Menüs * ********************************/ struct TextAttr Font = { (STRPTR)"topaz.font", TOPAZ_EIGHTY, FS_NORMAL, FPF_ROMFONT }; struct IntuiText DateiUebertragenText = { 0, 1, JAM2, 1, 1, &Font, (UBYTE *)"Übertragen", NULL }; struct IntuiText DateiInformationText = { 0, 1, JAM2, 1, 1, &Font, (UBYTE *)"Über ...", NULL }; struct IntuiText DateiEndeText = { 0, 1, JAM2, 1, 1, &Font, (UBYTE *)"Ende", NULL }; struct IntuiText TabellenLabelsText = { 0, 1, JAM2, 1, 1, &Font, (UBYTE *)"Labels", NULL }; struct IntuiText TabellenMakrosText = { 0, 1, JAM2, 1, 1, &Font, (UBYTE *)"Makros", NULL }; struct IntuiText TabellenBloeckeText = { 0, 1, JAM2, 1, 1, &Font, (UBYTE *)"Blöcke", NULL }; struct IntuiText TabellenMnemonicsText = { 0, 1, JAM2, 1, 1, &Font, (UBYTE *)"Mnemonics", NULL }; struct IntuiText EinstAendernText = { 0, 1, JAM2, 1, 1, &Font, (UBYTE *)"Ändern", NULL }; struct IntuiText EinstSpeichernText = { 0, 1, JAM2, 1, 1, &Font, (UBYTE *)"Speichern", NULL }; struct IntuiText EinstLadenText = { 0, 1, JAM2, 1, 1, &Font, (UBYTE *)"Laden", NULL }; struct IntuiText EinstKLadenText = { 0, 1, JAM2, 1, 1, &Font, (UBYTE *)"KonvTab laden", NULL }; struct IntuiText DruckenSText = { 0, 1, JAM2, 1, 1, &Font, (UBYTE *)"Quelldatei", NULL }; struct IntuiText DruckenLabelText = { 0, 1, JAM2, 1, 1, &Font, (UBYTE *)"Labels", NULL }; struct IntuiText DruckenMakroText = { 0, 1, JAM2, 1, 1, &Font, (UBYTE *)"Makros", NULL }; struct IntuiText DruckenBloeckeText = { 0, 1, JAM2, 1, 1, &Font, (UBYTE *)"Blöcke", NULL }; struct MenuItem DruckenBloecke = { NULL, 1, 31, 152, 10, ITEMTEXT | COMMSEQ | HIGHCOMP | ITEMENABLED, 0L, (APTR)&DruckenBloeckeText, NULL, '1', NULL, 0, }; struct MenuItem DruckenMakros = { &DruckenBloecke, 1, 21, 152, 10, ITEMTEXT | COMMSEQ | HIGHCOMP | ITEMENABLED, 0L, (APTR)&DruckenMakroText, NULL, '2', NULL, 0, }; struct MenuItem DruckenLabels = { &DruckenMakros, 1, 11, 152, 10, ITEMTEXT | COMMSEQ | HIGHCOMP | ITEMENABLED, 0L, (APTR)&DruckenLabelText, NULL, '3', NULL, 0, }; struct MenuItem DruckenSource = { &DruckenLabels, 1, 1, 152, 10, ITEMTEXT | COMMSEQ | HIGHCOMP | ITEMENABLED, 0L, (APTR)&DruckenSText, NULL, '4', NULL, 0, }; struct MenuItem EinstKLaden = { NULL, 1, 31, 152, 10, ITEMTEXT | COMMSEQ | HIGHCOMP | ITEMENABLED, 0L, (APTR)&EinstKLadenText, NULL, 'K', NULL, 0, }; struct MenuItem EinstLaden = { &EinstKLaden, 1, 21, 152, 10, ITEMTEXT | COMMSEQ | HIGHCOMP | ITEMENABLED, 0L, (APTR)&EinstLadenText, NULL, 'O', NULL, 0, }; struct MenuItem EinstSpeichern = { &EinstLaden, 1, 11, 152, 10, ITEMTEXT | COMMSEQ | HIGHCOMP | ITEMENABLED, 0L, (APTR)&EinstSpeichernText, NULL, 'S', NULL, 0, }; struct MenuItem EinstAendern = { &EinstSpeichern, 1, 1, 152, 10, ITEMTEXT | COMMSEQ | HIGHCOMP | ITEMENABLED, 0L, (APTR)&EinstAendernText, NULL, 'A', NULL, 0, }; struct MenuItem TabellenMnemonics = { NULL, 1, 31, 152, 10, ITEMTEXT | COMMSEQ | HIGHCOMP | ITEMENABLED, 0L, (APTR)&TabellenMnemonicsText, NULL, 'N', NULL, 0, }; struct MenuItem TabellenBloecke = { &TabellenMnemonics, 1, 21, 152, 10, ITEMTEXT | COMMSEQ | HIGHCOMP | ITEMENABLED, 0L, (APTR)&TabellenBloeckeText, NULL, 'B', NULL, 0, }; struct MenuItem TabellenMakros = { &TabellenBloecke, 1, 11, 152, 10, ITEMTEXT | COMMSEQ | HIGHCOMP | ITEMENABLED, 0L, (APTR)&TabellenMakrosText, NULL, 'M', NULL, 0, }; struct MenuItem TabellenLabels = { &TabellenMakros, 1, 1, 152, 10, ITEMTEXT | COMMSEQ | HIGHCOMP | ITEMENABLED, 0L, (APTR)&TabellenLabelsText, NULL, 'L', NULL, 0, }; struct MenuItem DateiEnde = { NULL, 1, 21, 152, 10, ITEMTEXT | COMMSEQ | HIGHCOMP | ITEMENABLED, 0L, (APTR)&DateiEndeText, NULL, 'Q', NULL, 0, }; struct MenuItem DateiInformation = { &DateiEnde, 1, 11, 152, 10, ITEMTEXT | COMMSEQ | HIGHCOMP | ITEMENABLED, 0L, (APTR)&DateiInformationText, NULL, '?', NULL, 0, }; struct MenuItem DateiUebertragen = { &DateiInformation, 1, 1, 152, 10, ITEMTEXT | COMMSEQ | HIGHCOMP | ITEMENABLED, 0L, (APTR)&DateiUebertragenText, NULL, 'T', NULL, 0, }; struct Menu MenuDrucken = { NULL, 314, 0, 88, 0, MENUENABLED, (BYTE *)" Drucken", &DruckenSource }; struct Menu MenuEinstellungen = { &MenuDrucken, 178, 0, 136, 0, MENUENABLED, (BYTE *)" Einstellungen", &EinstAendern }; struct Menu MenuTabellen = { &MenuEinstellungen, 82, 0, 96, 0, MENUENABLED, (BYTE *)" Tabellen", &TabellenLabels }; struct Menu MenuDatei = { &MenuTabellen, 10, 0, 72, 0, MENUENABLED, (BYTE *)" Datei", &DateiUebertragen }; /************************************** * globale Strukturen für Hauptwindow * **************************************/ SHORT Werte1[] = { 0, 62, 0, 0, 376, 0 }; SHORT Werte2[] = { 376, 1, 376, 62, 1, 62 }; SHORT GWerte1[] = { 0, 11, 0, 0, 180, 0 }; SHORT GWerte2[] = { 180, 1, 180, 11, 1, 11 }; struct Border GadgetBorder2 = { 0, 0, 1, 0, JAM1, 3, GWerte2, NULL }; struct Border GadgetBorder1 = { 0, 0, 2, 0, JAM1, 3, GWerte1, &GadgetBorder2 }; struct Border Border2 = { 16, 24, 2, 0, JAM1, 3, Werte2, NULL }; struct Border Border1 = { 16, 24, 1, 0, JAM1, 3, Werte1, &Border2 }; struct IntuiText GadgetText2 = { 1, 0, JAM2, 62, 2, &Font, (UBYTE *)" Stop ", NULL }; struct IntuiText GadgetText1 = { 1, 0, JAM2, 66, 2, &Font, (UBYTE *)"Start", NULL }; struct IntuiText Text7 = { 3, 0, JAM2, 20, 76, NULL, (UBYTE *)" ", NULL }; struct IntuiText Text6 = { 1, 0, JAM2, 20, 66, &Font, (UBYTE *)"Zeile: 000000 Zeilen insg: 000000 Pass: -", &Text7 }; struct IntuiText Text5 = { 1, 0, JAM2, 20, 56, &Font, (UBYTE *)"Anzahl Symbole: 00000 Anzahl Makros: 00000", &Text6 }; struct IntuiText Text4 = { 1, 0, JAM2, 20, 46, &Font, (UBYTE *)"Code: $0000 - $0000 Länge: 00000 Byte", &Text5 }; struct IntuiText Text3 = { 1, 0, JAM2, 20, 36, &Font, (UBYTE *)"Objektdatei: ", &Text4 }; struct IntuiText Text2 = { 1, 0, JAM2, 20, 26, &Font, (UBYTE *)"Quelldatei: ", &Text3 }; struct IntuiText Text1 = { 3, 0, JAM2, 20, 14, &Font, (UBYTE *)"Status:", &Text2 }; struct Gadget Gadget1 = { NULL, 114, 90, 181, 12, GADGHCOMP, RELVERIFY, BOOLGADGET, &GadgetBorder1, NULL, &GadgetText1, NULL, NULL, 1, NULL }; struct NewWindow MainNewWindow = { 116, 50, 408, 108, -1, -1, CLOSEWINDOW | GADGETUP | MENUPICK, WINDOWDEPTH | WINDOWDRAG | WINDOWCLOSE | SMART_REFRESH | ACTIVATE, &Gadget1, NULL, (UBYTE *)"CrossAss V1.0, © 1994 MagnaMedia Verlag AG", NULL, NULL, 116, 50, 408, 140, WBENCHSCREEN }; /***************************************** * globale Strukturen für Tabellenwindow * *****************************************/ char TaText[15][51]; struct IntuiText TaIntuiText[15]; struct IntuiText TaTText = { 1, 0, JAM2, 8, 0, &Font, NULL, NULL }; SHORT TaWerte1[] = { 0, 124, 0, 0, 404, 0 }; SHORT TaWerte2[] = { 404, 1, 404, 124, 1, 124 }; SHORT TaWerte3[] = { 0, 8, 0, 0, 20, 0 }; SHORT TaWerte4[] = { 20, 1, 20, 8, 1, 8 }; SHORT TaWerte5[] = { 0, 106, 0, 0, 20, 0 }; SHORT TaWerte6[] = { 20, 1, 20, 106, 1, 106 }; SHORT TaWerte7[] = { 4, 5, 11, 2, 17, 5 }; SHORT TaWerte8[] = { 4, 3, 11, 6, 17, 3 }; struct IntuiText TaText1 = { 3, 0, JAM2, 8, 12, &Font, (UBYTE *)" ", NULL }; struct Image TaImage1; struct Border TaBorder8 = { 0, 0, 1, 0, JAM1, 3, TaWerte8, NULL }; struct Border TaBorder7 = { 0, 0, 1, 0, JAM1, 3, TaWerte7, NULL }; struct Border TaBorder6 = { 415, 31, 1, 0, JAM1, 3, TaWerte6, NULL }; struct Border TaBorder5 = { 415, 31, 2, 0, JAM1, 3, TaWerte5, &TaBorder6 }; struct Border TaBorder4 = { 0, 0, 1, 0, JAM1, 3, TaWerte4, NULL }; struct Border TaBorder3 = { 0, 0, 2, 0, JAM1, 3, TaWerte3, &TaBorder4 }; struct Border TaBorder2 = { 6, 22, 2, 0, JAM1, 3, TaWerte2, &TaBorder5 }; struct Border TaBorder1 = { 6, 22, 1, 0, JAM1, 3, TaWerte1, &TaBorder2 }; struct PropInfo TaProp1 = { AUTOKNOB | FREEVERT | PROPBORDERLESS, 1, 1, 0x100, 0x100, 0, 0, 0, 0, 0, 0 }; struct Gadget TaGadget3 = { NULL, 416, 32, 19, 105, GADGHCOMP, GADGIMMEDIATE | RELVERIFY, PROPGADGET, &TaImage1, NULL, NULL, NULL, &TaProp1, 3, NULL }; struct Gadget TaGadget2 = { &TaGadget3, 415, 138, 21, 9, GADGHCOMP, GADGIMMEDIATE | RELVERIFY, BOOLGADGET, &TaBorder8, NULL, NULL, NULL, NULL, 2, NULL }; struct Gadget TaGadget1 = { &TaGadget2, 415, 22, 21, 9, GADGHCOMP, GADGIMMEDIATE | RELVERIFY, BOOLGADGET, &TaBorder7, NULL, NULL, NULL, NULL, 1, NULL }; struct NewWindow TableNewWindow = { 95, 50, 441, 150, -1, -1, CLOSEWINDOW | GADGETUP | GADGETDOWN, WINDOWDEPTH | WINDOWDRAG | WINDOWCLOSE | SMART_REFRESH | ACTIVATE, &TaGadget1, NULL, (UBYTE *)"Tabellarische Übersicht", NULL, NULL, 116, 50, 408, 140, WBENCHSCREEN }; /********************************************* * globale Strukturen für Informationswindow * *********************************************/ char ueberschrift[] = " CrossAss Version 1.0"; SHORT InfoWerte1[] = { 6, 52, 6, 15, 353, 15 }; SHORT InfoWerte2[] = { 353, 16, 353, 52, 7, 52 }; SHORT InfoWerte3[] = { 60, 85, 60, 55, 292, 55 }; SHORT InfoWerte4[] = { 292, 56, 292, 85, 61, 85 }; struct Border InfoBorder4 = { 0, 0, 2, 0, JAM1, 3, InfoWerte4, NULL }; struct Border InfoBorder3 = { 0, 0, 1, 0, JAM1, 3, InfoWerte3, &InfoBorder4 }; struct Border InfoBorder2 = { 0, 0, 1, 0, JAM1, 3, InfoWerte2, &InfoBorder3 }; struct Border InfoBorder1 = { 0, 0, 2, 0, JAM1, 3, InfoWerte1, &InfoBorder2 }; struct IntuiText InfoText7 = { 1, 0, JAM2, 8, 74, &Font, (UBYTE *)" ", NULL }; struct IntuiText InfoText6 = { 1, 0, JAM2, 8, 66, &Font, (UBYTE *)" ", &InfoText7 }; struct IntuiText InfoText5 = { 1, 0, JAM2, 8, 58, &Font, (UBYTE *)" ", &InfoText6 }; struct IntuiText InfoText4 = { 3, 0, JAM2, 31, 42, &Font, (UBYTE *)"(C)opyright 1994 MagnaMedia Verlag AG", &InfoText5 }; struct IntuiText InfoText3 = { 3, 0, JAM2, 11, 32, &Font, (UBYTE *)" programmiert von Christian Krenner", &InfoText4 }; struct IntuiText InfoText2 = { 2, 0, JAM1, 11, 18, &Font, (UBYTE *)ueberschrift, &InfoText3 }; struct IntuiText InfoText1 = { 3, 0, JAM2, 13, 19, &Font, (UBYTE *)ueberschrift, &InfoText2 }; struct NewWindow InfoNewWindow = { 136, 55, 360, 90, -1, -1, CLOSEWINDOW, WINDOWDEPTH | WINDOWDRAG | WINDOWCLOSE | SMART_REFRESH | ACTIVATE, NULL, NULL, (UBYTE *)"Informationen", NULL, NULL, 116, 50, 408, 140, WBENCHSCREEN }; /************************************************************* * globale Strukturen für Dateinameneingabe (nur OS 1.2/1.3) * *************************************************************/ char dateistrbuffer[256]; char dateistrundo[256]; SHORT DateiWerte1[] = { 0, 9, 0, 0, 354, 0 }; SHORT DateiWerte2[] = { 354, 1, 354, 9, 1, 9 }; SHORT DateiWerte3[] = { 0, 11, 0, 0, 356, 0 }; SHORT DateiWerte4[] = { 356, 1, 356, 11, 1, 11 }; struct IntuiText DateiText1 = { 1, 0, JAM2, 16, 16, &Font, NULL, NULL }; struct Border DateiBorder4 = { -2, -2, 1, 0, JAM1, 3, DateiWerte4, NULL }; struct Border DateiBorder3 = { -2, -2, 2, 0, JAM1, 3, DateiWerte3, &DateiBorder4 }; struct Border DateiBorder2 = { -1, -1, 2, 0, JAM1, 3, DateiWerte2, &DateiBorder3 }; struct Border DateiBorder1 = { -1, -1, 1, 0, JAM1, 3, DateiWerte1, &DateiBorder2 }; struct StringInfo DateiStringInfo = { dateistrbuffer, dateistrundo, 0, 256, 0, 0, 0, 0, 0, 0, NULL, 0L, NULL }; struct Gadget DateiGadget1 = { NULL, 16, 29, 352, 8, GADGHCOMP, RELVERIFY, STRGADGET, &DateiBorder1, NULL, &DateiText1, NULL, &DateiStringInfo, 1, NULL }; struct NewWindow DateiNewWindow = { 128, 106, 384, 43, -1, -1, CLOSEWINDOW | GADGETUP, WINDOWDEPTH | WINDOWDRAG | WINDOWCLOSE | SMART_REFRESH | ACTIVATE, &DateiGadget1, NULL, (UBYTE *)"Dateinameneingabe", NULL, NULL, 116, 50, 408, 140, WBENCHSCREEN }; /********************************************* * globale Strukturen für Einstellungswindow * *********************************************/ char einst1strbuffer[10], einst2strbuffer[10], einst3strbuffer[10]; char einststrundo[10], einst4strbuffer[8]; SHORT EinstWerte1[] = { 0, 9, 0, 0, 170, 0 }; SHORT EinstWerte2[] = { 170, 1, 170, 9, 1, 9 }; SHORT EinstWerte3[] = { 0, 11, 0, 0, 172, 0 }; SHORT EinstWerte4[] = { 172, 1, 172, 11, 1, 11 }; SHORT EinstWerte5[] = { 0, 9, 0, 0, 98, 0 }; SHORT EinstWerte6[] = { 98, 1, 98, 9, 1, 9 }; SHORT EinstWerte7[] = { 0, 11, 0, 0, 100, 0 }; SHORT EinstWerte8[] = { 100, 1, 100, 11, 1, 11 }; SHORT EinstWerte9[] = { 0, 11, 0, 0, 48, 0 }; SHORT EinstWerte10[] = { 48, 1, 48, 11, 1, 11 }; struct StringInfo Einst4StringInfo = { einst4strbuffer, einststrundo, 0, 7, 0, 0, 0, 0, 0, 0, NULL, 0L, NULL }; struct StringInfo Einst3StringInfo = { einst3strbuffer, einststrundo, 0, 9, 0, 0, 0, 0, 0, 0, NULL, 0L, NULL }; struct StringInfo Einst2StringInfo = { einst2strbuffer, einststrundo, 0, 9, 0, 0, 0, 0, 0, 0, NULL, 0L, NULL }; struct StringInfo Einst1StringInfo = { einst1strbuffer, einststrundo, 0, 9, 0, 0, 0, 0, 0, 0, NULL, 0L, NULL }; struct Border EinstBorder10 = { 0, 0, 1, 0, JAM1, 3, EinstWerte10, NULL }; struct Border EinstBorder9 = { 0, 0, 2, 0, JAM1, 3, EinstWerte9, &EinstBorder10 }; struct Border EinstBorder8 = { -2, -2, 1, 0, JAM1, 3, EinstWerte8, NULL }; struct Border EinstBorder7 = { -2, -2, 2, 0, JAM1, 3, EinstWerte7, &EinstBorder8 }; struct Border EinstBorder6 = { -1, -1, 2, 0, JAM1, 3, EinstWerte6, &EinstBorder7 }; struct Border EinstBorder5 = { -1, -1, 1, 0, JAM1, 3, EinstWerte5, &EinstBorder6 }; struct Border EinstBorder4 = { -2, -2, 1, 0, JAM1, 3, EinstWerte4, NULL }; struct Border EinstBorder3 = { -2, -2, 2, 0, JAM1, 3, EinstWerte3, &EinstBorder4 }; struct Border EinstBorder2 = { -1, -1, 2, 0, JAM1, 3, EinstWerte2, &EinstBorder3 }; struct Border EinstBorder1 = { -1, -1, 1, 0, JAM1, 3, EinstWerte1, &EinstBorder2 }; struct IntuiText EinstText5 = { 1, 0, JAM2, 186, 51, &Font, (UBYTE *)" ", NULL }; struct IntuiText EinstText4 = { 1, 0, JAM2, 186, 28, &Font, (UBYTE *)" ", &EinstText5 }; struct IntuiText EinstText1 = { 1, 0, JAM2, 2, -10, &Font, (UBYTE *)"Einträge Labeltabelle", NULL }; struct IntuiText EinstText2 = { 1, 0, JAM2, 2, -10, &Font, (UBYTE *)"Einträge Makrotabelle", NULL }; struct IntuiText EinstText3 = { 1, 0, JAM2, 2, -10, &Font, (UBYTE *)"Größe Makrospeicher", NULL }; struct IntuiText EinstText7 = { 1, 0, JAM2, 2, -10, &Font, (UBYTE *)"Refresh-Rate", NULL }; struct IntuiText EinstText8 = { 1, 0, JAM2, 70, 2, &Font, (UBYTE *)"OK !", NULL }; struct IntuiText EinstText9 = { 1, 0, JAM2, 8, 2, &Font, (UBYTE *)"Sort", NULL }; struct Gadget EinstGadget6 = { NULL, 238, 90, 49, 12, GADGHCOMP, RELVERIFY | TOGGLESELECT, BOOLGADGET, &EinstBorder9, NULL, &EinstText9, NULL, NULL, 6, NULL }; struct Gadget EinstGadget5 = { &EinstGadget6, 14, 90, 181, 12, GADGHCOMP, RELVERIFY, BOOLGADGET, &GadgetBorder1, NULL, &EinstText8, NULL, NULL, 5, NULL }; struct Gadget EinstGadget4 = { &EinstGadget5, 212, 74, 96, 8, GADGHCOMP, RELVERIFY | STRINGCENTER | LONGINT, STRGADGET, &EinstBorder5, NULL, &EinstText7, NULL, &Einst4StringInfo, 4, NULL }; struct Gadget EinstGadget3 = { &EinstGadget4, 14, 74, 168, 8, GADGHCOMP, RELVERIFY | STRINGCENTER | LONGINT, STRGADGET, &EinstBorder1, NULL, &EinstText3, NULL, &Einst3StringInfo, 3, NULL }; struct Gadget EinstGadget2 = { &EinstGadget3, 14, 51, 168, 8, GADGHCOMP, RELVERIFY | STRINGCENTER | LONGINT, STRGADGET, &EinstBorder1, NULL, &EinstText2, NULL, &Einst2StringInfo, 2, NULL }; struct Gadget EinstGadget1 = { &EinstGadget2, 14, 28, 168, 8, GADGHCOMP, RELVERIFY | STRINGCENTER | LONGINT, STRGADGET, &EinstBorder1, NULL, &EinstText1, NULL, &Einst1StringInfo, 1, NULL }; struct NewWindow EinstNewWindow = { 154, 50, 332, 106, -1, -1, CLOSEWINDOW | GADGETUP, WINDOWDEPTH | WINDOWDRAG | WINDOWCLOSE | SMART_REFRESH | ACTIVATE, &EinstGadget1, NULL, (UBYTE *)"Einstellungen", NULL, NULL, 116, 50, 408, 140, WBENCHSCREEN }; /************************************************** * globale Variablen, Zeiger, Arrays und Tabellen * **************************************************/ VOID *AllocMem(); void *OpenLibrary(); struct Window *OpenWindow(); unsigned long AvailMem(); struct Einstellungen Einst = { 32768L, 128L*(long)sizeof(struct Macro), 2000L*(long)sizeof(struct Label),20,TRUE }; extern struct ExecBase *SysBase; BOOL OS20; BOOL DateiReq(char *filename,char *AnzeigeText,char *Show); extern int Enable_Abort; struct IntuitionBase *IntuitionBase = 0L; struct Window *MainWindow = 0L; struct MacroStack MacroStack[32]; struct MacroStack *MacroPointer; struct Macro *MacroTable = 0L; char *MacroMem = 0L; struct Block BlockTable[32]; char blockcounter = 0; struct IncludeStack IncludeStack[32]; struct IncludeStack *IncludePointer; struct Label *LabelTable = 0L; char workbuffer[256]; char *actposition = 0L; unsigned char mainbuffer[512]; unsigned char outbuffer[512]; unsigned int pos = 0; unsigned long bufferlenght = 512L; unsigned long actlenght = 512L; unsigned long endbuffer = 0L; unsigned int macronumber = 0, actmacro = 0; char *macroup = 0L; unsigned long labelnumber = 0L; struct FileHandle *SourceHandle = 0L; struct FileHandle *ObjectHandle = 0L; struct FileHandle *PrintHandle = 0L; /* struct FileHandle *Open(); */ char mnemonic, pseudo, macro; char test[256], operand[32][80]; unsigned int pc = 0, params[10], start, over, aver; BOOL defd[10], run; unsigned char error = 255; char pass = 0; unsigned long completelines = 0L, lines = 0L; char actname[256], objname[256], srcname[256], prtname[256]; BOOL nerror = FALSE; char *zeiger, label[32], paramcount; unsigned int linelenght = 0; BOOL define = TRUE, prtflag = FALSE, printed = FALSE; unsigned char zeile[256]; unsigned int aufruf; #define MNEMONICS 56 char mnemonics[MNEMONICS][4] = { "LDA", "LDX", "LDY", "STA", "STX", "STY", "TAX", "TAY", "TXA", "TYA", "TXS", "TSX", "PLA", "PHA", "PLP", "PHP", "ADC", "SBC", "INC", "DEC", "INX", "DEX", "INY", "DEY", "AND", "ORA", "EOR", "CMP", "CPX", "CPY", "BIT", "BCC", "BCS", "BEQ", "BNE", "BMI", "BPL", "BVC", "BVS", "JMP", "JSR", "ASL", "LSR", "ROL", "ROR", "CLC", "CLD", "CLI", "CLV", "SEC", "SED", "SEI", "NOP", "RTS", "RTI", "BRK" }; #define PSEUDOS 13 char pseudos[PSEUDOS][11] = { "BYTE", "WORD", "EQUAL", "BASE", "INCLUDE", "IF", "ELSE", "ENDIF", "APPEND", "MACRO", "ENDMACRO", "BLOCK", "ASCII" }; unsigned char opcodes[MNEMONICS][12] = { { 0xa9,0xad,0xbd,0xb9,0xa5,0xb5,0xff,0xa1,0xb1,0xff,0xff,0xff }, { 0xa2,0xae,0xff,0xbe,0xa6,0xff,0xb6,0xff,0xff,0xff,0xff,0xff }, { 0xa0,0xac,0xbc,0xff,0xa4,0xb4,0xff,0xff,0xff,0xff,0xff,0xff }, { 0xff,0x8d,0x9d,0x99,0x85,0x95,0xff,0x81,0x91,0xff,0xff,0xff }, { 0xff,0x8e,0xff,0xff,0x86,0xff,0x96,0xff,0xff,0xff,0xff,0xff }, { 0xff,0x8c,0xff,0xff,0x84,0x94,0xff,0xff,0xff,0xff,0xff,0xff }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xaa }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xa8 }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x8a }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x98 }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x9a }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xba }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x68 }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x48 }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x28 }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x08 }, { 0x69,0x6d,0x7d,0x79,0x65,0x75,0xff,0x61,0x71,0xff,0xff,0xff }, { 0xe9,0xed,0xfd,0xf9,0xe5,0xf5,0xff,0xe1,0xf1,0xff,0xff,0xff }, { 0xff,0xee,0xfe,0xff,0xe6,0xf6,0xff,0xff,0xff,0xff,0xff,0xff }, { 0xff,0xce,0xde,0xff,0xc6,0xd6,0xff,0xff,0xff,0xff,0xff,0xff }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xe8 }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xca }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xc8 }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x88 }, { 0x29,0x2d,0x3d,0x39,0x25,0x35,0xff,0x21,0x31,0xff,0xff,0xff }, { 0x09,0x0d,0x1d,0x19,0x05,0x15,0xff,0x01,0x11,0xff,0xff,0xff }, { 0x49,0x4d,0x5d,0x59,0x45,0x55,0xff,0x41,0x51,0xff,0xff,0xff }, { 0xc9,0xcd,0xdd,0xd9,0xc5,0xd5,0xff,0xc1,0xd1,0xff,0xff,0xff }, { 0xe0,0xec,0xff,0xff,0xe4,0xff,0xff,0xff,0xff,0xff,0xff,0xff }, { 0xc0,0xcc,0xff,0xff,0xc4,0xff,0xff,0xff,0xff,0xff,0xff,0xff }, { 0xff,0x2c,0xff,0xff,0x24,0xff,0xff,0xff,0xff,0xff,0xff,0xff }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x90,0xff,0xff }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xb0,0xff,0xff }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xf0,0xff,0xff }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xd0,0xff,0xff }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x30,0xff,0xff }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x10,0xff,0xff }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x50,0xff,0xff }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x70,0xff,0xff }, { 0xff,0x4c,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x6c,0xff }, { 0xff,0x20,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff }, { 0xff,0x0e,0x1e,0xff,0x06,0x16,0xff,0xff,0xff,0xff,0xff,0x0a }, { 0xff,0x4e,0x5e,0xff,0x46,0x56,0xff,0xff,0xff,0xff,0xff,0x4a }, { 0xff,0x2e,0x3e,0xff,0x26,0x36,0xff,0xff,0xff,0xff,0xff,0x2a }, { 0xff,0x6e,0x7e,0xff,0x66,0x76,0xff,0xff,0xff,0xff,0xff,0x6a }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x18 }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xd8 }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x58 }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xb8 }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x38 }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xf8 }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x78 }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xea }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x60 }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x40 }, { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00 }, }; char laenge[12] = { 2, 3, 3, 3, 2, 2, 2, 2, 2, 2, 3, 1 }; #define ERRORS 66 char errors[ERRORS][47] = { "Fehler beim Lesen der Quelldatei ! ", /* 0 */ "Fehler beim Öffnen der Quell-/Include-Datei !", /* 1 */ "Quellcodezeile zu lang (max. 255 Zeichen) ! ", /* 2 */ "Label bereits definiert ! ", /* 3 */ "Zu viele Operanden (max. 32) ! ", /* 4 */ "Fehlerhafter Label-/Mnemonic-/Makro-Name ! ", /* 5 */ "Labeltabelle voll ! ", /* 6 */ "Operand zu lang (max. 128 Zeichen) ! ", /* 7 */ "Zu viele Includefiles (max. 32) ! ", /* 8 */ "Includefilename fehlt ! ", /* 9 */ "Makroname fehlt ! ", /* 10 */ "Makrotabelle voll ! ", /* 11 */ "Makrospeicher voll ! ", /* 12 */ ".ENDMACRO fehlt ! ", /* 13 */ "Keine Schachtelung von Makrodefinitionen ! ", /* 14 */ "Zu viele Makros (max. 32) ! ", /* 15 */ "Unbekannte Rechenoperation ! ", /* 16 */ "Unerlaubte Ziffer ! ", /* 17 */ "Überlauf (Ergebnis > 65535) ! ", /* 18 */ "Kein .INCLUDE innerhalb Makrodefinition ! ", /* 19 */ "Mnemonic/Pseudoopcode/Makro erwartet ! ", /* 20 */ "Labelname zu lang (max. 32 Zeichen) ! ", /* 21 */ "Zuzuweisender Wert fehlt ! ", /* 22 */ "Labelname fehlt ! ", /* 23 */ "Unbekanntes Label ! ", /* 24 */ "Makroparameter fehlt ! ", /* 25 */ "Unbekannter Makroparameter ! ", /* 26 */ "Makroparameternummer erwartet ! ", /* 27 */ "Term unvollständig ! ", /* 28 */ "Unbekannte Adressierungsart ! ", /* 29 */ "Operand zu lang, Byte erwartet ! ", /* 30 */ "Unerlaubte Adressierungsart ! ", /* 31 */ "Startadresse fehlt ! ", /* 32 */ "Branchsprung außerhalb Reichweite ! ", /* 33 */ "Fehler beim Öffnen der Objektdatei ! ", /* 34 */ "Fehler beim Schreiben in Objektdatei ! ", /* 35 */ "Zu wenig Speicher frei ! ", /* 36 */ "Assemblierung abgebrochen ! ", /* 37 */ ".ENDMACRO ohne .MACRO ! ", /* 38 */ "Filename der Objektdatei fehlt ! ", /* 39 */ ".BASE-Befehl mit Objektdateiname fehlt ! ", /* 40 */ "Vergleichsoperand fehlt ! ", /* 41 */ "Zu viele Makroparameter (max. 10) ! ", /* 42 */ "Kann Window nicht öffnen ! ", /* 43 */ "Fehler beim Abspeichern der Einstellungen ! ", /* 44 */ "Fehler beim Laden der Einstellungen ! ", /* 45 */ "Fehler beim Öffnen des Parallelports ! ", /* 46 */ "Fehler beim Lesen der Objektdatei ! ", /* 47 */ "Fehler beim Senden über Parallelport ! ", /* 48 */ "Übertragung läuft... ", /* 49 */ "ASCII-Zeichen erwartet ! ", /* 50 */ "Fehler in Konvertierungstabellendatei ! ", /* 51 */ "Lade Konvertierungstabelle... ", /* 52 */ "Lade Einstellungsdatei... ", /* 53 */ "Speichere Einstellungsdatei... ", /* 54 */ "Unerlaubte Labelposition ! ", /* 55 */ "Sortiere Labeltabelle... ", /* 56 */ "Quelldateiausdruck angeschaltet... ", /* 57 */ "Quelldateiausdruck ausgeschaltet... ", /* 58 */ "Fehler beim Öffnen der Druckdatei ! ", /* 59 */ "Fehler beim Ausdruck ! ", /* 60 */ "Druck läuft... ", /* 61 */ "Vergleichoperator fehlt ! ", /* 62 */ "Unbekannter/Unerlaubter Vergleichsoperator ! ", /* 63 */ "Division durch 0 ! ", /* 64 */ "Makro bereits definiert ! " /* 65 */ }; unsigned char addr[5][5] = { { '(',',','x',')', 7 }, { '(',')',',','y', 8 }, { 255,255,',','x', 5 }, { 255,255,',','y', 6 }, { '(',255,255,')', 10 } }; /******************** * Programm beenden * ********************/ void freeit() { if(LabelTable) FreeMem(LabelTable, Einst.labellenght); if(MacroMem) FreeMem(MacroMem, Einst.macromemlenght); if(MacroTable) FreeMem(MacroTable, Einst.macrotablelenght); if(SourceHandle) Close(SourceHandle); LabelTable = MacroMem = MacroTable = SourceHandle = 0L; } /*********************************** * Alles öffnen und initialisieren * ***********************************/ BOOL init() { workbuffer[0] = '\0'; if(!(MacroTable = (struct Macro *) AllocMem(Einst.macrotablelenght, MEMF_CLEAR))) { error = 36; return(FALSE); } if(!(MacroMem = (char *) AllocMem(Einst.macromemlenght, MEMF_CLEAR))) { error = 36; return(FALSE); } if(!(LabelTable = (struct Label *) AllocMem(Einst.labellenght, MEMF_CLEAR))) { error = 36; return(FALSE); } return(TRUE); } /************************* * Hauptwindow schließen * *************************/ void closeall() { if(MainWindow) { ClearMenuStrip(MainWindow); CloseWindow(MainWindow); } if(IntuitionBase) CloseLibrary(IntuitionBase); exit(FALSE); } /********************** * Hauptwindow öffnen * **********************/ extern BOOL saveeinst(); extern BOOL loadeinst(); void openall() { register int i; OS20 = (SysBase->LibNode.lib_Version >= 37); if(!(IntuitionBase = (struct IntuitionBase *) OpenLibrary("intuition.library", 0L))) closeall(); Gadget1.GadgetText = &GadgetText1; for(i=0; i<256; i++) Einst.converttable[i] = i; if(!(MainWindow = (struct Window *) OpenWindow(&MainNewWindow))) closeall(); if(!loadeinst()) { error = 255; saveeinst(); } SetMenuStrip(MainWindow, &MenuDatei); DrawBorder(MainWindow->RPort, &Border1, 0L, 0L); prtname[0] = '\0'; } /***************************** * Datei zum Anhängen öffnen * *****************************/ struct FileHandle *append(name) char *name; { struct FileHandle *handle = 0L; if(handle = Open(name, MODE_OLDFILE)) { if(Seek(handle, 0L, 1L) == 1L) { Close(handle); return((struct FileHandle *)0L); } } else { if(!(handle = Open(name, MODE_NEWFILE))) return((struct FileHandle *)0L); } return(handle); } /*********************** * Status neu anzeigen * ***********************/ void refreshstatus() { if((actmacro == macronumber) || !macronumber) { if(actname[0]) sprintf(Text2.IText, "Quelldatei: %-32.32s", actname); else sprintf(Text2.IText, "Quelldatei: --------------------------------"); } else sprintf(Text2.IText, "akt. Makro: %-32.32s", MacroTable[actmacro].name); if(objname[0]) sprintf(Text3.IText, "Objektdatei: %-32.32s", objname); else sprintf(Text3.IText, "Objektdatei: --------------------------------"); sprintf(Text4.IText, "Code: $%04x - $%04x Länge: %05u Byte", start, pc, pc-start); sprintf(Text5.IText, "Anzahl Symbole: %05lu Anzahl Makros: %05u", labelnumber, macronumber); sprintf(Text6.IText, "Zeile: %06lu Zeilen insg: %06lu Pass: -", lines, completelines); if(error == 255) { if(run) sprintf(Text7.IText, "Assemblierung läuft... "); else sprintf(Text7.IText, "Kein Fehler aufgetreten. "); } else sprintf(Text7.IText, "%s", errors[error]); if(pass) Text6.IText[43] = pass+'0'; else Text6.IText[43] = '-'; PrintIText(MainWindow->RPort, &Text1, 0L, 0L); } /*************************************************** * Ausgabe einer unbearbeiteten Zeile für Ausdruck * ***************************************************/ BOOL printline() { char pstring[320]; if(prtflag && (pass == 2)) { printed = TRUE; sprintf(pstring, "%7lu : %04x %s\n", completelines, pc, workbuffer); if((Write(PrintHandle, pstring, (long)strlen(pstring))) != (long)strlen(pstring)) { error = 60; return(FALSE); } } return(TRUE); } /********************************* * Filenamenausgabe für Ausdruck * *********************************/ BOOL printnames() { char text[640]; if(prtflag && (pass == 2)) { sprintf(text, "\nQuelldatei: %s\nObjektdatei: %s\n\n", actname, objname); if((Write(PrintHandle, text, (long)strlen(text))) != (long)strlen(text)) { error = 60; return(FALSE); } } return(TRUE); } /****************** * Zahl ermitteln * ******************/ unsigned int getstatement(); unsigned long searchlabel(); unsigned long getnumber() { char low = 0; register char pot = 10; register unsigned long result = 0L; char label[32], i; nerror = FALSE; if(!*zeiger) { nerror = TRUE; error = 28; return(0); } if(*zeiger == '<') /* Vorzeichen */ { zeiger++; low = 1; } if(*zeiger == '>') { zeiger++; low = 2; } if((*zeiger == '(') || (*zeiger == '[')) /* Terme */ { zeiger++; result = (unsigned long)getstatement(); if(nerror) return(0); goto einsprung; /* Unsauber aber wirkungsvoll */ } if(*zeiger == '*') /* Programmcounter */ { zeiger++; result = (unsigned long)pc; goto einsprung; /* siehe oben */ } if(*zeiger == '?') /* Makroparameter */ { zeiger++; if((!*zeiger) || (!isdigit(*zeiger))) { nerror = TRUE; error = 27; return(0); } i = *zeiger - '0'; zeiger++; if(i >= paramcount) { nerror = TRUE; error = 26; return(0); } if(!defd[i]) { error = 24; nerror = TRUE; return(0); } result = (unsigned long)params[i]; goto einsprung; /* siehe oben */ } if(*zeiger == '\'') /* ASCII-Wert (konvertiert) */ { zeiger++; if(!*zeiger) { nerror = TRUE; error = 50; return(0); } result = (long)(Einst.converttable[*zeiger]); zeiger++; goto einsprung; } if(isalpha(*zeiger)) /* Labelwerte */ { i = 0; do { label[i] = *zeiger; i++; zeiger++; } while((i<32) && (isdigit(*zeiger) || isalpha(*zeiger) || (*zeiger == '_'))); if(i==32) { error = 21; nerror = TRUE; return(0); } label[i] = 0; if((result = searchlabel(label)) == labelnumber) { error = 24; nerror = TRUE; return(0); } result = (unsigned long)LabelTable[result].wert; goto einsprung; /* siehe oben */ } switch(*zeiger) /* Hex-, Dez-, Binär und Oktalzahlen */ { case '$': pot = 16; zeiger++; break; case '%': pot = 2; zeiger++; break; case '&': pot = 8; zeiger++; break; } do { if(isalpha(*zeiger)) { if((pot != 16) || (toupper(*zeiger) > 'F')) { error = 17; nerror = TRUE; return(0); } result = result * 16L + (long)(toupper(*zeiger) - 'A' + 10); } if(isdigit(*zeiger)) { if((*zeiger-'0') >= pot) { error = 17; nerror = TRUE; return(0); } result = result * (long)pot + (long)(toupper(*zeiger) - '0'); } zeiger++; } while(isdigit(*zeiger) || isalpha(*zeiger)); einsprung: if(result > 65535) { error = 18; nerror = TRUE; return(0); } if(low == 1) return(result - 256L * (result / 256L)); if(low == 2) return(result / 256L); return(result); } /****************** * Term berechnen * ******************/ unsigned int getstatement() { register unsigned long result = 0L, zresult; char rechenz = '+', nrechenz = '*'; unsigned long w; while(*zeiger && (rechenz != ')') && (rechenz != ']')) { zresult = 1L; nrechenz = '*'; do { switch(nrechenz) { case '*': zresult *= getnumber(); break; case '/': if(!(w = getnumber())) { nerror = TRUE; error = 64; return(0); } zresult /= w; break; } if(nerror) return(0); nrechenz = *zeiger; if(*zeiger) zeiger++; } while((nrechenz == '*') || (nrechenz == '/')); if(nrechenz) zeiger--; switch(rechenz) { case '+': result += zresult; break; case '-': result -= zresult; break; case '|': result |= zresult; break; case '&': result &= zresult; break; case '<': result <<= zresult; break; case '>': result >>= zresult; break; default: error = 16; nerror = TRUE; return(0); } rechenz = *zeiger; if(rechenz) zeiger++; } if(result > 65535L) { error = 18; nerror = TRUE; return(0); } nerror = FALSE; return((unsigned int)result); } /*********************** * Buffer neu einlesen * ***********************/ BOOL readbuffer() { actlenght = Read(SourceHandle, mainbuffer, bufferlenght); if(IoErr() >= 100) return(FALSE); endbuffer = mainbuffer+actlenght; actposition = mainbuffer; return(TRUE); } /************************** * Zeile aus Buffer holen * **************************/ BOOL getline() { register char counter = 0; char i; while(((*actposition != 0x0a) && (counter < 255)) || (actposition == (char *)endbuffer)) { if(actposition == (char *)endbuffer) { if(actlenght == bufferlenght) { if(!readbuffer()) return(FALSE); continue; } else { if(MacroPointer == MacroStack) { actmacro = macronumber; if(SourceHandle) Close(SourceHandle); SourceHandle = 0L; if(IncludePointer == IncludeStack) return(FALSE); IncludePointer--; strcpy(actname, IncludePointer->lastfile); if(!(SourceHandle = (struct FileHandle *) Open(actname, (ULONG)MODE_OLDFILE))) { error = 1; return(FALSE); } lines = 0L; if(!readbuffer()) return(FALSE); while(lines < (IncludePointer->lineafter)) { if(!getline()) return(FALSE); completelines--; } if(!printnames()) return(FALSE); continue; } else { MacroPointer--; actposition = MacroPointer->pointer; endbuffer = MacroPointer->endbuffer; actlenght = MacroPointer->actlenght; actmacro = MacroPointer->number; lines = MacroPointer->lineafter; paramcount = MacroPointer->paramcount; aufruf = MacroPointer->aufruf; for(i=0; iparams[i]; defd[i] = MacroPointer->defd[i]; } continue; } } } workbuffer[counter] = *actposition; counter++; actposition++; } if(counter == 255) { error = 2; return(FALSE); } workbuffer[counter] = 0; completelines++; lines++; actposition++; return(TRUE); } /**************** * Label suchen * ****************/ unsigned long searchlabel(name) char *name; { register unsigned long number = 0L; while(number < labelnumber) { if(!strcmp(LabelTable[number].name, name)) { if(LabelTable[number].aufruf == 0) return(number); if((LabelTable[number].macro == actmacro) && (LabelTable[number].aufruf == aufruf)) return(number); } number++; } return(labelnumber); } /******************* * Mnemonic suchen * *******************/ char searchmnemonic(source) char *source; { register char number = 0, i = 0; while(number < MNEMONICS) { for(i=0;(i<4) && (toupper(source[i]) == mnemonics[number][i]);i++) ; if(i==4) return(number); number++; } return(MNEMONICS); } /*********************** * Pseudoopcode suchen * ***********************/ char searchpseudo(source) char *source; { register char number = 0, i = 0; if(source[0] != '.') return(PSEUDOS); while(number < PSEUDOS) { i=1; while((source[i]) && (toupper(source[i]) == pseudos[number][i-1]) && (i<11)) i++; if(i==11) break; if(!source[i]) return(number); number++; } return(PSEUDOS); } /**************** * Makro suchen * ****************/ unsigned int searchmacro(source) char *source; { register char i = 0; register unsigned int number = 0; while(number < macronumber) { i=0; while((source[i]) && (MacroTable[number].name[i]) && (source[i] == MacroTable[number].name[i])) i++; if((!source[i]) && (!MacroTable[number].name[i])) return(number); number++; } return(macronumber); } /************************** * Neues Label definieren * **************************/ BOOL definelabel(name, number) char *name; unsigned int number; { if(searchlabel(name) != labelnumber) { error = 3; return(FALSE); } if(((labelnumber+1L) * sizeof(struct Label)) >= Einst.labellenght) { error = 6; return(FALSE); } strcpy(LabelTable[labelnumber].name, name); LabelTable[labelnumber].wert = number; if(actmacro != macronumber) { LabelTable[labelnumber].aufruf = aufruf; LabelTable[labelnumber].macro = actmacro; } else { LabelTable[labelnumber].aufruf = 0; LabelTable[labelnumber].macro = 65535; } labelnumber++; return(TRUE); } /********************************** * Zeile in Bestandteile auflösen * **********************************/ BOOL divideline() { register int i, u; register char *pointer = workbuffer; BOOL flag = TRUE; BOOL quote = FALSE; mnemonic = pseudo = macro = 0; test[0] = label[0] = '\0'; for(i=0; i<32; i++) operand[i][0] = '\0'; while(flag) { flag = FALSE; i=0; while((*pointer == ' ') || (*pointer == 0x09)) pointer++; if(isdigit(*pointer)) { error = 5; return(FALSE); } while((*pointer) && (*pointer != ';') && (*pointer != ' ') && (*pointer != 0x09)) { test[i] = *pointer; i++; pointer++; } test[i] = '\0'; macro = macronumber; mnemonic = MNEMONICS; pseudo = PSEUDOS; if(!test[0] && !label[0]) return(TRUE); if(!test[0] && label[0]) { error = 20; return(FALSE); } if(((macro = searchmacro(test))==macronumber) && ((mnemonic = searchmnemonic(test))==MNEMONICS) && ((pseudo = searchpseudo(test))==PSEUDOS)) { flag = TRUE; if(label[0]) { error = 20; return(FALSE); } strcpy(label, test); if(strlen(label) >= 32) { error = 21; return(FALSE); } } } if(label[0] && (((pseudo >= 3) && (pseudo <= 8)) || (pseudo == 9) || (pseudo == 10))) { error = 55; return(FALSE); } if((pass == 1) && (pseudo != 2) && (label[0]) && define) if(!definelabel(label, pc)) return(FALSE); i = u = 0; if(*pointer) { pointer++; while((*pointer) && (*pointer != ';')) { if(*pointer == '\"') { quote = (quote) ? FALSE : TRUE; pointer++; continue; } if((*pointer == ',') && (mnemonic == MNEMONICS) && (!quote)) { operand[u][i] = '\0'; pointer++; u++; i=0; if(u>31) { error = 4; return(FALSE); } continue; } if(((*pointer != ' ') && (*pointer != 0x09)) || (quote)) { operand[u][i] = *pointer; i++; if(i == 80) { error = 7; return(FALSE); } } pointer++; } operand[u][i] = '\0'; } return(TRUE); } /**************************************** * Aktuellen Block in Tabelle eintragen * ****************************************/ void remarkblock() { register int i; if((blockcounter < 32) && (objname[0]) && (pass == 1)) { BlockTable[blockcounter].begin = start; BlockTable[blockcounter].end = pc; for(i=0;(i<31) && objname[i];i++) BlockTable[blockcounter].name[i] = objname[i]; BlockTable[blockcounter].name[i] = '\0'; blockcounter++; } } /***************************** * Pseudo-Opcodes bearbeiten * *****************************/ BOOL outbytes(); BOOL dopseudos() { register unsigned char i; register unsigned int wert, anzahl; switch(pseudo) { case 0: /* .BYTE */ { i = 0; while((operand[i][0]) && (i<32)) { zeiger = operand[i]; if(pass == 1) wert = 0; else wert = getstatement(); if(nerror) { error = 255; wert = 0; } if(wert > 255) { error = 30; return(FALSE); } zeile[i] = (unsigned char)wert; i++; } linelenght = i; return(TRUE); } case 1: /* .WORD */ { i = linelenght = 0; while((operand[i][0]) && (i<32)) { zeiger = operand[i]; if(pass == 1) wert = 1; else wert = getstatement(); if(nerror) { error = 255; wert = 0; } zeile[linelenght] = (unsigned char)(wert - 256 * (wert / 256)); zeile[linelenght+1] = (unsigned char)(wert / 256); linelenght += 2; i++; } return(TRUE); } case 2: /* .EQUAL */ { if(pass == 2) return(TRUE); if(!operand[0][0]) { error = 22; return(FALSE); } if(!label[0]) { error = 23; return(FALSE); } zeiger = operand[0]; wert = getstatement(); if(nerror) return(FALSE); if(!definelabel(label, wert)) return(FALSE); return(TRUE); } case 3: /* .BASE */ { if(!operand[0][0]) { error = 32; return(FALSE); } if(!operand[1][0]) { error = 39; return(FALSE); } remarkblock(); strcpy(objname, operand[1]); zeiger = operand[0]; start = getstatement(); if(nerror) return(FALSE); if(!printline()) return(FALSE); if(!printnames()) return(FALSE); pc = start; if(pass == 2) { if(ObjectHandle) { if(Write(ObjectHandle, outbuffer, (long)pos) != (long)pos) { error = 36; return(FALSE); } Close(ObjectHandle); } if(!(ObjectHandle = (struct FileHandle *) Open(objname, (ULONG)MODE_NEWFILE))) { error = 34; return(FALSE); } outbuffer[0] = (unsigned char)(start - 256 * (start / 256)); outbuffer[1] = (unsigned char)(start / 256); pos = 2; } return(TRUE); } case 4: /* .INCLUDE */ { if(!operand[0][0]) { error = 9; return(FALSE); } if(IncludePointer == &IncludeStack[32]) { error = 8; return(FALSE); } Close(SourceHandle); SourceHandle = 0L; strcpy(IncludePointer->lastfile, actname); IncludePointer->lineafter = lines; IncludePointer++; strcpy(actname, operand[0]); if(!(SourceHandle = (struct FileHandle *) Open(actname, (ULONG)MODE_OLDFILE))) { error = 1; return(FALSE); } lines = 0L; if(!readbuffer()) return(FALSE); if(!printline()) return(FALSE); if(!printnames()) return(FALSE); return(TRUE); } case 5: /* .IF */ case 6: /* .ELSE */ { i = 0; if(pseudo == 5) { if(!operand[0][0]) { error = 62; return(FALSE); } if(!operand[1][0]) { error = 41; return(FALSE); } zeiger = operand[1]; wert = getstatement(); if(!operand[2][0]) { switch(operand[0][0]) { case '=': if(!nerror) return(TRUE); else { nerror = FALSE; error = 255; } break; case '!': if(nerror) { nerror = FALSE; error = 255; return(TRUE); } break; default: error = 63; return(FALSE); } } else { if(nerror) return(FALSE); zeiger = operand[2]; anzahl = getstatement(); if(nerror) return(FALSE); switch(operand[0][0]) { case '=': if(wert == anzahl) return(TRUE); break; case '!': if(wert != anzahl) return(TRUE); break; case '<': if(wert < anzahl) return(TRUE); break; case '>': if(wert > anzahl) return(TRUE); break; default: error = 63; return(FALSE); } } i = 1; } anzahl = pseudo = 0; define = FALSE; if(!printline()) return(FALSE); do { if(pseudo == 5) anzahl++; if(pseudo == 7) anzahl--; if(!getline()) return(FALSE); if(!divideline()) return(FALSE); if(!printline()) return(FALSE); if(pseudo == 8) { if(!dopseudos()) return(FALSE); continue; } } while(anzahl || ((i) ? ((pseudo != 6) && (pseudo != 7)) : (pseudo != 7))); define = TRUE; return(TRUE); } case 8: /* .APPEND */ { Close(SourceHandle); SourceHandle = 0L; if(!operand[0][0]) { error = 9; return(FALSE); } strcpy(actname, operand[0]); if(!(SourceHandle = (struct FileHandle *) Open(actname, (ULONG)MODE_OLDFILE))) { error = 1; return(FALSE); } lines = 0L; if(!readbuffer()) return(FALSE); if(!printline()) return(FALSE); if(!printnames()) return(FALSE); return(TRUE); } case 9: /* .MACRO / .ENDMACRO */ { if(pass != 1) { if(!printline()) return(FALSE); printed = FALSE; while(pseudo != 10) { if(!getline()) { error = 13; return(FALSE); } if(!divideline()) return(FALSE); if(pseudo == 8) { if(!dopseudos()) return(FALSE); continue; } } return(TRUE); } define = FALSE; if(!operand[0][0]) { error = 10; return(FALSE); } if(((macronumber+1) * sizeof(struct Macro)) > Einst.macrotablelenght) { error = 11; return(FALSE); } if(searchmacro(operand[0]) != macronumber) { error = 65; return(FALSE); } zeiger = operand[1]; wert = getstatement(); if(wert > 10) { error = 42; return(FALSE); } MacroTable[macronumber].paramcount = (char)wert; if(nerror) return(FALSE); MacroTable[macronumber].source = macroup; strcpy(MacroTable[macronumber].name, operand[0]); MacroTable[macronumber].aufruf = 0; i = 0; workbuffer[i] = 0; if(!printline()) return(FALSE); printed = FALSE; while((macroup-MacroMem) < Einst.macromemlenght) { if(!workbuffer[i]) { i = 0; if(!getline()) { error = 13; return(FALSE); } if(!divideline()) return(FALSE); if(pseudo == 10) break; if(pseudo == 9) { error = 14; return(FALSE); } if(pseudo == 4) { error = 19; return(FALSE); } if(pseudo == 8) { if(!dopseudos()) return(FALSE); continue; } } *macroup = workbuffer[i]; macroup++; i++; if(!workbuffer[i]) { *macroup = 0x0a; macroup++; } } if((macroup-MacroMem) == Einst.macromemlenght) { error = 12; return(FALSE); } MacroTable[macronumber].lenght = macroup - MacroTable[macronumber].source; macronumber++; actmacro = macronumber; define = TRUE; return(TRUE); } case 10: /* .ENDMACRO (ohne .MACRO !) */ { error = 38; return(FALSE); } case 11: /* .BLOCK */ { zeiger = operand[0]; anzahl = getstatement(); zeiger = operand[1]; wert = getstatement(); if(wert > 255) { error = 30; return(FALSE); } linelenght = 0; if(pass == 2) { while(anzahl > 3) { zeile[0] = (unsigned char)wert; linelenght = 1; if(!outbytes()) return(FALSE); pc++; anzahl--; } linelenght = anzahl; for(;anzahl > 0;anzahl--) zeile[anzahl-1] = (unsigned char)wert; } else pc += anzahl; return(TRUE); } case 12: /* .ASCII */ { zeiger = operand[0]; linelenght = 0; while(*zeiger) { zeile[linelenght] = Einst.converttable[*zeiger]; linelenght++; zeiger++; } return(TRUE); } } } /******************* * Macro ausführen * *******************/ BOOL domacro() { register char i; /* unsigned int wert; not used */ struct MacroStack help; if(MacroPointer == &MacroStack[32]) { error = 15; return(FALSE); } MacroPointer->pointer = actposition; for(i=0;i<10;i++) { MacroPointer->params[i] = params[i]; MacroPointer->defd[i] = defd[i]; help.params[i] = 0; help.defd[i] = FALSE; } MacroPointer->lineafter = lines; MacroPointer->endbuffer = (char *)endbuffer; MacroPointer->actlenght = actlenght; MacroPointer->paramcount = paramcount; MacroPointer->number = actmacro; MacroPointer->aufruf = aufruf; MacroPointer++; actposition = MacroTable[macro].source; actlenght = MacroTable[macro].lenght; endbuffer = actposition + actlenght; help.paramcount = MacroTable[macro].paramcount; MacroTable[macro].aufruf++; aufruf = MacroTable[macro].aufruf; for(i=0; i 6) && (pass == 1)) ? 0 : getstatement(); if(nerror) { if((pass != 1) || (error != 24)) return(FALSE); else { error = 255; oper = 65535; } } if((oper > 255) || (operand[0][0] == '!')) { switch(adr) { case 4: adr = 1; if(opcodes[mnemonic][adr] == 0xff) adr = 9; break; case 5: adr = 2; break; case 6: adr = 3; break; case 0: case 7: case 8: if(pass == 2) { error = 30; return(FALSE); } } } else { if((adr == 4) && (opcodes[mnemonic][adr] == 0xff)) if(opcodes[mnemonic][1] == 0xff) adr = 9; else adr = 1; } if(opcodes[mnemonic][adr] == 0xff) { error = 31; return(FALSE); } linelenght = laenge[adr]; over = oper; aver = adr; return(TRUE); } /******************************* * Opcodes für Zeile erstellen * *******************************/ BOOL makebytes() { zeile[0] = opcodes[mnemonic][aver]; if(aver == 11) return(TRUE); if(aver != 9) { zeile[1] = (unsigned char)(over - 256 * (over / 256)); zeile[2] = (unsigned char)(over / 256); } else { if((over > (pc+2)) ? ((over-pc)>129) : ((pc-over)>126)) { error = 33; return(FALSE); } zeile[1] = (unsigned char)(over - (pc + 2)); } return(TRUE); } /********************************** * Bytes in Objektdatei speichern * **********************************/ BOOL outbytes() { register char i = 0; while(ilastfile, dateistrbuffer); IncludePointer->lineafter = 0L; IncludePointer++; endbuffer = (LONG) mainbuffer; actposition = (char *)endbuffer; actlenght = 0L; *mainbuffer = 0; while(getline()) { num[0][0] = num[1][0] = '\0'; zeiger = workbuffer; if(*zeiger == ';') continue; for(i=0; i<2; i++) { while((*zeiger == ' ') || (*zeiger == 0x09)) zeiger++; u = 0; while((*zeiger != ' ') && (*zeiger != 0x09) && (*zeiger)) { num[i][u] = *zeiger; u++; zeiger++; } num[i][u] = '\0'; } zeiger = num[0]; number1 = getnumber(); if(nerror) break; zeiger = num[1]; number2 = getnumber(); if(nerror) break; for(i=(unsigned int)number1; i<256; i++, number2++) Einst.converttable[i] = (unsigned char)number2; } if(SourceHandle) Close(SourceHandle); SourceHandle = 0L; actname[0] = '\0'; lines = completelines = 0L; return(TRUE); } /*********************** * Einstellungen laden * ***********************/ BOOL loadeinst() { struct FileHandle *EinstHandle; error = 53; refreshstatus(); error = 255; if(!(EinstHandle = (struct FileHandle *) Open("s:CA.prefs", MODE_OLDFILE))) { error = 45; return(FALSE); } if(Read(EinstHandle, &Einst, (long)sizeof(struct Einstellungen)) != (long)sizeof(struct Einstellungen)) { error = 45; Close(EinstHandle); return(FALSE); } Close(EinstHandle); return(TRUE); } /****************************************** * Pass 1 : Labeldefinitionen durchführen * ******************************************/ void passone() { register unsigned int oldmacro = 0, dejafait = 0; struct Message *GetMsg(); struct IntuiMessage *message; ULONG MessageClass; SourceHandle = 0L; MacroPointer = MacroStack; IncludePointer = IncludeStack; strcpy(IncludePointer->lastfile, srcname); IncludePointer->lineafter = 0L; IncludePointer++; endbuffer = (LONG) mainbuffer; actposition = (char *)endbuffer; *mainbuffer = 0; actlenght = 0L; macroup = MacroMem; labelnumber = 0L; macronumber = blockcounter = actmacro = 0; paramcount = 0; for(oldmacro = 0; oldmacro < 10; oldmacro++) params[oldmacro] = 0; aufruf = 0; oldmacro = 0; pass = 1; completelines = lines = 0L; start = pc = 0xc000; define = TRUE; refreshstatus(); FOREVER { if(dejafait == Einst.delay) { dejafait = 0; refreshstatus(); if(message = (struct IntuiMessage *) GetMsg(MainWindow->UserPort)) { MessageClass = message->Class; ReplyMsg(message); if(MessageClass == GADGETUP) { error = 37; break; } } } dejafait++; linelenght = 0; if(!getline()) break; if(!divideline()) break; oldmacro = macronumber; if(pseudo != PSEUDOS) { if(!dopseudos()) break; pc += linelenght; } if(mnemonic != MNEMONICS) { if(!assline()) break; pc += linelenght; } if(macro != oldmacro) if(!domacro()) break; } remarkblock(); } /************************************************** * Pass 2 : Eigentliche Assemblierung durchführen * **************************************************/ void passtwo() { register unsigned int i = 0, dejafait = 0; struct Message *GetMsg(); struct IntuiMessage *message; ULONG MessageClass; char pstring[320]; unsigned int oldpc; SourceHandle = ObjectHandle = 0L; MacroPointer = MacroStack; IncludePointer = IncludeStack; strcpy(IncludePointer->lastfile, srcname); IncludePointer->lineafter = 0L; IncludePointer++; endbuffer = (LONG) mainbuffer; actposition = (char *)endbuffer; *mainbuffer = 0; actlenght = 0L; paramcount = pos = 0; objname[0] = '\0'; for(i = 0; i < 10; i++) params[i] = 0; aufruf = 0; for(i = 0; i < macronumber; i++) MacroTable[i].aufruf = 0; pass = 2; completelines = lines = 0L; pc = start; define = TRUE; refreshstatus(); FOREVER { printed = FALSE; if(dejafait == Einst.delay) { dejafait = 0; refreshstatus(); if(message = (struct IntuiMessage *) GetMsg(MainWindow->UserPort)) { MessageClass = message->Class; ReplyMsg(message); if(MessageClass == GADGETUP) { error = 37; break; } } } dejafait++; linelenght = 0; oldpc = pc; if(!getline()) break; if(!divideline()) break; if(pseudo != PSEUDOS) { if(!dopseudos()) break; pc += linelenght; if(!outbytes()) break; } if(mnemonic != MNEMONICS) { if(!assline()) break; if(!makebytes()) break; pc += linelenght; if(!outbytes()) break; } if(macro != macronumber) { if(!domacro()) break; } if(prtflag && !printed) { sprintf(pstring, "%7lu : %04x ", completelines, oldpc); for(i=0; i<((linelenght > 3) ? 3 : linelenght); i++) sprintf(&pstring[15+i*3], "%02x ", zeile[i]); for(;i<3;i++) sprintf(&pstring[15+i*3], " "); sprintf(&pstring[24], "%s\n", workbuffer); if((Write(PrintHandle, pstring, (long)strlen(pstring))) != (long)strlen(pstring)) { error = 60; break; } } } if(error == 255) { if(ObjectHandle) { if(Write(ObjectHandle, outbuffer, (long)pos) != (long)pos) error = 36; } else error = 40; } if(ObjectHandle) { Close(ObjectHandle); ObjectHandle = 0L; } } /********************** * Informationswindow * **********************/ BOOL information() { struct Window *InfoWindow; struct Message *GetMsg(); struct IntuiMessage *message; sprintf(InfoText5.IText, " Labeltabelle: %8lu Byte", Einst.labellenght); sprintf(InfoText6.IText, " Makrotabelle: %8lu Byte", Einst.macrotablelenght); sprintf(InfoText7.IText, " Makrospeicher: %8lu Byte", Einst.macromemlenght); InfoNewWindow.LeftEdge = MainWindow->LeftEdge+20; InfoNewWindow.TopEdge = MainWindow->TopEdge+5; if(!(InfoWindow = (struct Window *) OpenWindow(&InfoNewWindow))) { error = 43; return(FALSE); } PrintIText(InfoWindow->RPort, &InfoText1, 0L, 0L); DrawBorder(InfoWindow->RPort, &InfoBorder1, 0L, 0L); WaitPort(InfoWindow->UserPort); message = (struct IntuiMessage *)GetMsg(InfoWindow->UserPort); ReplyMsg(message); CloseWindow(InfoWindow); return(TRUE); } /********************* * Dateinameneingabe * *********************/ BOOL getname(uebersch, string) char *uebersch, *string; { struct Window *DateiWindow; struct Message *GetMsg(); struct IntuiMessage *message; USHORT MessageClass; if (OS20) { if (DateiReq(string,uebersch,"~(#?.info)")) { strcpy(dateistrbuffer,string); return TRUE; } else return FALSE; } DateiNewWindow.LeftEdge = MainWindow->LeftEdge+12; DateiNewWindow.TopEdge = MainWindow->TopEdge+56; DateiText1.IText = uebersch; strcpy(dateistrbuffer, string); DateiStringInfo.BufferPos = strlen(string); if(!(DateiWindow = (struct Window *) OpenWindow(&DateiNewWindow))) { error = 43; return(FALSE); } PrintIText(DateiWindow->RPort, &DateiText1, 0L, 0L); ActivateGadget(&DateiGadget1, DateiWindow, NULL); WaitPort(DateiWindow->UserPort); message = GetMsg(DateiWindow->UserPort); MessageClass = message->Class; ReplyMsg(message); CloseWindow(DateiWindow); return((MessageClass & GADGETUP) ? TRUE : FALSE); } /************************** * Objektdatei übertragen * **************************/ BOOL transfer() { struct FileHandle *ParHandle = 0L; unsigned long lenght = 512L; error = 255; if(!getname("Zu übertragende Datei:", objname)) return(FALSE); if(!(ObjectHandle = (struct FileHandle *) Open(dateistrbuffer, MODE_OLDFILE))) { error = 34; return(FALSE); } if(!(ParHandle = (struct FileHandle *) Open("par:", MODE_OLDFILE))) { error = 46; return(FALSE); } error = 49; refreshstatus(); error = 255; while(lenght == 512L) { lenght = Read(ObjectHandle, outbuffer, 512L); if(IoErr() > 100) { error = 47; break; } if(Write(ParHandle, outbuffer, lenght) != lenght) { error = 48; break; } } Close(ObjectHandle); Close(ParHandle); return((error == 255) ? TRUE : FALSE); } /*********************** * Source-Code drucken * ***********************/ BOOL printsource() { prtflag = (prtflag) ? FALSE : TRUE; if(prtflag) { if(!(getname("Druckdatei:", prtname))) { prtflag = FALSE; return(FALSE); } strcpy(prtname, dateistrbuffer); error = 57; } else error = 58; return(FALSE); } /*********************** * Tabellen ausdrucken * ***********************/ BOOL printtabs(number) char number; { char pstring[100], pstring2[100], pstring3[100]; register unsigned long counter, end; if(!(getname("Druckdatei:", prtname))) return(FALSE); strcpy(prtname, dateistrbuffer); if(!(PrintHandle = append(prtname))) error = 59; error = 61; refreshstatus(); pstring[0] = pstring2[0] = pstring3[0] = '\0'; switch(number) { case 0: end = (unsigned long)labelnumber; sprintf(pstring, "\nLabeltabelle: %lu Einträge\n\n", (unsigned long)labelnumber); if(end) { strcpy(pstring2, "Labelname dez. hex.\n"); strcpy(pstring3, "---------------------------------------------\n"); } break; case 1: end = (unsigned long)macronumber; sprintf(pstring, "\nMakrotabelle: %lu Einträge\n\n", (unsigned long)macronumber); if(end) { strcpy(pstring2, "Makroname Länge Parameter\n"); strcpy(pstring3, "--------------------------------------------------\n"); } break; case 2: end = (unsigned long)blockcounter; sprintf(pstring, "\nBlocktabelle: %u Einträge\n\n", blockcounter); if(end) { strcpy(pstring2, "von bis von bis Länge Dateinamen\n"); strcpy(pstring3, "--------------------------------------------------------------------\n"); } break; } if(((Write(PrintHandle, pstring, (long)strlen(pstring))) != (long)strlen(pstring)) || ((Write(PrintHandle, pstring2, (long)strlen(pstring2))) != (long)strlen(pstring2)) || ((Write(PrintHandle, pstring3, (long)strlen(pstring3))) != (long)strlen(pstring3))) { error = 60; Close(PrintHandle); return(FALSE); } for(counter = 0L; counter 1L) { for(i=1L; i 0) { LabelTable[j-1L] = helplabel; break; } } } } } error = 255; refreshstatus(); } /**************************** * Alle Texte neu schreiben * ****************************/ void redrawit(upper, number) unsigned long upper; USHORT number; { register unsigned long i = 0; register int u; for(i=0; i<15; i++) { switch(number) { case 0: if((i+upper) < labelnumber) sprintf(TaText[i], "%-32.32s %5u $%04x", LabelTable[i+upper].name, LabelTable[i+upper].wert, LabelTable[i+upper].wert); else strcpy(TaText[i], " "); break; case 1: if((i+upper) < (unsigned long)macronumber) sprintf(TaText[i], "%-32.32s %5lu %2u", MacroTable[i+upper].name, MacroTable[i+upper].lenght, MacroTable[i+upper].paramcount); else strcpy(TaText[i], " "); break; case 2: if((i+upper) < (unsigned long)blockcounter) sprintf(TaText[i], "%04x-%04x %5u %-32.32s", BlockTable[i+upper].begin, BlockTable[i+upper].end, (BlockTable[i+upper].end-BlockTable[i+upper].begin), BlockTable[i+upper].name); else strcpy(TaText[i], " "); break; case 3: if((i+upper) < (unsigned long)MNEMONICS) { sprintf(TaText[i], "%3.3s ", mnemonics[i+upper]); for(u=0; u<12; u++) TaText[i][5+u*4] = (opcodes[i+upper][u] == 0xff) ? ' ' : '*'; } else strcpy(TaText[i], " "); break; } } } /*********************** * Einstellungenwindow * ***********************/ BOOL doeinstellungen() { struct Window *EinstWindow; struct Message *GetMsg(); struct IntuiMessage *message; struct Einstellungen Ein; ULONG MessageClass = 0L, freechip = 0L, freefast = 0L; USHORT GadgetID = 0; BOOL refr = TRUE; Ein = Einst; sprintf(einst1strbuffer, "%lu", (Einst1StringInfo.LongInt = Ein.labellenght/(long)sizeof(struct Label))); sprintf(einst2strbuffer, "%lu", (Einst1StringInfo.LongInt = Ein.macrotablelenght/(long)sizeof(struct Macro))); sprintf(einst3strbuffer, "%lu", Ein.macromemlenght); sprintf(einst4strbuffer, "%u", Ein.delay); Einst1StringInfo.BufferPos = strlen(einst1strbuffer); Einst2StringInfo.BufferPos = strlen(einst2strbuffer); Einst3StringInfo.BufferPos = strlen(einst3strbuffer); Einst4StringInfo.BufferPos = strlen(einst4strbuffer); if(Ein.sort) EinstGadget6.Flags |= SELECTED; else EinstGadget6.Flags &= ~SELECTED; freechip = (unsigned long)AvailMem(MEMF_CHIP | MEMF_LARGEST); freefast = (unsigned long)AvailMem(MEMF_FAST | MEMF_LARGEST); if(!(EinstWindow = (struct Window *) OpenWindow(&EinstNewWindow))) { error = 43; return(FALSE); } PrintIText(EinstWindow->RPort, &EinstText4, 0L, 0L); ActivateGadget(&EinstGadget1, EinstWindow, NULL); while((MessageClass != CLOSEWINDOW) && (GadgetID != 5)) { if(refr) { refr = FALSE; sprintf(EinstText4.IText, " = %8lu Byte", Ein.labellenght); sprintf(EinstText5.IText, " = %8lu Byte", Ein.macrotablelenght); PrintIText(EinstWindow->RPort, &EinstText4, 0L, 0L); } WaitPort(EinstWindow->UserPort); message = GetMsg(EinstWindow->UserPort); MessageClass = message->Class; GadgetID = (USHORT)(((struct Gadget *)(message->IAddress))->GadgetID); ReplyMsg(message); switch(GadgetID) { case 1: if(((Ein.labellenght = Einst1StringInfo.LongInt * (long)sizeof(struct Label)) > freechip) && (Ein.labellenght > freefast)) Ein.labellenght = 0L; refr = TRUE; ActivateGadget(&EinstGadget2, EinstWindow, NULL); break; case 2: if(((Ein.macrotablelenght = Einst2StringInfo.LongInt * (long)sizeof(struct Macro)) > freechip) && (Ein.labellenght > freefast)) Ein.labellenght = 0L; refr = TRUE; ActivateGadget(&EinstGadget3, EinstWindow, NULL); break; case 3: Ein.macromemlenght = Einst3StringInfo.LongInt; ActivateGadget(&EinstGadget4, EinstWindow, NULL); break; case 4: Ein.delay = (unsigned int)Einst4StringInfo.LongInt; ActivateGadget(&EinstGadget1, EinstWindow, NULL); break; case 6: Ein.sort = 1-Ein.sort; break; } } freeit(); if(MessageClass != CLOSEWINDOW) { Einst.macromemlenght = Ein.macromemlenght; Einst.macrotablelenght = Ein.macrotablelenght; Einst.labellenght = Ein.labellenght; Einst.delay = Ein.delay; Einst.sort = Ein.sort; } labelnumber = 0L; macronumber = actmacro = 0; EinstNewWindow.LeftEdge = EinstWindow->LeftEdge; EinstNewWindow.TopEdge = EinstWindow->TopEdge; CloseWindow(EinstWindow); return(TRUE); } /****************** * Tabellenwindow * ******************/ BOOL dotables(number) USHORT number; { struct Window *TableWindow; struct Gadget *ActG; struct Message *GetMsg(); struct IntuiMessage *message; ULONG MessageClass; USHORT flag = 0; register int i; unsigned int quot; unsigned long max, upper, oldupper; TaProp1.VertPot = max = upper = 0; switch(number) { case 0: max = labelnumber; strcpy(TaText1.IText, "Labelname dez hex "); break; case 1: max = (unsigned long)macronumber; strcpy(TaText1.IText, "Makroname Länge Parameter "); break; case 2: max = (unsigned long)blockcounter; strcpy(TaText1.IText, "von bis Länge Dateiname "); break; case 3: max = (unsigned long)MNEMONICS; strcpy(TaText1.IText, " IM AB AX AY ZP ZX ZY ID DI RE IN AI"); break; } TaProp1.VertBody = (max < 16) ? 0xffff : (0xffff / max) * 15; if(!(TableWindow = (struct Window *) OpenWindow(&TableNewWindow))) { error = 43; return(FALSE); } DrawBorder(TableWindow->RPort, &TaBorder1, 0L, 0L); DrawBorder(TableWindow->RPort, &TaBorder3, 415L, 22L); DrawBorder(TableWindow->RPort, &TaBorder3, 415L, 138L); for(i=0; i<15; i++) { TaIntuiText[i] = TaTText; TaIntuiText[i].NextText = &TaIntuiText[i+1]; TaIntuiText[i].TopEdge = 24 + i * 8; TaIntuiText[i].IText = TaText[i]; TaText[i][0] = '\0'; } TaIntuiText[14].NextText = NULL; redrawit(upper, number); PrintIText(TableWindow->RPort, &TaText1, 0L, 0L); PrintIText(TableWindow->RPort, TaIntuiText, 0L, 0L); do { message = (struct IntuiMessage *)GetMsg(TableWindow->UserPort); if(!message && !flag) { Wait(1L << TableWindow->UserPort->mp_SigBit); continue; } if(message) { MessageClass = message->Class; ReplyMsg(message); if(MessageClass & GADGETDOWN) { ActG = message->IAddress; flag = ActG->GadgetID; } if((MessageClass & GADGETUP) || (MessageClass & CLOSEWINDOW)) flag = 0; } if(flag && !((ActG->Flags) & SELECTED)) flag = 0; oldupper = upper; quot = (0xffff/(max-15)); switch(flag) { case 2: if((upper < (max-15L)) && (max > 15L)) { upper++; TaProp1.VertPot = upper*quot; RefreshGadgets(&TaGadget3, TableWindow, NULL); } break; case 1: if(upper > 0) { upper--; TaProp1.VertPot = upper*quot; RefreshGadgets(&TaGadget3, TableWindow, NULL); } break; } if((upper * quot) != TaProp1.VertPot) { upper = (max < 16) ? 0 : TaProp1.VertPot/quot; if(((upper+15) > max) && (max > 15)) upper = max-15; } if(upper != oldupper) { redrawit(upper, number); PrintIText(TableWindow->RPort, &TaText1, 0L, 0L); PrintIText(TableWindow->RPort, TaIntuiText, 0L, 0L); } } while(!(MessageClass & CLOSEWINDOW)); TableNewWindow.LeftEdge = TableWindow->LeftEdge; TableNewWindow.TopEdge = TableWindow->TopEdge; CloseWindow(TableWindow); return(TRUE); } /****************************** * Menüauswertung durchführen * ******************************/ void domenus(menunumber) USHORT menunumber; { USHORT Menu, MenuItem; Menu = MENUNUM(menunumber); MenuItem = ITEMNUM(menunumber); error = 255; ClearMenuStrip(MainWindow); switch(Menu) { case 0: /* Datei-Menü */ switch(MenuItem) { case 0: /* Übertragen */ transfer(); break; case 1: /* Information */ information(); break; case 2: /* Beenden */ freeit(); closeall(); exit(TRUE); } break; case 1: /* Tabellen-Menü */ dotables(MenuItem); break; case 2: /* Einstellungen-Menü */ switch(MenuItem) { case 0: /* Ändern */ doeinstellungen(); break; case 1: /* Speichern */ saveeinst(); break; case 2: /* Laden */ loadeinst(); break; case 3: /* KonTab laden */ loadkonverttable(); break; } break; case 3: /* Drucken-Menü */ if(!MenuItem) printsource(); /* Source-Code */ else printtabs(MenuItem-1); /* Tabellen */ break; } pass = 0; SetMenuStrip(MainWindow, &MenuDatei); if(error != 255) refreshstatus(); } /***************** * Hauptschleife * *****************/ void mainloop() { struct Message *GetMsg(); struct IntuiMessage *message; ULONG MessageClass; USHORT code; refreshstatus(); ClearMenuStrip(MainWindow); information(); SetMenuStrip(MainWindow, &MenuDatei); srcname[0] = '\0'; FOREVER { pass = 0; WaitPort(MainWindow->UserPort); message = GetMsg(MainWindow->UserPort); MessageClass = message->Class; code = message->Code; ReplyMsg(message); if(MessageClass & CLOSEWINDOW) break; if(MessageClass & GADGETUP) { ClearMenuStrip(MainWindow); if(!(getname((char *)"Quelldateiname:", srcname))) { SetMenuStrip(MainWindow, &MenuDatei); continue; } strcpy(srcname, dateistrbuffer); objname[0] = '\0'; Gadget1.GadgetText = &GadgetText2; RefreshGadgets(&Gadget1, MainWindow, NULL); freeit(); if(init()) { error = 255; run = TRUE; passone(); if(prtflag) { if(!(PrintHandle = append(prtname))) error = 59; } if(error == 255) passtwo(); run = FALSE; if(prtflag) { if(PrintHandle) Close(PrintHandle); } if(SourceHandle) Close(SourceHandle); SourceHandle = 0L; if(((error == 255) || (error == 37)) && Einst.sort) sortthem(); refreshstatus(); } Gadget1.GadgetText = &GadgetText1; RefreshGadgets(&Gadget1, MainWindow, NULL); SetMenuStrip(MainWindow, &MenuDatei); } if(MessageClass & MENUPICK) { domenus(code); refreshstatus(); } } } /********************************************************* * Aufruf des FileRequesters der ASL-Library in C * * * * Datum : 18. November 1990 * * Autor : David Göhler * * Version : 1.1 * * Letzte Änderung : 18. November 1990 * * * * Compilieren mit DICE: dcc filereq.c -o filereqdemo * * * *********************************************************/ #define FILENAMELEN 256 struct Library *AslBase; /* Syntax : BOOL DateiReq(filename,AnzeigeText,Show) Datum : 04. November 1989 Eingabe : filename - Zeiger auf den Filenamen AnzeigeText - Zeiger auf Text, der oben im Window steht Show - Ein String, der ein Pattern enthält. Der FileRequester zeigt dann nur Dateien an, die auf das Pattern passen. Ausgabe : FALSE - Requester mit Cancel verlassen TRUE - neuer Dateiname ist gültig Funktion: Aufruf des 2.0-ASL-FileRequesters. Ein vereinfachtes Beispiel. Läuft nur unter 2.0 */ BOOL DateiReqD(char *filename,char *AnzeigeText,char *Show, BOOL dir) { struct FileRequester *FR; char zwfile[FILENAMELEN]; char zwdir [FILENAMELEN]; char *cpoint,c; BOOL retcode = FALSE; ULONG extflags1; if (dir) extflags1 = FIL1F_NOFILES; else extflags1 = FIL1F_MATCHDIRS; if (AslBase = (struct Library *)OpenLibrary(AslName,37)) { // String in filename und dirname aufteilen cpoint = PathPart(filename); c = *cpoint; *cpoint = '\0'; strcpy(zwdir,filename); if (c=='/') { *cpoint++=c; } else { *cpoint = c; } strcpy(zwfile,cpoint); if (FR = AllocAslRequestTags( ASL_FileRequest, ASL_Hail, AnzeigeText, ASL_Window, 0L, ASL_File, zwfile, ASL_Dir, zwdir, ASL_FuncFlags, FILF_PATGAD, ASL_ExtFlags1, extflags1, ASL_Pattern, Show, TAG_DONE )) { if (RequestFile(FR)) { strcpy(filename,FR->rf_Dir); AddPart(filename,FR->rf_File,FILENAMELEN); retcode = TRUE; } FreeFileRequest(FR); } CloseLibrary((struct Library *)AslBase); } return retcode; } BOOL DateiReq(char *filename,char *AnzeigeText,char *Show) { return DateiReqD(filename,AnzeigeText,Show,FALSE); } /***************** * Hauptprogramm * *****************/ void main() { openall(); mainloop(); freeit(); closeall(); }