Funktionen und Prozeduren

[Slashmob]

Moin zusammen,

zurzeit bearbeite ich wiedermal eine Projektaufgabe, die viele Prozeduren und Funktionen beinhaltet. Die Aufgabenstellung bereitet mir schon Schwierigkeiten. Bin noch Anfänger und die gesamte Aufgabe erscheint mir ziemlich schwer und unübersichtlich. Ich weiß gar nicht wo ich anfangen soll...


Kann mir wer bei diesem Abschnitt behilflich sein?

1. Eine Funktion, die eine Kommentarzeile verwirft, d.h. überspringt.

Delphi-Quellcode:

function Verwerfe_Kommentarzeile(s:string):boolean; // überspringt die Kommentarzeile
    var return_wert:boolean;
       position:integer;
       begin
            If (s[1]='/') and (s[2]='/') then     // Ist der Ansatz richtig??
               result=true;
            else
            result=false;
    end;

2. Eine Prozedur, die Groß- und Kleinschreibung ignoriert.

Delphi-Quellcode:

procedure erlaube_gross_Kleinschreibung(var s:string);
       begin
            s:=uppercase(s);  // Großschreibung
    end;

3. Eine Prozedur, die Kommentare an bestimmten Positionen verwirft, d.h löscht.

Delphi-Quellcode:

 procedure bereinige_Datensatz_von_Kommentaren(var s:string);
    // löscht im Datensatz den folgenden Kommentar
    var
       position:integer;
       begin
    end;

4. Eine Prozedur, die führende Leerzeichen löscht.

Delphi-Quellcode:

 procedure loesche_fuehrende_Leerzeichen(var s:string);
       begin
            while s[1]= '' do              // Passt das so?
            delete (s,1,1);    
       end;

[Lemmy]

hi,

so richtig versteh ich nicht, aber schau mal in der Hilfe nach unter:
Aufgabe 1: POS (geht aber auch so)
Aufgabe 2: ???
Aufgabe 3: POS und COPY
Aufgabe 4: TRIM

Grüße

[Sir Rufo]

Ich weiß ja nicht wer die Funktions-/Prozedur-Namen vergeben hat, aber die Funktionen passen nicht zur Benennung.

Diese Funktion verwirft oder überspringt keine Kommentarzeile, sondern prüft, ob es sich um eine Kommentarzeile handelt.
Der Name ist also verwirrend und sollte daher auf

Delphi-Quellcode:

function Ist_Kommentarzeile( const s : string ) : Boolean;

geändert werden - oder die Funktion macht nicht das, was sie eigentlich machen soll ;)

Zitat:

Zitat von Slashmob (Beitrag 1144530)

1. Eine Funktion, die eine Kommentarzeile verwirft, d.h. überspringt.

Delphi-Quellcode:

function Verwerfe_Kommentarzeile(s:string):boolean; // überspringt die Kommentarzeile
    var return_wert:boolean;
       position:integer;
       begin
            If (s[1]='/') and (s[2]='/') then     // Ist der Ansatz richtig??
               result=true;
            else
            result=false;
    end;

Was soll diese Prozedur denn nun? Groß- und Kleinschreibung ignorieren? erlauben?
Aktuell macht diese Prozedur nichts von alledem, sondern wandelt alle Zeichen in Großbuchstaben um.

Zitat:

Zitat von Slashmob (Beitrag 1144530)

2. Eine Prozedur, die Groß- und Kleinschreibung ignoriert.

Delphi-Quellcode:

procedure erlaube_gross_Kleinschreibung(var s:string);
       begin
            s:=uppercase(s);  // Großschreibung
    end;

ok, die ist wohl noch nicht fertig :)

Zitat:

Zitat von Slashmob (Beitrag 1144530)

3. Eine Prozedur, die Kommentare an bestimmten Positionen verwirft, d.h löscht.

Delphi-Quellcode:

 procedure bereinige_Datensatz_von_Kommentaren(var s:string);
    // löscht im Datensatz den folgenden Kommentar
    var
       position:integer;
       begin
    end;

Diese Prozedur macht tatsächlich genau das, was der Name vermuten lässt

Zitat:

Zitat von Slashmob (Beitrag 1144530)

4. Eine Prozedur, die führende Leerzeichen löscht.

Delphi-Quellcode:

 procedure loesche_fuehrende_Leerzeichen(var s:string);
       begin
            while s[1]= '' do              // Passt das so?
            delete (s,1,1);    
       end;

[Slashmob]

Zitat:

Zitat von Sir Rufo (Beitrag 1144555)

Ich weiß ja nicht wer die Funktions-/Prozedur-Namen vergeben hat, aber die Funktionen passen nicht zur Benennung.

Diese Funktion verwirft oder überspringt keine Kommentarzeile, sondern prüft, ob es sich um eine Kommentarzeile handelt.
Der Name ist also verwirrend und sollte daher auf

Delphi-Quellcode:

function Ist_Kommentarzeile( const s : string ) : Boolean;

geändert werden - oder die Funktion macht nicht das, was sie eigentlich machen soll ;)

Zitat:

