Skocz do zawartości

Proszę o pomoc w aplikacji Windows form C# (Kompilator)


kroszkanorber

Pomocna odpowiedź

Witam. Chcę napisać aplikację kompilator dla kodów własnego autorstwa.

Założenia: Ma być uniwersalny, Polecenia deklaruje użytkownik, pliki binarne (wynikowe) deklaruje użytkownik.(Teraz jest to zdefiniowane w kodzie)

aplikacja którą napisałem z pomocą Copilot nie spełnia wszystkich założeń.

Aplikacja składa się z 3 okien. ListBox i 2 okna RichTextBox i belki postępu.

ListBox i RichTextBox różnią się od siebie w funkcjonalności

Belka postępu używana jest podczas przesyłania plików binarnych do portu UART.

Okno ListBox po lewej stronie wyświetla ostatnio otwarte pliki.

Okno RichTextBox1 wyświetla program w środkowej części aplikacji.

Okno RichTextBox2 wyświetla plik binarny po kompilacji.

Co muszę zmienić lub dopisać do aplikacji by spełniała moje wymagania?

Kod:


using System;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.IO.Ports;
using System.Reflection.Metadata;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading.Tasks;

namespace AGNES_8b2k
{
    public partial class Form1 : Form
    {
        private List<string> words1 = new List<string>();
        private List<string> words2 = new List<string>();
        private List<string> words3 = new List<string>();
        private List<string> wordsDefine = new List<string>();
        private List<string> wordsDefineBinary = new List<string>();
        private List<string> wordsIndex = new List<string>();
        private List<string> wordsIndexNumber = new List<string>();
        private List<string> recentFiles = new List<string>();
        private List<string> sendFilesToUart = new List<string>();
        private Dictionary<string, string> fileDictionary = new Dictionary<string, string>();
        private SerialPort serialPort;
        private int totalDataCount;
        private int sentDataCount;
        private bool hasError;


        // Deklaracja zmiennej globalnej filePathAsm
        private string filePathAsm = "";
        // Tabela słów kluczowych do kolorowania
        private string[] keywordsBlue =
        {    "NOP",
             "MOVLB",
             "MOVEB",
             "MOVRB",
             "ANDRB",
             "IORRB",
             "XORRB",
             "COMR",
             "ADDRB",
             "SUBRB",
             "RRR",
             "RLR",
             "SWAPR",
             "MULRB",
             "SETC",
             "CLRC",
             "RETLB",
             "RETURN",
             "RETFIE",
             "MOVBE",
             "SKIPC",
             "SKIPZ",
             "SKIPE",
             "SKIPU",
             "GOTO",
             "CALL",
             "WEEN",
             "ADDPC",
             "MOVBR",
             "MOVER",
             "SETR",
             "CLRR"
        };
        private string[] wordToBinary =
        {
           "00000",
           "00001",
           "00010",
           "00011",
           "00100",
           "00101",
           "00110",
           "00111",
           "01000",
           "01001",
           "01010",
           "01011",
           "01100",
           "01101",
           "01110",
           "01111",
           "10000",
           "10001",
           "10010",
           "10011",
           "10100",
           "10101",
           "10110",
           "10111",
           "11000",
           "11001",
           "11010",
           "11011",
           "11100",
           "11101",
           "11110",
           "11111"
        };

        private string[] keywordsPurple = { "#DEFINE" };

        private string[] keywordsOrange = { "BEGIN",
                                            "END"};
        public Form1()
        {
            InitializeComponent();

            // Dodanie obsługi zdarzenia dla zmiany wyboru elementu
            listBox1.SelectedIndexChanged += listBox1_SelectedIndexChanged;

            // Dodanie obsługi zdarzenia zamknięcia formularza
            this.FormClosed += new FormClosedEventHandler(Form1_FormClosed);

            // Załaduj ostatnio otwierane pliki
            LoadRecentFiles();

            richTextBox1.MouseMove += RichTextBox1_MouseMove; // Dodaj obsługę zdarzenia MouseMove
        }
        private void listBox1_SelectedIndexChanged(object sender, EventArgs e) // Upewnij się, że nazwa metody jest zgodna
        {
            if (listBox1.SelectedItem != null)
            {
                string selectedFileName = listBox1.SelectedItem.ToString();
                if (fileDictionary.TryGetValue(selectedFileName, out string fullPath))
                {
                    OpenFileAndPerformOperations(fullPath);
                    listBox1.ClearSelected(); // Usuń zaznaczenie z ListBox
                }
            }
        }
        private void OpenFileAndPerformOperations(string filePath)
        {
            // Przeniesiona logika otwierania pliku
            filePathAsm = filePath;

            // Wyczyszczenie RichTextBox przed wczytaniem nowego pliku
            richTextBox1.Clear();

            FileReader fileReader = new FileReader();
            fileReader.LoadFileToRichTextBox(filePath, richTextBox1);

            // Wyłączenie zdarzenia TextChanged na czas kolorowania
            richTextBox1.TextChanged -= RichTextBox1_TextChanged_ForColoring;

            // Kolorowanie pobranego tekstu
            ColorTextInRichTextBox(richTextBox1);

            // Ponowne włączenie zdarzenia TextChanged
            richTextBox1.TextChanged += RichTextBox1_TextChanged_ForColoring;

            // Aktualizacja listy ostatnich plików
            string fileName = Path.GetFileName(filePath);
            if (!recentFiles.Contains(fileName))
            {
                recentFiles.Add(fileName);
                fileDictionary[fileName] = filePath;

                if (recentFiles.Count > 5)
                {
                    string oldestFileName = recentFiles[0];
                    recentFiles.RemoveAt(0);
                    fileDictionary.Remove(oldestFileName); // Usuń najstarszy plik, aby zachować tylko 5 ostatnich plików
                }
                UpdateRecentFilesListBox();
            }
        }
        private void UpdateRecentFilesListBox()
        {
            listBox1.Items.Clear();
            foreach (var file in recentFiles)
            {
                listBox1.Items.Add(file);
            }
        }
        private void SaveRecentFiles()
        {
            string directoryPath = @"C:/AGNES_8b2k";
            if (!Directory.Exists(directoryPath))
            {
                Directory.CreateDirectory(directoryPath); // Tworzenie ścieżki, jeśli nie istnieje
            }
            string filePath = Path.Combine(directoryPath, "recentFiles.txt");
            File.WriteAllLines(filePath, fileDictionary.Values);
        }
        private void LoadRecentFiles()
        {
            string filePath = @"C:/AGNES_8b2k/recentFiles.txt";
            if (File.Exists(filePath))
            {
                var lines = File.ReadAllLines(filePath);
                fileDictionary = lines.ToDictionary(line => Path.GetFileName(line), line => line);
                recentFiles = fileDictionary.Keys.ToList();
                UpdateRecentFilesListBox();
            }
            else
            {
                MessageBox.Show("Nie znaleziono pliku " + filePath + ". Tworzę nowy plik.");
                SaveRecentFiles(); // Utwórz nowy plik
            }
        }
        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            // Zapisz ostatnio otwierane pliki
            SaveRecentFiles();
            // Zamknij port COM, jeśli jest otwarty
            if (serialPort != null && serialPort.IsOpen)
            {
                serialPort.Close();
            }
        }
#nullable disable
        private void RichTextBox1_TextChanged_ForColoring(object sender, EventArgs e)
        {
            int selectionStart = richTextBox1.SelectionStart;
            int wordStartIndex = selectionStart - 0;
            //richTextBox1.TextChanged -= RichTextBox1_TextChanged_ForColoring;
            while (wordStartIndex > 0 && !char.IsWhiteSpace(richTextBox1.Text[wordStartIndex - 1]))
            {
                wordStartIndex--;
            }
            // Upewnij się, że nie jesteśmy na końcu tekstu
            if (wordStartIndex >= richTextBox1.Text.Length)
            {
                return;
            }
            // Pobierz tekst do końca ostatniego słowa
            string lastWord = richTextBox1.Text.Substring(wordStartIndex, selectionStart - wordStartIndex);
            // Zresetuj kolorowanie
            richTextBox1.Select(wordStartIndex, lastWord.Length);
            richTextBox1.SelectionColor = Color.Aqua;
            // Zastosuj kolorowanie dla każdego słowa kluczowego na niebiesko
            foreach (var keyword in keywordsBlue)
            {
                if (lastWord.Equals(keyword, StringComparison.OrdinalIgnoreCase))
                {
                    richTextBox1.Select(wordStartIndex, lastWord.Length);
                    richTextBox1.SelectionColor = Color.AntiqueWhite;
                    break;
                }
            }

            // Zastosuj kolorowanie dla każdego słowa kluczowego na fioletowo
            foreach (var keyword in keywordsPurple)
            {
                if (lastWord.Equals(keyword, StringComparison.OrdinalIgnoreCase))
                {
                    richTextBox1.Select(wordStartIndex, lastWord.Length);
                    richTextBox1.SelectionColor = Color.Red;
                    break;
                }
            }

            // Zastosuj kolorowanie dla każdego słowa kluczowego na pomarańczowo
            foreach (var keyword in keywordsOrange)
            {
                {
                    if (lastWord.Equals(keyword, StringComparison.OrdinalIgnoreCase))
                    {
                        richTextBox1.Select(wordStartIndex, lastWord.Length);
                        richTextBox1.SelectionColor = Color.Orange;
                        break;
                    }
                }
            }

            // Przywróć oryginalną pozycję kursora
            richTextBox1.SelectionStart = selectionStart;
            richTextBox1.SelectionLength = 0;
            richTextBox1.SelectionColor = richTextBox1.ForeColor;

            //richTextBox1.TextChanged += RichTextBox1_TextChanged_ForColoring;
        }