Zitat von Slashmob (Beitrag 1144530)

1. Eine Funktion, die eine Kommentarzeile verwirft, d.h. überspringt.

Delphi-Quellcode:

function Verwerfe_Kommentarzeile(s:string):boolean; // überspringt die Kommentarzeile
    var return_wert:boolean;
       position:integer;
       begin
            If (s[1]='/') and (s[2]='/') then     // Ist der Ansatz richtig??
               result=true;
            else
            result=false;
    end;

Was soll diese Prozedur denn nun? Groß- und Kleinschreibung ignorieren? erlauben?
Aktuell macht diese Prozedur nichts von alledem, sondern wandelt alle Zeichen in Großbuchstaben um.

Zitat:

Zitat von Slashmob (Beitrag 1144530)

2. Eine Prozedur, die Groß- und Kleinschreibung ignoriert.

Delphi-Quellcode:

procedure erlaube_gross_Kleinschreibung(var s:string);
       begin
            s:=uppercase(s);  // Großschreibung
    end;

ok, die ist wohl noch nicht fertig :)

Zitat:

Zitat von Slashmob (Beitrag 1144530)

3. Eine Prozedur, die Kommentare an bestimmten Positionen verwirft, d.h löscht.

Delphi-Quellcode:

 procedure bereinige_Datensatz_von_Kommentaren(var s:string);
    // löscht im Datensatz den folgenden Kommentar
    var
       position:integer;
       begin
    end;

Diese Prozedur macht tatsächlich genau das, was der Name vermuten lässt

Zitat:

Zitat von Slashmob (Beitrag 1144530)

4. Eine Prozedur, die führende Leerzeichen löscht.

Delphi-Quellcode:

 procedure loesche_fuehrende_Leerzeichen(var s:string);
       begin
            while s[1]= '' do              // Passt das so?
            delete (s,1,1);    
       end;

also zu 1. den Inhalt der Prozedur hab ich geschrieben und scheint wohl falsch zu sein. Ja die Funktion soll die Kommentarzeile verwerfen, überspringen. Wie sieht sie dann richtig aus?
zu 2. Die Prozedur soll Groß-und Kleinschreibung ignorieren bzw. erlauben! Wie mach ich das??
zu 3. Auch hier weiß ich nicht wirklich was dort stehen muss.
zu 4. JUHU! :-D

[Sir Rufo]

Nein kann ich nicht - und auch niemand sonst hier ...

denn es fehlen noch ein paar wichtige Informationen.
Das was du bislang hier an Informationen gegeben hast, scheint mir nur das linke Ohr vom Eisbären zu sein ;)

[p80286]

Zitat:

Zitat von Slashmob (Beitrag 1144560)

also zu 1. den Inhalt der Prozedur hab ich geschrieben und scheint wohl falsch zu sein. Ja die Funktion soll die Kommentarzeile verwerfen, überspringen. Wie sieht sie dann richtig aus?
zu 2. Die Prozedur soll Groß-und Kleinschreibung ignorieren bzw. erlauben! Wie mach ich das??
zu 3. Auch hier weiß ich nicht wirklich was dort stehen muss.
zu 4. JUHU! :-D

Entschuldige aber da gibt es wohl ein Verständnisproblem.
Nehmen wir die 2 Groß/Kleinschreibung
Soll Groß/Kleinschreibung ignoriert werden dann tu nichts,
oder
soll Groß- und Kleinschreibung zu Groß- oder (excl.) Klein-Schreibung übersetzt werden?
Dann solltest du Großbuchstaben zu Kleinbuchstaben übersetzen. Bei Klein zu Groß fällt das ß unter den Tisch.

3)

Delphi-Quellcode:

position:=pos('//',satz);

und wie geht's mit dieser Zeile weiter? (Leerzeile, Blanks...)

Und in 4 frag Dich mal was passiert wenn Du eine Leerzeile übergibst (length()=0)

Gruß
K-H

[Slashmob]

Ok, danke soweit!
Ich werde morgen dann die Aufgabe mit den Infos reinstellen und mehr Quelltext, damit auch ersichtlich ist, was gemeint ist.

[himitsu]

Zitat:

Delphi-Quellcode:

procedure loesche_fuehrende_Leerzeichen(var s:string);
       begin
            while s[1]= '' do // Passt das so?
            delete (s,1,1);
       end;

Und jetzt übergib dieser Prozedur mal einen Leerstring, oder Einen nur aus Leerzeichen.
*peng*
Wo es kein erstes Zeichen gibt, da kann man nicht darauf zugreifen.


Aber was ich dir dringend empfehlen würde:
Eine "ordentlichere" Codeformatierung, vorallem bezüglich deiner grauenhaften Einrückung.

[silver-moon-2000]

Zitat:

Zitat von Sir Rufo (Beitrag 1144555)

Diese Prozedur macht tatsächlich genau das, was der Name vermuten lässt

Zitat:

Zitat von Slashmob (Beitrag 1144530)

4. Eine Prozedur, die führende Leerzeichen löscht.

Delphi-Quellcode:

 procedure loesche_fuehrende_Leerzeichen(var s:string);
       begin
            while s[1]= '' do              // Passt das so?
            delete (s,1,1);    
       end;

Entschuldige, aber bist Du Dir da sicher? :?
Er schreibt doch

Delphi-Quellcode:

s[1] = ''

und nicht

Delphi-Quellcode:

s[1] = ' '

oder mache ich hier aufgrund der späten Stunde (und eines Glases Noilly Prat) einen Denkfehler?

Ansonsten aber, wie schon erwähnt, der Hinweis auf

Delphi-Quellcode:

Trim(Left)

, wenn auch Steuerzeichen entfernt werden sollen/dürfen

[ConnorMcLeod]

Zitat:

Zitat von Slashmob (Beitrag 1144530)

1. Eine Funktion, die eine Kommentarzeile verwirft, d.h. überspringt.

Delphi-Quellcode:

function Verwerfe_Kommentarzeile(s:string):boolean; // überspringt die Kommentarzeile
    var return_wert:boolean;
       position:integer;
       begin
            If (s[1]='/') and (s[2]='/') then     // Ist der Ansatz richtig??
               result=true;
            else
            result=false;
    end;

Da ist Einiges im Argen...
*) wie schon gesagt wurde, passt der Name nicht zur Verwendung; wenn ich es richtig verstehe, dann sollte die Funktion *Soll_die_Zeile_verworfen_werden* heissen.
*) die Variablen sind unnotwendig
*) der übergebene String wird nicht auf seine Größe geprüft
*) die Logik kann man kürzer formulieren.
*) die Parameterübergabe mit string kann man optimieren
*) den Parameter kann man ebenso sprechend benamsen wie eine Variable ;-)

z.B.

Delphi-Quellcode:

function Soll_die_Zeile_verworfen_werden(const AZeile: string): Boolean;
begin
  Result := ((2 <= Length(AZeile)) and ('/' = AZeile[1]) and ('/' = AZeile[2]));
// oder
  Result := (1 = Pos('//', AZeile));
end;

HTH

[Slashmob]

Hier die versprochene Aufgabenstellung und die Codes. Wie gesagt ich komme mit der Aufgabenstellung nicht klar und die Programme, die schon gegeben sind, sind für mich als Anfänger unübersichtlich und "schwierig nachzuvollziehen". Wäre um Aufklärung und Hilfe sehr dankbar!

Code:

 AUFGABENSTELLUNG
Es wurde ein „Programmierplatz“ für eine Bahnsteuerung besprochen
und zum Download zur Verfügung gestellt. 
Nun soll ein Steuerungsprogramm geschrieben werden, das das früher erstellte „DIN“-Programm einliest, und auf Verwertbarkeit und Fehlerhaftigkeit testet. 
Die Eingabedatei, die von Ihrem Zeilenparser zerlegt werden soll, könnte nach einer Änderung durch den Bediener folgendermaßen aussehen:

// Programmanfang
HF0 // Kommentar 1
// Kommentarzeile
X100 Y80 // hier Fehler melden
X100X80 // hier Fehler melden
HF 1 // hier Fehler melden
X96Y151 // hier Fehler melden
DEL TAX-4DELTAY-66 // hier Fehler melden

Um Fehler zu entdecken und nach Verbesserung der Eingabedatei wieder das
ursprüngliche Bild zu zeigen, muss das Programm folgende Funktionen haben:

Datei öffnen bzw. schließen.
Zeilen einlesen und abarbeiten:
-Kommentarzeilen verwerfen
-Kommentare hinter Hilfsfunktionen oder Datensätzen verwerfen
-Führende Leerzeichen verwerfen
-Klein-/Großschreibung ignorieren
-Hilfsfunktion erkennen und Linientyp und Linienfarbe setzen
-Datensatz erkennen und absolute Koordinaten berechnen
-Fehler im Datensatz erkennen und melden.

Das Programm soll einen Datensatz von einer Hilfsfunktion unterscheiden. 
Die Hilfsfunktion steuert wie im mitgelieferten Programm für die Erstellung der Textdatei
die Farben und den Linientyp. 
Der Datensatz wird benutzt, um absolute Koordinaten zu ermitteln und eine Geometrie auf ein Imagefeld zu zeichnen. 
Für jedes Werkzeug, bzw. jede Hilfsfunktion ist zusätzlich die Bearbeitungsstrecke zu berechnen und in einem Stringgrid (mit Überschriften) auszugeben. 
Nach Erledigung der Aufgabe soll es eine Vollzugsmeldung geben.
Ein Prototyp des Programms, der zum Endprodukt weiter verfeinert werden soll, ist
im Internet abzuholen.

BAHNSTEUERUNG

Delphi-Quellcode:

unit Unit1;
// dieser Programmrumpf ist alleine nicht lauffähig!
{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, FileUtil, LResources, Forms, Controls, Graphics, Dialogs,
  StdCtrls, ExtCtrls;

type

  { TForm1 }

  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Image1: TImage;
    Memo1: TMemo;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { private declarations }
  public
    { public declarations }
  end;

var
  Form1: TForm1;
  strecke_HF                 : array[0..4] of double; // Streckenspeicher
  aktuelle_Hilfsfunktion     : integer;
  new_x,
  new_y,
  last_X,
  last_Y                     : double;

implementation

{ TForm1 }

procedure TForm1.Button1Click(Sender: TObject);   // "Memo auf Datei"
   begin

end;

procedure TForm1.Button2Click(Sender: TObject);
    var dateiname,s    : string;
        f              : textfile;
        lx,
        index,
        zeilenzaehler  : integer;
        werte          : array[1..4] of double;
        lage           : array[1..4] of integer;

    function Verwerfe_Kommentarzeile(s:string):boolean;
    // führt zum Überspringen der Kommentarzeile
    var return_wert:boolean;
       posi:integer;
       begin
    end;

    procedure loesche_fuehrende_Leerzeichen(var s:string);
       begin
            while s[1]= ' ' do
            delete (s,1,1);     // löscht erstes Zeichen (das Leerzeichen) im String
       end;

    procedure erlaube_gross_Kleinschreibung(var s:string);
       begin

    end;

    procedure bereinige_Datensatz_von_Kommentaren(var s:string);
    // löscht im Datensatz den folgenden Kommentar
    var
       posi:integer;
       begin
    end;

    procedure berechne_absolutwerte(deltax,deltay:double);
    // berechnet die Absolutwerte mit Hilfe der incrementellen
       begin
    end;

    function berechne_strecke:double;
    // berechnet für jedes Werkzeug die Summe der zurückgelegten Wege
       begin
    end;

    function extrahiere_werte(s:string):boolean;
    // diese Prozedur speichert die exrahierten Werte global
       var
           test_zaehler,                 // nur zwei positionen besetzt?
           posi1,
           posi2,
           index             :integer;
           resultat          : boolean;
           hilfsstring       : string;
           strecke,
           x,y,deltax,deltay : double;
       begin

       result:=resultat;
    end;

    function ermittle_Hilfsfunktion(s:string):boolean;
        var return_wert:boolean;
            posi:integer;
        begin
    end;

    function zeile_bearbeiten(s:string):boolean;
       var ergebnis:boolean;
           strecke: double;
    // im Fehlerfall wird ergebnis "false"

       begin
       ergebnis:=true;
       loesche_fuehrende_Leerzeichen(s);
       if Verwerfe_Kommentarzeile(s) then exit;
       erlaube_gross_Kleinschreibung(s);
       bereinige_Datensatz_von_Kommentaren(s);
       if not ermittle_Hilfsfunktion(s) then     // wenn Datensatz gefunden
          begin
          if not extrahiere_werte(s) then
             begin
             ergebnis:=false;
             result:=ergebnis;
             exit;
          end;
       end;
       result:=ergebnis;
    end;

    begin
    last_X:=0.0;
    last_Y:=0.0;
    for index:=0 to 4 do strecke_HF[index]:=0.0;
    // hier holen des Dateinamens mit opendialog!

    assignfile(f,dateiname);
    reset(f);
    zeilenzaehler:=0;
    while not eof(f) do
       begin
       readln(f,s);
       inc(zeilenzaehler);
       if not zeile_bearbeiten(s) then
          begin
          showmessage('Fehler in Zeile '+inttostr(zeilenzaehler));
          closefile(f);
          exit;
       end;
    end;
    closefile(f);
    // Strecken ausgeben
    for lx:=0 to 4 do
       begin
       showmessage('strecke'+inttostr(lx)+'='+floattostr(strecke_HF[lx]));
    end;
end;

initialization
  {$I unit1.lrs}

end.

DIN-PROGRAMM

Delphi-Quellcode:

unit Unit1; 

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, FileUtil, LResources, Forms, Controls, Graphics, Dialogs,StdCtrls, ExtCtrls; 

type

  { TForm1 }

  TForm1 = class(TForm)
    Image1: TImage;
    Label1: TLabel;
    Label2: TLabel;
    RadioGroup1: TRadioGroup;
    Button1: TButton;
    RadioGroup2: TRadioGroup;
    SaveDialog1: TSaveDialog;
    Button2: TButton;
    Button3: TButton;
    Button4: TButton;
    procedure Image1MouseMove(Sender: TObject; Shift: TShiftState; X,Y: Integer);
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure Image1MouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
    procedure Button3Click(Sender: TObject);
    procedure Button4Click(Sender: TObject);
    procedure RadioGroup1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1          : TForm1;
  Stiftzustand,
  Koordinaten,
  xglob,
  yglob,
  xold,
  yold,
  h,
  w              : integer;
  o_string,
  dateiname      : string;
  f              : textfile;
  dateioffen     : boolean;

implementation

procedure TForm1.Image1MouseMove(Sender: TObject; Shift: TShiftState; X,
  Y: Integer);                      // Koordinatenanzeige in Labels
   begin
   label1.Caption:='x= '+inttostr(x);
   label2.Caption:='y= '+inttostr(y);
end;

procedure TForm1.FormCreate(Sender: TObject);
   begin
   h:=image1.Height;                              // Höhe des Bildes zwischenspeichern
   w:=image1.Width;                               // Breite des Bildes zwischenspeichern
   image1.Canvas.Brush.Color:=clwhite;            // Farbe zum Löschen setzen
   image1.Canvas.FillRect(rect(0,0,w,h));         // Löschen
   image1.Cursor:=crcross;
   dateiname:='default.txt';
   xold:=0;
   yold:=0;
   dateioffen:=false;
   button3.Enabled:=false;
end;

procedure TForm1.Button1Click(Sender: TObject); // "Punkt speichern"

   procedure absolut;  // Absolut - Punkt anfahren
      begin
      o_string:='X'+inttostr(xglob);
      o_string:=o_string+'Y'+inttostr(yglob);
   end;

   procedure relativ; // Realtiv - Punkt anfahren
      begin
      o_string:='DELTAX'+inttostr(xglob-xold);
      o_string:=o_string+'DELTAY'+inttostr(yglob-yold);
   end;

   begin
   Stiftzustand:=radiogroup1.ItemIndex;     // Stiftzustand wählen
   Koordinaten:=radiogroup2.ItemIndex;      // Koordinatenart wählen
   case Koordinaten of
      0: absolut;
      1: relativ;
   end;
   // o_string:=o_string+'HF'+inttostr(stiftzustand);     ????
   case stiftzustand of
      0: begin      // HF0 - Eilgang
         image1.Canvas.Pen.Style := psDot;
         image1.Canvas.Pen.Color:=clred;
         image1.Canvas.LineTo(xglob,yglob);
         end;
      1: begin      // HF1 - Schneiden
         image1.Canvas.Pen.Style := psSolid;
         image1.Canvas.Pen.Color:=clblack;
         image1.Canvas.LineTo(xglob,yglob);
         end;
      2: begin      // HF2 - Koernern
         image1.Canvas.Pen.Style := psdashdot;
         image1.Canvas.Pen.Color:=clblue;
         image1.Canvas.LineTo(xglob,yglob);
         end;
      3: begin     // HF3 - Markieren
         image1.Canvas.Pen.Style := psdash;
         image1.Canvas.Pen.Color:=clgreen;
         image1.Canvas.LineTo(xglob,yglob);
         end;
      else
         showmessage('erst Werkzeug wählen!');
         exit;
      end;

   xold:=xglob;
   yold:=yglob;
   if dateioffen then
      begin
      writeln(f,o_string);
   end
   else
      begin
      showmessage('Datei nicht offen '+o_string);
   end;
end;

procedure TForm1.Button2Click(Sender: TObject);  // "Datei" speichern
   begin
   if savedialog1.execute then
      begin
      dateiname:=savedialog1.filename;
   end
   else
      dateiname:='default.txt';
   assignfile(f,dateiname);
   rewrite(f);
   dateioffen:=true;
   button2.Enabled:=false;
   button3.Enabled:=true;
   button4.Enabled:=false;
end;

procedure TForm1.Image1MouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
   begin
   xglob:=x;
   yglob:=y;
end;

procedure TForm1.Button3Click(Sender: TObject); // "Datei schließen"
   begin
   if dateioffen then
      begin
      dateioffen:=false;
      closefile(f);
      button2.Enabled:=true;
      button3.Enabled:=false;
      button4.Enabled:=true;
      end
   else
      showmessage('Datei ist nicht geöffnet, kann also nicht geschlossen werden');
end;

procedure TForm1.Button4Click(Sender: TObject); // "Prgm beenden"
   begin
   close;
end;

procedure TForm1.RadioGroup1Click(Sender: TObject);
Var o_string:string;
   begin
   o_string:='HF'+inttostr(RadioGroup1.itemindex);
   if dateioffen then
      begin
      writeln(f,o_string);
   end
   else
      begin
      showmessage('Datei nicht offen '+O_string);
   end;
end;




initialization
  {$I unit1.lrs}

end.

EINGABEDATEI (Textdatei) sieht dann z.B. so aus

Zitat:

HF0
X32Y40
HF1
X31Y97
X81Y96
X80Y40
X32Y41
HF0
X41Y35
X86Y40
HF1
DELTAX-1DELTAY56
DELTAX46DELTAY-1
DELTAX-4DELTAY-53
DELTAX-40DELTAY-4
DELTAX-1DELTAY4
HF0
DELTAX10DELTAY-6
DELTAX42DELTAY4

[p80286]

Ich hab's mal Überflogen, wenn ich es richtig verstanden habe, ist die Eingabedatei so etwas ähnliches wie eine Plottersteuerung. Das DIN-Programm wird durch die Eingabedatei gesteuert. Dein Job ist es die Eingabedatei zu prüfen und ggf. zu korrigieren/modifizieren?

Um Dich schlau zu machen solltest Du nach "Compiler" und "Parser" suchen.

Für einen ersten Einstieg
a) Kommentare löschen
b) Leerzeilen löschen
c) Sonderzeichen ("-") entfernen und melden
d) alles in Großbuchstaben
e) verbleibenden Text auf Gültigkeit prüfen (DELTAX/DELTAY HF#)

Gruß
K-H

[Slashmob]

Zitat:

Zitat von p80286 (Beitrag 1144735)

Ich hab's mal Überflogen, wenn ich es richtig verstanden habe, ist die Eingabedatei so etwas ähnliches wie eine Plottersteuerung. Das DIN-Programm wird durch die Eingabedatei gesteuert. Dein Job ist es die Eingabedatei zu prüfen und ggf. zu korrigieren/modifizieren?

Um Dich schlau zu machen solltest Du nach "Compiler" und "Parser" suchen.

Für einen ersten Einstieg
a) Kommentare löschen
b) Leerzeilen löschen
c) Sonderzeichen ("-") entfernen und melden
d) alles in Großbuchstaben
e) verbleibenden Text auf Gültigkeit prüfen (DELTAX/DELTAY HF#)

Gruß
K-H

Hab das DIN-Programm jetzt mal getestet. Das Programm erstellt eine Textdatei mit Hilfsfunktionen (Stiftwerkzeuge) und Datensätzen in Form von absoluten und relativen Koordinaten. So eine Textdatei sieht dann z.B. so aus:

Code:

HF1
X240Y132
HF2
X171Y241
X71Y162
DELTAX88DELTAY-63
DELTAX-36DELTAY178
HF3
DELTAX66DELTAY50
DELTAX71DELTAY-71
HF1
DELTAX-150DELTAY74
HF0
DELTAX181DELTAY-127
HF3
DELTAX-38DELTAY176
HF0
DELTAX-200DELTAY-43
HF1
DELTAX-43DELTAY-173
HF2
DELTAX37DELTAY-75
DELTAX97DELTAY-4

Die Hilfsfunktion HF1 bedeutet "Schneiden". "X240Y132" sind absolute Koordinaten und alles mit Delta sind relative Koordinaten.
Hab ich das jetzt richtig verstanden, dass das Bahnsteuerungsprogramm, die Textdatei vom DIN-Prgm auf Fehler untersuchen und verbessern soll? Und
Laut Aufgabenstellung soll z.B. eine Kommentarzeile verworfen werden. Was heißt verwerfen genau? Löschen oder überspringen, ignorieren ....?

[Sir Rufo]

Also es wird da einen Programmteil geben, der die ganzen Befehle abarbeiten soll.

Somit wäre es doch besser, wenn dieser Programmteil nur die reinen Befehle bekommt und nicht die ganzen Leer-/Kommentarzeilen, bzw. Kommentare am Ende einer Zeile

Aus diesem Grund schickt man die Datei mit den Befehlen erst mal durch einen "Filter" und entfernt alle unnötigen Sachen
Vor dem Filter:

Code:

// Mega-Super-Skript
HF1 // ganz was tolles
X240Y132 // noch toller

  // jetzt kommt was ganz großes

HF2 // :o)
X171Y241

// vom OberGuru geschrieben

und nach dem Filter

Code:

HF1
X240Y132
HF2
X171Y241

Als nächsten Schritt kann man jetzt die Syntax grob prüfen (z.B. ob in einer Zeile Leerzeichen vorkommen), was ja ein Fehler wäre

Am Besten du nimmst dir mal so ein "WorstCase"-Skript vor und arbeitest das "Step-By-Step" ab.

Code:

// Mega-Super-Skript
 Hf1 // ganz was tolles
  X240y132 // noch toller

// jetzt kommt was ganz großes

  hf2 // :o)
x171y241

// vom OberGuru geschrieben

[Slashmob]

Ah ok ok...da kommen wir der Sache schon ein bisschen näher. :-D
Nun muss ich also nur noch die ganzen Funktionen und Prozeduren fertigmachen, damit die Eingabedatei "bereinigt" wird.


Das hab ich schon gemacht...ist das korrekt so? Wenn nein, wo ist der Fehler?
Danke schon mal für die ganzen Tipps!

Delphi-Quellcode:

function Verwerfe_Kommentarzeile(s:string):boolean;
    // führt zum Überspringen der Kommentarzeile
    var return_wert:boolean;    // ??
        posi:integer;
       begin
            posi:=pos('//',s);
            If (s[1]='/') and (s[2]='/') then
            delete(s,posi,length(s));
       end;

    procedure loesche_fuehrende_Leerzeichen(var s:string);
       begin
            If (s <=0) then exit;            
            While (s>0) and (s[1]= ' ') do // Nur wenn String größer als 0
            delete (s,1,1);     // löscht erstes Zeichen (das Leerzeichen) im String
       end;

    procedure erlaube_gross_Kleinschreibung(var s:string); 
       begin
            s:=uppercase(s);
            s:=lowercase(s);
       end;

    procedure bereinige_Datensatz_von_Kommentaren(var s:string);
    // löscht im Datensatz den folgenden Kommentar
    var
        posi  // Position
        :integer;
       begin
            posi:=pos('//',s);
            delete(s,posi,length(s));
       end;

[p80286]

Ein wenig Konfus?

Delphi-Quellcode:

function Loesche_Kommentar(s:string):string;
var
  posi:integer;
begin
  posi:=pos('//',s);
  if Posi>0 then delete(s,posi,maxint);
  result:=s
end;
 
function Loesche_fuehrende_Leerzeichen(s:string):string;
begin
  result:=trimleft(s);
end;
 
function Erstelle_Grossschreibung(s:string):string;
begin
  result:=uppercase(s);
end;

procedure Satzverarbeitung(s:string);
var
  temps:string;

begin
  temps:=s;
  temps:=Loesche_Kommentar(temps);
  temps:=Loesche_fuehrende_Leerzeichen(temps);
  if length(temps)>0 then begin
    temps:=Erstelle_Grossschreibung(temps);
    // weitere Prüfungen
    // wenn Fehler dann Showmessage('Satz:'+s+' ist fehlerhaft!');
  end;
 
end;

Gruß
K-H

[Slashmob]

Ok, danke soweit. Das hat mir schon viel geholfen das zu verstehen. Im Prinzip besteht die Aufgabe darin mit pos,copy und delete zu arbeiten.

Nun soll ich ja eine Prozedur schreiben, die mir die Absolutwerte der Koordinaten erstellt.

Delphi-Quellcode:

procedure berechne_absolutwerte(deltax,deltay:double);
    // berechnet die Absolutwerte mit Hilfe der incrementellen
       var x,y: integer;
       begin
            x:=x+deltax;
            y:=y+deltay;
       end;

Was wäre hier die einfachste Art x und y zu berechnen.
Muss ich hier in der Textdatei nach den Werten von X und Y und den Deltawerten suchen?

[Bjoerk]

Zitat:

Zitat von Slashmob (Beitrag 1144804)

Ok, danke soweit. Das hat mir schon viel geholfen das zu verstehen. Im Prinzip besteht die Aufgabe darin mit pos,copy und delete zu arbeiten.

Nun soll ich ja eine Prozedur schreiben, die mir die Absolutwerte der Koordinaten erstellt.

Delphi-Quellcode:

procedure berechne_absolutwerte(deltax,deltay:double);
    // berechnet die Absolutwerte mit Hilfe der incrementellen
       var x,y: integer;
       begin
            x:=x+deltax;
            y:=y+deltay;
       end;

Was wäre hier die einfachste Art x und y zu berechnen.
Muss ich hier in der Textdatei nach den Werten von X und Y und den Deltawerten suchen?

Das wird wohl ohne Parser nicht gehen, weil du ja auch auf das prüfen mußt:

X100X80 // hier Fehler melden

BTW:
Was ist hier denn falsch??
X96Y151 // hier Fehler melden

Du mußt auch zuerst den Kommentar entfernen und dann erst den Trim machen, da zwischen Code und Kommentar ein Leerzeichen sein kann (also so, wie es K.-H. gemacht hat).

MFG
Thomas

[Slashmob]

Zitat:

Zitat von Bjoerk (Beitrag 1144810)

Das wird wohl ohne Parser nicht gehen, weil du ja auch auf das prüfen mußt:

X100X80 // hier Fehler melden

BTW:
Was ist hier denn falsch??
X96Y151 // hier Fehler melden

Du mußt auch zuerst den Kommentar entfernen und dann erst den Trim machen, da zwischen Code und Kommentar ein Leerzeichen sein kann (also so, wie es K.-H. gemacht hat).

MFG
Thomas

BTW:
Was ist hier denn falsch??
X96Y151 // hier Fehler melden
Gute Frage.Glaube ist korrekt so.

X100X80 // hier Fehler melden
Wie überprüf ich das?

Denk ich jetzt zu kompliziert oder geht das auch einfacher??

Delphi-Quellcode:

procedure berechne_absolutwerte(deltax,deltay:double);
    // berechnet die Absolutwerte mit Hilfe der incrementellen
       var x,y: integer;
       begin
            Position_X:=pos('X',s);    // Stelle vom Zeichen 'X' im String
            Position_Y:=pos('Y',s);    // Stelle vom Zeichen 'Y' im String
            x:=Position_X + strtoint(Position_X+1); // X-Koordinaten, ist Zahl nach dem Zeichen 'X'
            y:=Position_Y + strtoint(Position_Y+1); // Y-Koordinaten, ist Zahl nach dem Zeichen 'Y'
            Position_deltax:=pos('DELTAX',s);  // Stelle von 'DELTAX' im String
            Position_deltay:=pos('DELTAY',s);  // Stelle von 'DELTAY' im String
            deltax:= Position_deltax + strtoint(Position_deltax+1); // Deltax-Zahlenwert nach 'DELTAX'
            deltay:= Position_deltay + strtoint(Position_deltay+1); // Deltay-Zahlenwert nach 'DELTAY'

            x:=x+deltax;
            y:=y+deltay;
       end;

[Bjoerk]

Der Wert kann ja auch aus mehrstellig sein.

Ich habe mir mal folgendes überlegt, ist kein echter Parser, dürfte hier aber genügen. Der Code geht so vor, daß gültige Einträge aus dem String rausgelöscht und in einem anderen aufsummiert werden. Ist am Schluß der Eingabestring nicht leer, dann war ein Fehler aufgetreten.

Die entsprechenden Zahlenwerte werden als Integer zurückgeliefert. Diese kannst du ja bedarfsweise als Abs(Value) dem Result hinzufügen.

Mein Code soll nur als Anregung dienen !!!
==========================================

Delphi-Quellcode:

function CodeOnlyAndUpperCaseAndBlankReplace(const S: string): string;
var
  Index: integer;
begin
  Result:= S;
  Index:= Pos('//', Result);
  if Index > 1 then
    Result:= Copy(Result, 1, Index-1)
  else
    if Index = 1 then Result:= '';
  Index:= 1;
  while Index <= Length(Result) do
  begin
    if Result[Index] <= ' ' then
    begin
      Delete(Result, Index, 1);
      Dec(Index);
    end;
    Inc(Index);
  end;
  Result:= UpperCase(Result);
end;

function GetValue(var S: string; const Searchstr: string; var Value: integer): boolean;
var
  I, Index: integer;
  Substr: string;
begin
  Result:= false;
  Value:= 0;
  Index:= Pos(Searchstr, S);
  if Index > 0 then
  begin
    Substr:= '';
    I:= Index+Length(Searchstr);
    while I <= Length(S) do
    begin
      if S[I] in ['-', '0'..'9'] then
        Substr:= Substr+S[I]
      else
        Break;
      Inc(I);
    end;
    Result:= TryStrToInt(Substr, Value);
    if Result then
      Delete(S, Index, Length(Searchstr+Substr));
  end;
end;

procedure TForm1.Button10Click(Sender: TObject);
var
  S, T, Result, Searchstr: string;
  Value: integer;
  Error: boolean;
begin
  Result:= '';
  S:= 'DELTAX1DELTAY-63 // Test';
  Error:= false;

  S:= CodeOnlyAndUpperCaseAndBlankReplace(S);
  T:= S;

  Searchstr:='DELTAX';
  if (not Error) and GetValue(S, Searchstr, Value) then
  begin
    Result:= Result+Searchstr+IntToStr(Value);
    T:= S; Error:= GetValue(T, Searchstr, Value);
  end;

  Searchstr:='DELTAY';
  if (not Error) and GetValue(S, Searchstr, Value) then
  begin
    Result:= Result+Searchstr+IntToStr(Value);
    T:= S; Error:= GetValue(T, Searchstr, Value);
  end;

  Searchstr:='X';
  if (not Error) and GetValue(S, Searchstr, Value) then
  begin
    Result:= Result+Searchstr+IntToStr(Value);
    T:= S; Error:= GetValue(T, Searchstr, Value);
  end;

  Searchstr:='Y';
  if (not Error) and GetValue(S, Searchstr, Value) then
  begin
    Result:= Result+Searchstr+IntToStr(Value);
    T:= S; Error:= GetValue(T, Searchstr, Value);
  end;

  Searchstr:='HF';
  if (not Error) and GetValue(S, Searchstr, Value) then
  begin
    Result:= Result+Searchstr+IntToStr(Value);
    T:= S; Error:= GetValue(T, Searchstr, Value);
  end;

  if Length(S) <> 0 then Error:= true;

  if Error then
    Showmessage('Error: '+S)
  else
    Showmessage('Code: '+Result);
end;

end.

[Slashmob]

Hab nochmal paar Verständnisfragen.
Ich kann der Aufgabenstellung nicht ganz entnehmen wie der Ablauf des Programms ist.

Button2 führt ja quasi die "Säuberung" durch.
Aber was soll Button1 namens "Memo auf Datei" machen?
Wofür brauch ich das Memofeld in diesem Programm?

Und ich verstehe dies hier nicht:

Delphi-Quellcode:

function extrahiere_werte(s:string):boolean; // diese Prozedur speichert die exrahierten Werte global
       var
           test_zaehler,         // nur zwei positionen besetzt?
           position1,
           position2,
           i                 : integer;   // Index
           resultat          : boolean;
           hilfsstring       : string;
           strecke,
           x,y,deltax,deltay : double;
       begin
            result:=resultat;
       end;

Wäre um Tipps dankbar.
Gruß Slash

[Bjoerk]

Keine Ahnung was damit gemeint sein soll. Du sammelst die Resultstrings einfach in einer Stringlist und speicherst diese dann in einer Datei. Fertig. Zusätzlich kann man das ganze natürlich noch in einem Memo anzeigen lassen (Die einzelnen Werte liegen ja bereits vor).

[p80286]

Ich hab da was gefunden:
http://warpserv.fh-bielefeld.de/ltil...saufgabe_5.pdf

Gruß
K-H

[Slashmob]

Zitat:

Zitat von p80286 (Beitrag 1144938)

Ich hab da was gefunden:
http://warpserv.fh-bielefeld.de/ltil...saufgabe_5.pdf

Gruß
K-H

Ja, das ist die Aufgabe.

[Bjoerk]

Ich habe mir die zip von eurer fh mal angeschaut. Mega Geil.. Anyway. Es scheint wohl so zu sein, daß die X und Y Werte aufsummierst werden (X,Y = X,Y + deltaX,Y). Das ist alles.