        private void richTextBox1_PreviewKeyDown(object sender, PreviewKeyDownEventArgs e)
        {
            if (e.KeyCode == Keys.Tab)
            {
                e.IsInputKey = true; // Ustawienie IsInputKey na true, aby klawisz Tab był traktowany jako znak wejściowy
            }
        }
        private void richTextBox1_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Tab)
            {
                e.SuppressKeyPress = true; // Zapobieganie domyślnemu zachowaniu tabulatora
                richTextBox1.SelectedText = "\t"; // Wstawianie znaku tabulacji
            }
        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }

        //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
        private List<int> errorLines = new List<int>(); // Przechowuje indeksy linii z błędami
        private Dictionary<int, List<Tuple<int, int>>> errorWordRanges = new Dictionary<int, List<Tuple<int, int>>>(); // Przechowuje zakresy błędnych słów
        private HashSet<string> definedWords = new HashSet<string>();
        private HashSet<string> interrupts = new HashSet<string>();
        private ToolTip toolTip = new ToolTip(); // Podpowiedź narzędzia do wyświetlania sugestii

        private void CheckSyntaxAndHighlightErrors()
        {
            hasError = false;
            errorLines.Clear(); // Wyczyść poprzednie błędy
            errorWordRanges.Clear(); // Wyczyść zakresy błędnych słów
            definedWords.Clear(); // Wyczyść poprzednie definicje
            interrupts.Clear(); // Wyczyść poprzednie przerwania
            bool firstErrorFound = false; // Flaga do oznaczenia pierwszego błędu
            int firstErrorLineIndex = -1; // Przechowuje indeks pierwszej linii z błędem
            HashSet<string> validInstructions = new HashSet<string>(keywordsBlue.Select(s => s.ToUpper()));

            // Krok 1: Skanowanie w poszukiwaniu definicji
            foreach (string line in richTextBox1.Lines)
            {
                string trimmedLine = line.Trim();
                if (string.IsNullOrEmpty(trimmedLine))
                    continue; // Pomijamy puste linie

                string[] tokens = trimmedLine.Split(new[] { '\t', ' ' }, StringSplitOptions.RemoveEmptyEntries);

                if (tokens.Length == 0)
                    continue; // Pomijamy puste linie

                string firstToken = tokens[0].ToUpper(); // Konwertowanie na wielkie litery

                if (firstToken == "#DEFINE" && tokens.Length >= 2)
                {
                    definedWords.Add(tokens[1].ToUpper()); // Dodajemy nazwę definicji, konwertując na wielkie litery
                }
            }

            // Krok 2: Skanowanie w poszukiwaniu przerwań
            foreach (string line in richTextBox1.Lines)
            {
                string trimmedLine = line.Trim();
                if (string.IsNullOrEmpty(trimmedLine))
                    continue; // Pomijamy puste linie

                string[] tokens = trimmedLine.Split(new[] { '\t', ' ' }, StringSplitOptions.RemoveEmptyEntries);

                if (tokens.Length == 0)
                    continue; // Pomijamy puste linie

                string firstToken = tokens[0].ToUpper(); // Konwertowanie na wielkie litery

                if (!validInstructions.Contains(firstToken) && !firstToken.StartsWith("//") && firstToken != "#DEFINE")
                {
                    interrupts.Add(firstToken); // Dodajemy nazwę przerwania
                }
            }

            // Krok 3: Skanowanie w poszukiwaniu kodów z błędami
            for (int i = 0; i < richTextBox1.Lines.Length; i++)
            {
                string line = richTextBox1.Lines[i];
                string trimmedLine = line.Trim();
                if (string.IsNullOrEmpty(trimmedLine))
                    continue; // Pomijamy puste linie

                string[] tokens = trimmedLine.Split(new[] { '\t', ' ' }, StringSplitOptions.RemoveEmptyEntries);

                if (tokens.Length == 0)
                    continue; // Pomijamy puste linie

                string firstToken = tokens[0].ToUpper(); // Konwertowanie na wielkie litery

                if (firstToken.StartsWith("//"))
                {
                    continue; // Pomijamy komentarze
                }

                if (firstToken == "#DEFINE")
                {
                    continue; // Pomiń sprawdzanie reszty linii po #DEFINE
                }

                bool lineHasError = false;
                List<Tuple<int, int>> wordRanges = new List<Tuple<int, int>>(); // Zakresy błędnych słów w linii

                if (validInstructions.Contains(firstToken))
                {
                    // Pierwszy token jest instrukcją
                    if (tokens.Length < 2)
                    {
                        // Do nothing, brak drugiego słowa nie jest błędem
                    }
                    else
                    {
                        string secondToken = tokens[1].ToUpper(); // Konwertowanie na wielkie litery

                        if (!(interrupts.Contains(secondToken) ||
                            definedWords.Contains(secondToken) ||
                            (secondToken.StartsWith("B'") && secondToken.EndsWith("'")) ||
                            (secondToken.StartsWith("H'") && secondToken.EndsWith("'")) ||
                            int.TryParse(secondToken, out _))) // Dodane sprawdzenie liczb
                        {
                            lineHasError = true;
                            int start = line.IndexOf(tokens[1]);
                            wordRanges.Add(Tuple.Create(start, tokens[1].Length)); // Dodaj zakres błędnego słowa
                        }
                    }
                }
                else if (interrupts.Contains(firstToken))
                {
                    // Pierwszy token jest nazwą przerwania
                    if (tokens.Length > 1 && !tokens[1].StartsWith("//"))
                    {
                        lineHasError = true;
                        int start = line.IndexOf(tokens[1]);
                        wordRanges.Add(Tuple.Create(start, tokens[1].Length)); // Dodaj zakres błędnego słowa
                    }
                }
                else
                {
                    lineHasError = true;
                    int start = line.IndexOf(tokens[0]);
                    wordRanges.Add(Tuple.Create(start, tokens[0].Length)); // Dodaj zakres błędnego słowa
                }

                if (lineHasError)
                {
                    hasError = true;
                    HighlightWords(i, wordRanges, Color.Gray); // Zaznacz błędne słowa na szaro
                    errorLines.Add(i); // Dodaj linię do listy błędów
                    errorWordRanges[i] = wordRanges; // Dodaj zakresy błędnych słów do słownika
                    if (!firstErrorFound)
                    {
                        firstErrorLineIndex = i; // Zapisz indeks pierwszej linii z błędem
                        firstErrorFound = true;
                    }
                }
                else
                {
                    ClearHighlightLine(i); // Usuń zaznaczenie, jeśli linia jest poprawna
                }
            }

            // Ustawienie kursora na końcu pierwszej linii z błędem i wyświetlenie komunikatu
            if (firstErrorFound)
            {
                SetCursorToEndOfLine(firstErrorLineIndex); // Ustaw kursor na końcu pierwszej błędnej linii
                MessageBox.Show($"Błąd: nieprawidłowy kod w linii {firstErrorLineIndex + 1}: {richTextBox1.Lines[firstErrorLineIndex]}");
            }
        }

        private void HighlightWords(int lineIndex, List<Tuple<int, int>> wordRanges, Color color)
        {
            foreach (var range in wordRanges)
            {
                int start = richTextBox1.GetFirstCharIndexFromLine(lineIndex) + range.Item1;
                int length = range.Item2;
                richTextBox1.Select(start, length);
                richTextBox1.SelectionBackColor = color; // Zaznaczenie słowa na podany kolor
            }
        }

        private void ClearHighlightLine(int lineIndex)
        {
            int start = richTextBox1.GetFirstCharIndexFromLine(lineIndex);
            int length = richTextBox1.Lines[lineIndex].Length;
            richTextBox1.Select(start, length);
            richTextBox1.SelectionBackColor = richTextBox1.BackColor; // Usunięcie zaznaczenia
        }

        private void SetCursorToEndOfLine(int lineIndex)
        {
            int start = richTextBox1.GetFirstCharIndexFromLine(lineIndex);
            int length = richTextBox1.Lines[lineIndex].Length;
            richTextBox1.Select(start + length, 0); // Ustaw kursor na końcu linii
            richTextBox1.ScrollToCaret(); // Przewiń do kursora
        }

        private string GetSuggestions(string word)
        {
            List<string> suggestions = new List<string>();
            suggestions.AddRange(definedWords.Where(w => IsSimilar(w, word)));
            suggestions.AddRange(interrupts.Where(w => IsSimilar(w, word)));
            return string.Join("\n", suggestions); // Zapisz sugestie jedna pod drugą
        }

        private bool IsSimilar(string word1, string word2)
        {
            if (word1.Length < 2 || word2.Length < 2)
            {
                return false;
            }

            return word1.Substring(0, 2) == word2.Substring(0, 2);
        }
        private void RichTextBox1_MouseMove(object sender, MouseEventArgs e)
        {
            int index = richTextBox1.GetCharIndexFromPosition(e.Location);
            int lineIndex = richTextBox1.GetLineFromCharIndex(index);

            if (errorLines.Contains(lineIndex))
            {
                string line = richTextBox1.Lines[lineIndex];
                string[] tokens = line.Split(new[] { '\t', ' ' }, StringSplitOptions.RemoveEmptyEntries);
                if (tokens.Length > 1)
                {
                    string secondToken = tokens[1].ToUpper();
                    string suggestions = GetSuggestions(secondToken);
                    toolTip.SetToolTip(richTextBox1, suggestions != "" ? $"Sugestie:\n{suggestions}" : "Brak sugestii");
                }
            }
            else
            {
                toolTip.SetToolTip(richTextBox1, null);
            }
        }
        //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
        private void uruchomKompilatorToolStripMenuItem_Click(object sender, EventArgs e)
        {
            CheckSyntaxAndHighlightErrors();
            if (!hasError)
            {
                ProcessTextFromRichTextBox(richTextBox1);
                DisplayKeywordsInRichTextBox();
            }
            else
            {
               // MessageBox.Show("Wystąpiły błędy w kodzie. Sprawdź zaznaczone linie.");
            }
        }
        private void ProcessTextFromRichTextBox(RichTextBox richTextBox)
        {
            // Wyczyść tablice przed rozpoczęciem przetwarzania
            words1.Clear();
            words2.Clear();
            words3.Clear();
            wordsDefine.Clear();
            wordsDefineBinary.Clear();

            // Podziel tekst na linie
            string[] lines = richTextBox.Lines;

            foreach (string line in lines)
            {
                // Podziel linię na słowa
                string[] words = line.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);

                // Sprawdź, czy linia jest pusta
                if (words.Length == 0)
                {
                    words1.Add("0");
                    words2.Add("0");
                    words3.Add("0");
                    continue;
                }

                // Sprawdź, czy pierwsze słowo zaczyna się od znaków //
                if (words[0].StartsWith("//"))
                {
                    words1.Add("0");
                    words2.Add("0");
                    words3.Add("0");
                    continue;
                }

                // Sprawdź, czy pierwsze słowo to #define
                if (words[0] == "#define")
                {
                    if (words.Length > 1)
                    {
                        wordsDefine.Add(words[1]);
                    }
                    else
                    {
                        wordsDefine.Add("0");
                    }

                    if (words.Length > 2)
                    {
                        wordsDefineBinary.Add(words[2]);
                    }
                    else
                    {
                        wordsDefineBinary.Add("0");
                    }
                }

                // Dodaj słowa do tablic, jeśli istnieją
                words1.Add(words.Length > 0 ? words[0] : "0");
                words2.Add(words.Length > 1 ? words[1] : "0");
                words3.Add(words.Length > 2 ? words[2] : "0");
            }
        }

        private string GetSecondWordBinary(string secondWord)
        {
            secondWord = secondWord.ToUpper(); // Upewnij się, że cały tekst jest zapisany wielkimi literami

            if (secondWord.Length > 2 && secondWord.StartsWith("H'") && secondWord.EndsWith("'"))
            {
                // Wyodrębnij cyfrę szesnastkową pomiędzy H' a '
                string hexValue = secondWord.Substring(2, secondWord.Length - 3);
                if (int.TryParse(hexValue, System.Globalization.NumberStyles.HexNumber, null, out int hexNumber))
                {
                    // Zamień liczbę szesnastkową na liczbę binarną
                    string binaryValue = Convert.ToString(hexNumber, 2);

                    // Usuń nadmiar bitów po lewej stronie, jeśli długość przekracza 11 bitów
                    if (binaryValue.Length > 11)
                    {
                        binaryValue = binaryValue.Substring(binaryValue.Length - 11);
                    }

                    // Uzupełnij brakujące zera z lewej strony do 11 bitów
                    return binaryValue.PadLeft(11, '0');
                }
            }
            else if (secondWord.Length > 2 && secondWord.StartsWith("B'") && secondWord.EndsWith("'"))
            {
                // Wyodrębnij wartość binarną pomiędzy B' a '
                string binaryValue = secondWord.Substring(2, secondWord.Length - 3);

                // Usuń nadmiar bitów po lewej stronie, jeśli długość przekracza 11 bitów
                if (binaryValue.Length > 11)
                {
                    binaryValue = binaryValue.Substring(binaryValue.Length - 11);
                }

                // Uzupełnij brakujące zera z lewej strony do 11 bitów
                return binaryValue.PadLeft(11, '0');
            }
            else if (int.TryParse(secondWord, out int secondWordValue))
            {
                // Zamień drugie słowo na liczbę binarną o długości 11 bitów
                string binaryValue = Convert.ToString(secondWordValue, 2);

                // Usuń nadmiar bitów po lewej stronie, jeśli długość przekracza 11 bitów
                if (binaryValue.Length > 11)
                {
                    binaryValue = binaryValue.Substring(binaryValue.Length - 11);
                }

                // Uzupełnij brakujące zera z lewej strony do 11 bitów
                return binaryValue.PadLeft(11, '0');
            }

            // Jeśli drugie słowo nie jest liczbą ani w formacie H'XX' ani B'XX', zwróć domyślną wartość
            return "00000000000";
        }
        private void DisplayKeywordsInRichTextBox()
        {
            // Wyczyść RichTextBox2 przed dodaniem nowych słów
            richTextBox2.Clear();
            sendFilesToUart.Clear();
            richTextBox2.AppendText("   " + "START" + "      " + "00000110" + Environment.NewLine);
            sendFilesToUart.Add("00000110");
            wordsIndex.Clear();
            wordsIndexNumber.Clear();

            // Wyszukiwanie przerwań
            // Numer linii zaczynający od 0000
            int lineNumber = 0;
            for (int i = 0; i < words1.Count; i++)
            {
                // Sprawdź warunki `#define`, `0`, `end` na początku
                if (words1[i] == "#define" || words1[i] == "0" || words1[i] == "end")
                {
                    continue;
                }

                // Sprawdź, czy słowo występuje w `keywordsBlue`
                bool foundInKeywords = false;
                for (int j = 0; j < keywordsBlue.Length; j++)
                {
                    if (keywordsBlue[j].Equals(words1[i], StringComparison.OrdinalIgnoreCase))
                    {
                        foundInKeywords = true;
                        lineNumber++;
                        break;
                    }
                }

                if (!foundInKeywords)
                {
                    wordsIndex.Add(words1[i]);
                    wordsIndexNumber.Add(Convert.ToString(lineNumber));
                }
            }

            // Kompilacja assembler do kodu binarnego
            // Numer linii zaczynający od 0000
            lineNumber = 0;

            // Iteracja przez słowa w `words1`
            for (int i = 0; i < words1.Count; i++)
            {
                // Sprawdź, czy słowo występuje w `keywordsBlue`
                for (int j = 0; j < keywordsBlue.Length; j++)
                {
                    if (keywordsBlue[j].Equals(words1[i], StringComparison.OrdinalIgnoreCase))
                    {
                        string secondWordBinary = "00000000000";

                        // Upewnij się, że `i` jest w zakresie `words2`
                        if (i >= words2.Count)
                        {
                            Console.WriteLine("Index out of range: words2");
                            break;
                        }

                        // Skanowanie `words2` przez `wordsDefine`
                        bool foundInDefine = false;
                        for (int k = 0; k < wordsDefine.Count; k++)
                        {
                            if (words2[i].Equals(wordsDefine[k], StringComparison.OrdinalIgnoreCase))
                            {
                                secondWordBinary = GetSecondWordBinary(wordsDefineBinary[k]);
                                foundInDefine = true;
                                break;
                            }
                        }

                        // Skanowanie `words2` przez `wordsIndex`
                        bool foundInIndex = false;
                        if (!foundInDefine)
                        {
                            for (int k = 0; k < wordsIndex.Count; k++)
                            {
                                if (words2[i].Equals(wordsIndex[k], StringComparison.OrdinalIgnoreCase))
                                {
                                    secondWordBinary = GetSecondWordBinary(wordsIndexNumber[k]);
                                    foundInIndex = true;
                                    break;
                                }
                            }
                        }

                        // Jeśli nie znaleziono w `wordsDefine`, dekoduj `words2` przy pomocy `GetSecondWordBinary`
                        if (!foundInDefine && !foundInIndex)
                        {
                            secondWordBinary = GetSecondWordBinary(words2[i]);
                        }

                        // Upewnij się, że `j` jest w zakresie `wordToBinary`
                        if (j >= wordToBinary.Length)
                        {
                            Console.WriteLine("Index out of range: wordToBinary");
                            break;
                        }

                        // Kontatenacja obu słów
                        string concatenatedBinary = wordToBinary[j] + secondWordBinary;

                        // Podział na dwie części o długości 8 znaków
                        string part1 = concatenatedBinary.Substring(0, 8);
                        string part2 = concatenatedBinary.Substring(8, 8);

                        // Dodaj numer linii i odpowiadającą liczbę binarną do RichTextBox2
                        richTextBox2.AppendText("     " + lineNumber.ToString("D4") + "       " + part1 + " " + part2 + Environment.NewLine);

                        sendFilesToUart.Add(part1);
                        sendFilesToUart.Add(part2);
                        // Zwiększ numer linii tylko gdy znajdziemy słowo
                        lineNumber++;
                        break;
                    }
                }
            }

            richTextBox2.AppendText("    " + "STOP" + "       " + "00000111" + Environment.NewLine);
            sendFilesToUart.Add("00000111");
        }

        //////////////////////////////////////////////////////////////////////////
        private void aSMToolStripMenuItem_Click(object sender, EventArgs e)
        {

        }

        private void menuStrip1_ItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {

        }
        private void zapiszToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Utworzenie instancji SaveFileDialog
            SaveFileDialog saveFileDialog1 = new SaveFileDialog();

            // Ustawienie opcji filtra i indeksu filtra
            saveFileDialog1.Filter = "ASM Files (*.asm)|*.asm|All Files (*.*)|*.*";
            saveFileDialog1.FilterIndex = 1;

            // Wyświetlenie okna dialogowego
            DialogResult result = saveFileDialog1.ShowDialog();

            // Przetwarzanie danych, jeśli użytkownik kliknął OK
            if (result == DialogResult.OK)
            {
                // Pobranie ścieżki wybranego pliku
                string filePathAsm = saveFileDialog1.FileName;

                // Utworzenie instancji FileWriter i zapis zawartości RichTextBox do pliku
                FileWriter fileWriter = new FileWriter();
                fileWriter.SaveRichTextBoxToFile(filePathAsm, richTextBox1);
            }
        }
        private void ColorTextInRichTextBox(RichTextBox richTextBox)
        {
            int selectionStart = richTextBox.SelectionStart;

            // Zapamiętaj aktualny tekst
            string text = richTextBox.Text;

            // Zastosuj kolorowanie dla każdego słowa kluczowego na niebiesko
            foreach (var keyword in keywordsBlue)
            {
                int index = text.IndexOf(keyword, StringComparison.OrdinalIgnoreCase);
                while (index != -1)
                {
                    richTextBox.Select(index, keyword.Length);
                    richTextBox.SelectionColor = Color.AntiqueWhite;
                    index = text.IndexOf(keyword, index + keyword.Length, StringComparison.OrdinalIgnoreCase);
                }
            }

            // Zastosuj kolorowanie dla każdego słowa kluczowego na fioletowo
            foreach (var keyword in keywordsPurple)
            {
                int index = text.IndexOf(keyword, StringComparison.OrdinalIgnoreCase);
                while (index != -1)
                {
                    richTextBox.Select(index, keyword.Length);
                    richTextBox.SelectionColor = Color.Red;
                    index = text.IndexOf(keyword, index + keyword.Length, StringComparison.OrdinalIgnoreCase);
                }
            }

            // Zastosuj kolorowanie dla każdego słowa kluczowego na pomarańczowo
            foreach (var keyword in keywordsOrange)
            {
                int index = text.IndexOf(keyword, StringComparison.OrdinalIgnoreCase);
                while (index != -1)
                {
                    richTextBox.Select(index, keyword.Length);
                    richTextBox.SelectionColor = Color.Orange;
                    index = text.IndexOf(keyword, index + keyword.Length, StringComparison.OrdinalIgnoreCase);
                }
            }

            // Przywróć oryginalną pozycję kursora
            richTextBox.SelectionStart = selectionStart;
            richTextBox.SelectionLength = 0;
            richTextBox.SelectionColor = richTextBox.ForeColor;
        }
        private void otwórzToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Create an instance of OpenFileDialog
            OpenFileDialog openFileDialog1 = new OpenFileDialog();

            // Set filter options and filter index
            openFileDialog1.Filter = "ASM Files (*.asm)|*.asm|All Files (*.*)|*.*";
            openFileDialog1.FilterIndex = 1;
            openFileDialog1.Multiselect = false;

            // Wyświetlenie okna dialogowego
            DialogResult result = openFileDialog1.ShowDialog();

            // Przetwarzanie danych, jeśli użytkownik kliknął OK
            if (result == DialogResult.OK)
            {
                string filePath = openFileDialog1.FileName;
                OpenFileAndPerformOperations(filePath);
            }
        }

        //--------programator--------------
        private async void uruchomProgramatorToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Uruchomienie inicjalizacji portu w tle
            string portName = await InicjalizujPortAsync();

            if (!string.IsNullOrEmpty(portName))
            {
                progressBar1.Visible = true; // Ustaw pasek postępu jako widoczny
                progressBar1.Value = 0; // Zresetuj wartość paska do 0%

                // Przetwarzanie i wysyłanie danych przez port szeregowy
                await ProcessAndSendDataAsync(sendFilesToUart);
            }
        }

        private async Task ProcessAndSendDataAsync(List<string> dataWords)
        {
            List<byte> dataList = new List<byte>();

            foreach (string word in dataWords)
            {
                try
                {
                    byte data = Convert.ToByte(word, 2);
                    dataList.Add(data);
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Błąd konwersji danych: {ex.Message}");
                }
            }

            totalDataCount = dataList.Count;
            sentDataCount = 0;

            // Zamknij i ponownie otwórz port COM przed wysyłką danych
            if (serialPort.IsOpen)
            {
                serialPort.Close();
            }
            serialPort.Open();

            foreach (byte data in dataList)
            {
                await SendDataOverSerialAsync(data);
                UpdateProgressBar();
            }

            // Sprawdzenie, czy wszystkie dane zostały wysłane
            if (sentDataCount == totalDataCount)
            {
                progressBar1.Visible = false; // Ukryj pasek
                serialPort.Close(); // Zamknij port COM
                MessageBox.Show("Port COM został zamknięty."); // Powiadomienie o zamknięciu portu
            }
        }

        private async Task SendDataOverSerialAsync(byte data)
        {
            if (serialPort != null && serialPort.IsOpen)
            {
                while (serialPort.BytesToWrite > 0)
                {
                    // Poczekaj, aż bufor będzie gotowy na przyjęcie kolejnych danych
                    await Task.Delay(1);
                }

                await Task.Run(() => serialPort.Write(new byte[] { data }, 0, 1));
                sentDataCount++;

                // Dodanie opóźnienia po wysłaniu każdego bajta, aby uniknąć przepełnienia bufora
                await Task.Delay(1);
            }
        }

        private void UpdateProgressBar()
        {
            if (totalDataCount > 0)
            {
                int progress = (int)((double)sentDataCount / totalDataCount * 100);
                progressBar1.Value = progress;
            }
        }

        private async Task<string> InicjalizujPortAsync()
        {
            return await Task.Run(() =>
            {
                string portName = ZnajdźPortCom();
                if (string.IsNullOrEmpty(portName))
                {
                    MessageBox.Show("Nie znaleziono urządzenia na żadnym porcie COM.");
                    return null;
                }

                try
                {
                    serialPort = new SerialPort(portName, 9600)
                    {
                        Parity = Parity.None,
                        DataBits = 8,
                        StopBits = StopBits.One,
                        Handshake = Handshake.None
                    };
                    serialPort.Open();
                    MessageBox.Show($"Urządzenie znalezione na porcie {portName} i zainicjowane na 9600 bps.");
                    return portName;
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"Błąd podczas inicjalizacji portu: {ex.Message}");
                    return null;
                }
            });
        }

        private string ZnajdźPortCom()
        {
            foreach (string port in SerialPort.GetPortNames())
            {
                try
                {
                    using (SerialPort testSerialPort = new SerialPort(port))
                    {
                        testSerialPort.Open();
                        // Sprawdź, czy urządzenie odpowiada
                        if (SprawdźUrządzenie(testSerialPort))
                        {
                            return port;
                        }
                    }
                }
                catch (Exception)
                {
                    // Ignoruj błędy i sprawdź następny port
                }
            }
            return null;
        }

        private bool SprawdźUrządzenie(SerialPort serialPort)
        {
            // Implementacja logiki sprawdzania urządzenia
            return true; // Zmień to na właściwe sprawdzenie
        }

        private void progressBar1_Click(object sender, EventArgs e)
        {
            // Kod dla kliknięcia na progressBar1 (jeśli potrzebny)
        }

        //---------programator koniec---------------
        private void openFileDialog1_FileOk(object sender, System.ComponentModel.CancelEventArgs e)
        {

        }
    }
}
#nullable restore
public class FileReader
{
    public void LoadFileToRichTextBox(string filePath, RichTextBox richTextBox1)
    {
        try
        {
            // Sprawdzenie, czy plik istnieje
            if (File.Exists(filePath))
            {
                // Odczytanie zawartości pliku
                string fileContent = File.ReadAllText(filePath);

                // Zapisanie zawartości do RichTextBox
                richTextBox1.Text = fileContent;

            //MessageBox.Show("Plik został poprawnie odczytany.", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            else
            {
                MessageBox.Show("Plik nie istnieje.", "Błąd", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Wystąpił błąd podczas odczytu pliku: {ex.Message}", "Błąd", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }
}
public class FileWriter
{
    public void SaveRichTextBoxToFile(string filePath, RichTextBox richTextBox1)
    {
        try
        {
            // Zapisanie zawartości RichTextBox do pliku
            File.WriteAllText(filePath, richTextBox1.Text, Encoding.UTF8);

           // MessageBox.Show("Plik został poprawnie zapisany.", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Wystąpił błąd podczas zapisywania pliku: {ex.Message}", "Błąd", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }
}
namespace AGNES_8b2k
{
    partial class Form1
    {

        /// <summary>
        ///  Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        ///  Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        ///  Required method for Designer support - do not modify
        ///  the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Form1));
            menuStrip1 = new MenuStrip();
            aSMToolStripMenuItem = new ToolStripMenuItem();
            otwórzPlikASMToolStripMenuItem = new ToolStripMenuItem();
            zapiszToolStripMenuItem = new ToolStripMenuItem();
            kompilujToolStripMenuItem = new ToolStripMenuItem();
            uruchomKompilatorToolStripMenuItem = new ToolStripMenuItem();
            pomocToolStripMenuItem = new ToolStripMenuItem();
            listaPoleceńToolStripMenuItem = new ToolStripMenuItem();
            mOVLBToolStripMenuItem = new ToolStripMenuItem();
            mOVRBToolStripMenuItem = new ToolStripMenuItem();
            mOVEBToolStripMenuItem = new ToolStripMenuItem();
            programToolStripMenuItem = new ToolStripMenuItem();
            uruchomProgramatorToolStripMenuItem = new ToolStripMenuItem();
            openFileDialog1 = new OpenFileDialog();
            richTextBox1 = new RichTextBox();
            richTextBox2 = new RichTextBox();
            progressBar1 = new ProgressBar();
            listBox1 = new ListBox();
            menuStrip1.SuspendLayout();
            SuspendLayout();
            // 
            // menuStrip1
            // 
            menuStrip1.BackColor = SystemColors.MenuHighlight;
            menuStrip1.Font = new Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point, 238);
            menuStrip1.Items.AddRange(new ToolStripItem[] { aSMToolStripMenuItem, kompilujToolStripMenuItem, pomocToolStripMenuItem, programToolStripMenuItem });
            menuStrip1.Location = new Point(0, 0);
            menuStrip1.Name = "menuStrip1";
            menuStrip1.Size = new Size(892, 24);
            menuStrip1.TabIndex = 4;
            menuStrip1.Text = "menuStrip1";
            menuStrip1.ItemClicked += menuStrip1_ItemClicked;
            // 
            // aSMToolStripMenuItem
            // 
            aSMToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { otwórzPlikASMToolStripMenuItem, zapiszToolStripMenuItem });
            aSMToolStripMenuItem.Name = "aSMToolStripMenuItem";
            aSMToolStripMenuItem.Size = new Size(43, 20);
            aSMToolStripMenuItem.Text = "Asm";
            aSMToolStripMenuItem.Click += aSMToolStripMenuItem_Click;
            // 
            // otwórzPlikASMToolStripMenuItem
            // 
            otwórzPlikASMToolStripMenuItem.Name = "otwórzPlikASMToolStripMenuItem";
            otwórzPlikASMToolStripMenuItem.Size = new Size(112, 22);
            otwórzPlikASMToolStripMenuItem.Text = "Otwórz";
            otwórzPlikASMToolStripMenuItem.Click += otwórzToolStripMenuItem_Click;
            // 
            // zapiszToolStripMenuItem
            // 
            zapiszToolStripMenuItem.Name = "zapiszToolStripMenuItem";
            zapiszToolStripMenuItem.Size = new Size(112, 22);
            zapiszToolStripMenuItem.Text = "Zapisz";
            zapiszToolStripMenuItem.Click += zapiszToolStripMenuItem_Click;
            // 
            // kompilujToolStripMenuItem
            // 
            kompilujToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { uruchomKompilatorToolStripMenuItem });
            kompilujToolStripMenuItem.Name = "kompilujToolStripMenuItem";
            kompilujToolStripMenuItem.Size = new Size(78, 20);
            kompilujToolStripMenuItem.Text = "Kompilator";
            // 
            // uruchomKompilatorToolStripMenuItem
            // 
            uruchomKompilatorToolStripMenuItem.Name = "uruchomKompilatorToolStripMenuItem";
            uruchomKompilatorToolStripMenuItem.Size = new Size(185, 22);
            uruchomKompilatorToolStripMenuItem.Text = "Uruchom kompilator";
            uruchomKompilatorToolStripMenuItem.Click += uruchomKompilatorToolStripMenuItem_Click;
            // 
            // pomocToolStripMenuItem
            // 
            pomocToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { listaPoleceńToolStripMenuItem });
            pomocToolStripMenuItem.Name = "pomocToolStripMenuItem";
            pomocToolStripMenuItem.Size = new Size(57, 20);
            pomocToolStripMenuItem.Text = "Pomoc";
            // 
            // listaPoleceńToolStripMenuItem
            // 
            listaPoleceńToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { mOVLBToolStripMenuItem, mOVRBToolStripMenuItem, mOVEBToolStripMenuItem });
            listaPoleceńToolStripMenuItem.Name = "listaPoleceńToolStripMenuItem";
            listaPoleceńToolStripMenuItem.Size = new Size(143, 22);
            listaPoleceńToolStripMenuItem.Text = "Lista poleceń";
            // 
            // mOVLBToolStripMenuItem
            // 
            mOVLBToolStripMenuItem.Name = "mOVLBToolStripMenuItem";
            mOVLBToolStripMenuItem.Size = new Size(115, 22);
            mOVLBToolStripMenuItem.Text = "MOVLB";
            // 
            // mOVRBToolStripMenuItem
            // 
            mOVRBToolStripMenuItem.Name = "mOVRBToolStripMenuItem";
            mOVRBToolStripMenuItem.Size = new Size(115, 22);
            mOVRBToolStripMenuItem.Text = "MOVRB";
            // 
            // mOVEBToolStripMenuItem
            // 
            mOVEBToolStripMenuItem.Name = "mOVEBToolStripMenuItem";
            mOVEBToolStripMenuItem.Size = new Size(115, 22);
            mOVEBToolStripMenuItem.Text = "MOVEB";
            // 
            // programToolStripMenuItem
            // 
            programToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { uruchomProgramatorToolStripMenuItem });
            programToolStripMenuItem.Name = "programToolStripMenuItem";
            programToolStripMenuItem.Size = new Size(65, 20);
            programToolStripMenuItem.Text = "Program";
            // 
            // uruchomProgramatorToolStripMenuItem
            // 
            uruchomProgramatorToolStripMenuItem.Name = "uruchomProgramatorToolStripMenuItem";
            uruchomProgramatorToolStripMenuItem.Size = new Size(194, 22);
            uruchomProgramatorToolStripMenuItem.Text = "Uruchom programator";
            uruchomProgramatorToolStripMenuItem.Click += uruchomProgramatorToolStripMenuItem_Click;
            // 
            // openFileDialog1
            // 
            openFileDialog1.FileName = "openFileDialog1";
            openFileDialog1.FileOk += openFileDialog1_FileOk;
            // 
            // richTextBox1
            // 
            richTextBox1.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right;
            richTextBox1.BackColor = Color.Black;
            richTextBox1.BorderStyle = BorderStyle.None;
            richTextBox1.Font = new Font("Segoe UI", 11F);
            richTextBox1.ForeColor = Color.Aqua;
            richTextBox1.ImeMode = ImeMode.NoControl;
            richTextBox1.Location = new Point(244, 36);
            richTextBox1.MaxLength = 0;
            richTextBox1.Name = "richTextBox1";
            richTextBox1.Size = new Size(359, 323);
            richTextBox1.TabIndex = 5;
            richTextBox1.Text = "";
            richTextBox1.KeyDown += richTextBox1_KeyDown;
            richTextBox1.PreviewKeyDown += richTextBox1_PreviewKeyDown;
            // 
            // richTextBox2
            // 
            richTextBox2.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right;
            richTextBox2.BackColor = Color.Black;
            richTextBox2.BorderStyle = BorderStyle.None;
            richTextBox2.Cursor = Cursors.No;
            richTextBox2.Font = new Font("Segoe UI", 11F);
            richTextBox2.ForeColor = Color.Aqua;
            richTextBox2.Location = new Point(609, 36);
            richTextBox2.Name = "richTextBox2";
            richTextBox2.ReadOnly = true;
            richTextBox2.RightToLeft = RightToLeft.No;
            richTextBox2.Size = new Size(271, 323);
            richTextBox2.TabIndex = 6;
            richTextBox2.Text = "";
            // 
            // progressBar1
            // 
            progressBar1.Anchor = AnchorStyles.Bottom | AnchorStyles.Right;
            progressBar1.BackColor = SystemColors.Control;
            progressBar1.Location = new Point(609, 337);
            progressBar1.Name = "progressBar1";
            progressBar1.Size = new Size(271, 22);
            progressBar1.TabIndex = 7;
            progressBar1.Visible = false;
            progressBar1.Click += progressBar1_Click;
            // 
            // listBox1
            // 
            listBox1.BackColor = SystemColors.WindowText;
            listBox1.BorderStyle = BorderStyle.None;
            listBox1.Font = new Font("Segoe UI", 11F);
            listBox1.ForeColor = Color.LightGreen;
            listBox1.FormattingEnabled = true;
            listBox1.ItemHeight = 20;
            listBox1.Location = new Point(12, 36);
            listBox1.Name = "listBox1";
            listBox1.Size = new Size(160, 320);
            listBox1.TabIndex = 8;
            // 
            // Form1
            // 
            AutoScaleDimensions = new SizeF(7F, 15F);
            AutoScaleMode = AutoScaleMode.Font;
            AutoScroll = true;
            AutoValidate = AutoValidate.EnablePreventFocusChange;
            BackColor = SystemColors.MenuText;
            BackgroundImageLayout = ImageLayout.Center;
            ClientSize = new Size(892, 371);
            Controls.Add(listBox1);
            Controls.Add(progressBar1);
            Controls.Add(richTextBox2);
            Controls.Add(richTextBox1);
            Controls.Add(menuStrip1);
            DoubleBuffered = true;
            Icon = (Icon)resources.GetObject("$this.Icon");
            MainMenuStrip = menuStrip1;
            Name = "Form1";
            StartPosition = FormStartPosition.CenterScreen;
            Text = "AGNES_8b2k";
            Load += Form1_Load;
            menuStrip1.ResumeLayout(false);
            menuStrip1.PerformLayout();
            ResumeLayout(false);
            PerformLayout();
        }

        #endregion
        private MenuStrip menuStrip1;
        private ToolStripMenuItem aSMToolStripMenuItem;
        private ToolStripMenuItem otwórzPlikASMToolStripMenuItem;
        private ToolStripMenuItem kompilujToolStripMenuItem;
        private ToolStripMenuItem uruchomKompilatorToolStripMenuItem;
        private ToolStripMenuItem pomocToolStripMenuItem;
        private ToolStripMenuItem listaPoleceńToolStripMenuItem;
        private ToolStripMenuItem mOVLBToolStripMenuItem;
        private ToolStripMenuItem mOVRBToolStripMenuItem;
        private ToolStripMenuItem mOVEBToolStripMenuItem;
        private OpenFileDialog openFileDialog1;
        private RichTextBox richTextBox1;
        private RichTextBox richTextBox2;
        private ToolStripMenuItem zapiszToolStripMenuItem;
        private ProgressBar progressBar1;
        private ToolStripMenuItem programToolStripMenuItem;
        private ToolStripMenuItem uruchomProgramatorToolStripMenuItem;
        private ListBox listBox1;
    }
}

                                                                                      image.thumb.png.d6d963c47daf279f89996662a573621a.png

Zrzut ekranu uruchomionej aplikacji:

                                                                                      image.thumb.png.88188150a8b7ac8784872c75c80ec139.png

Dodam że wiem jak utworzyć nowe okno z Interface graficzny użytkownika. Używam Visual Studio. Chodzi mi o napisanie poprawnej integracji kodu.

Najważniejsze jest to że jestem zupełnie zielony w tym temacie, więc liczę na pomoc..., a nie na odrobienie pracy domowej przez kolegów...

Pozdrawiam.

Edytowano przez kroszkanorber
Link do komentarza
Share on other sites

Chciałem na początku napisać prosta aplikację w oknie. Potem kupiłem książki z których niczego nie zrozumiałem. Następnie znalazłem na YT Pasja Informatyki. Zacząłem trybić o co chodzi. Aplikacje kalkulatora napisałem... :). Albo przepisałem.... Coś tam rozumiem . Ogólnie jest potrzebna duża wiedza by programować moja ogranicza się do poskładania puzzli. Moje pytanie to jak wygląda struktura oprogramowania by działał poprawnie. Windows Form czy inne programy dla mnie pewnie nie będzie różnicy. Nie będę w stanie tych narzędzi przy mojej wiedzy w pełni wykorzystać. Nie jest to dla mnie intuicyjne. A to nie jest moja pierwsza aplikacja były już próby...

Link do komentarza
Share on other sites

@H1M4W4R1 przepisuje kody potem coś zmieniam i patrzę na wyniki. Tak się uczę jak działają. Jak coś nie trybi to szukam przyczyny w necie. Masz rację że poszedłem na łatwiznę i to chyba nie jest dobre.

Link do komentarza
Share on other sites

Zarejestruj się lub zaloguj, aby ukryć tę reklamę.
Zarejestruj się lub zaloguj, aby ukryć tę reklamę.

jlcpcb.jpg

jlcpcb.jpg

Produkcja i montaż PCB - wybierz sprawdzone PCBWay!
   • Darmowe płytki dla studentów i projektów non-profit
   • Tylko 5$ za 10 prototypów PCB w 24 godziny
   • Usługa projektowania PCB na zlecenie
   • Montaż PCB od 30$ + bezpłatna dostawa i szablony
   • Darmowe narzędzie do podglądu plików Gerber
Zobacz również » Film z fabryki PCBWay

Używam symfonie c++ . I w tym języku zacząłem pisać pierwsza aplikację. Uczyłem się wybiórczo ponieważ nie było to moim założeniem. Chciałem napisać coś co po prostu ułatwi mi programowanie kontrolera opisanego w fpga. Czyli stworzyć proste narzędzie. Kompilator Assembler do kodu maszynowego. No i wpadłem w temat który okazał się dla mnie zbyt rozległy by można się nauczyć w tydzień. Wiem. Trochę mnie poniosło... Założenia dla aplikacji są proste. Otwieramy okno w menu i wpisujemy polecenia a obok poleceń we właściwościach kod na jaki ma być przetworzone. Gdy tabela uzupełniona zatwierdzamy. Teraz kompilator skanuje linia po linii i wyszukuje słowa kluczowe. Każda linia ze słowem kluczowym to kolejna linia kodu. W ten sposób zostaje przyporządkowane polecenie do adresu. Przerwania występują jako niezdefiniowane słowa w linijce wyżej wskazując na adres z poleceniem zapisanym w następnej linii. W sumie nie jest to skomplikowany algorytm. Kod który podałem właśnie to robi. Do tego koloruje słowa kluczowe użyte w kodzie. Kompiluje liczby Dec Hex do postaci binarnej. Rozpoznaje drugie słowo występujące po poleceniu i je też dekoduje do postaci binarnej. Chciałem dopisać kod bym mógł w aplikacji definiować polecenia, długość pliku binarnego i debuger. Debuger który napisałem testuje tylko słowo za poleceniem i zwraca ewentualny błędnie napisane czyli nie znalezione drugie słowo za kodem i zaznacza je w aplikacji. Najechanie myszą generuje podpowiedzi kojarzone ze słowami zdefiniowanymi jako #define rejestr h'ff' lub przerwaniami w kodzie np main. Zdjęcie obrazuje w jakiej postaci jest wyświetlane okno aplikacji. Naturalnie można napisać coś bardziej profesjonalnego ale dla mnie to i tak po 3 miesiącach nauki to szczyt osiągnięć. Jak zaczynałem to tak na serio nie wiedziałem jak się wyświetla hello world w oknie konsoli... Jak macie coś do nauki to piszcie. Przynajmniej sprawdzę czy to dla mnie. Dzięki za odpowiedzi

  • Lubię! 1
Link do komentarza
Share on other sites

@kroszkanorber Nadal nie podałeś ani jednego przykładu.

Piszesz że uczysz się się z "Symfonii C++" Grębosza, a pokazujesz kod w C#. C++ i C# to różne języki  programowania. Nota bene, "Symfonia" to już wykopalisko, jeśli odpowiada ci styl  Grębosza i chcesz uczyć się C++, to kup sobie jego "Opus Magnum", ale i tak będziesz potrzebował najpierw coś dla początkujących.

Do C# potrzebujesz innego podręcznika, coś w typie "Nauka programowania w C# dla początkujących", bo takie pozycje jak "C# 12 w pigułce" choć rzeczywiście dobre, to jednak wymagają od czytelnika pewnej wiedzy.

To w jakim języku masz zamiar pisać? Jakiego języka masz zamiar się uczyć (na początek)?

Używasz Visual Studio. Skompresuj cały katalog projektu i dodaj jako załącznik. Postaram się dokładniej zrozumieć o co Ci chodzi i może coś  podpowiem.

Jeśli chcesz pomocy, to napisz - dokładnie i z przykładami -  co ten program ma robić (nie jak ma robić!, to się określi dopiero w kolejnym etapie). Oddziel kolorowanie składni od pozostałych zadań. Najpierw niech zrobi najważniejsze, ozdóbkami zajmij się na końcu. Sugerował bym , abyś wpisał do pliku - lub kilku, jeśli wolisz - to co masz wpisywać do okien i najpierw napisał program który wczyta te pliki i zrobi co ma być zrobione, a okienkami i kolorkami bawił się gdy będziesz miał działający, sprawdzony i użyteczny program.  Dzięki temu nie będziesz co chwilę od nowa pisał danych testowych. Edytorów, nawet takich które umożliwiają własne definiowanie kolorowania składni jest trochę. Potem możesz napisać od zera pasujący do Twoich oczekiwań interface użytkownika, lub np. jakąś wstawkę do Visual Studio Code czy Notepad++.

  • Lubię! 1
Link do komentarza
Share on other sites

Bądź aktywny - zaloguj się lub utwórz konto!

Tylko zarejestrowani użytkownicy mogą komentować zawartość tej strony

Utwórz konto w ~20 sekund!

Zarejestruj nowe konto, to proste!

Zarejestruj się »

Zaloguj się

Posiadasz własne konto? Użyj go!

Zaloguj się »
×
×
  • Utwórz nowe...

Ważne informacje

Ta strona używa ciasteczek (cookies), dzięki którym może działać lepiej. Więcej na ten temat znajdziesz w Polityce Prywatności.