aus Text Kommentare entfernen

[robochris]

Hallo Zusammen,

folgendes Programm würde ich gerne schreiben, weiss aber nicht genau, wie die beste Lösung ist:

1. Gegeben ist ein Text-File, z.B. eine Java Source File
2. Die Kommentare fangen alle mit // an
3. ich möchte den Text hinter // in jeder Zeile entfernen

In einer späteren Version möchte ich #defines erkennen und jeden Text ersetzen, also:

1. gegeben sind defines wie z.B.
#define zahl 1234
2. im Text kommt z.B. folgendes vor:
print(zahl)
3. jetzt muss das Programm alle "zahl" durch 1234 ersetzen

Hat jemand eine Idee, wie ich anfangen könnte?

Gruß,
chris

 

[Wildcard]

Ich würde da mit einem AST rangehen. Mit allen anderen Varianten wirst du früher oder später an Grenzen stoßen.

 

[robochris]

Ich würde da mit einem AST rangehen. Mit allen anderen Varianten wirst du früher oder später an Grenzen stoßen.

Brauch ich da eine Säge? Ausser die Dinger am Baum kenn ich keine Äste


Mein Problem ist ein wenig folgendes:

Eine große Datei liest man anscheinend am besten in einen StringBuffer ein:

String line=new String();

try{
in=new BufferedReader(new FileReader("test.txt"));
buffer = new StringBuffer();
while((line=in.readLine())!=null) {
line=line.toLowerCase();
buffer.append(line).append('\n');
}

Die Frage ist: Wie kann ich den StringBuffer nachher am besten Zeilenweise wieder auslesen?

 

[GilbertGrape]

Also wenn es jetzt nur um die Kommentargeschichte geht, brauchst du doch nur nach // suchen und dann bis zum nächsten \n löschen.

 

[robochris]

Also wenn es jetzt nur um die Kommentargeschichte geht, brauchst du doch nur nach // suchen und dann bis zum nächsten \n löschen.

Das mit der Kommentargeschichte wäre natürlich einfach. Ich möchte aber einen Assembler für einen Mikrocontroller schreiben.

Dazu muss ich folgendes tun:

1. alle Kommentare aus Code entfernen
2. alle #defines finden und den Text im Code durch den Text der defines ersetzen
3. alle Sprunglabel im Code finden
4. alle Befehler parsen
5. alle Spruglabel in den Befehlen ersetzten

Um mich dem Problem ein wenig anzunähern, beginne ich mit Schritt 1: Kommentare aus Text entfernen

Dazu sehe ich folgend Möglichkeiten:

1.Datei Zeilenweise auslesen
2. Kommentare Zeilenweise entfernen
3. Datei Zeilenweis abspeichern.

Mir scheint es aber eventuell besser, erst die Datei vollständig einzulesen und dann den zu verändernden und zu interpretierenden Text im Speicher hallten.

 

[Wildcard]

http://en.wikipedia.org/wiki/Abstract_syntax_tree

 

[Beni]

In meinem C-Preprocessor, den ich vor einigen Monaten schrieb, habe ich einen neuen InputStream geschrieben, der Kommentare entfernt. Das ist nicht sehr schwierig (sobald ein // erkannt wird, werden Zeichen weggeworfen bis eine neue Zeile kommt...), ziemlich schnell in der Bearbeitung und dein Programm bemerkt nichtmal dass da an den Dateien rumgespielt wird beim lesen.

Da du noch nicht weisst was ein AST ist (Abstract Syntax Tree) würde ich dir aber erstmal empfehlen ein bisschen was über Parser/Compiler zu lernen bevor du beginnst zu Programmieren. Es gibt tolle Libraries die dir viel Arbeit abnehmen können (persönlich benutze ich CUP als Parsergenerator und JFlex als Lexergenerator).den Vorteil, dass

 

[xysawq]

Na dann viel Spaß bei deinen Roboterbauten ^^.

Mir ist das ganze ab Schritt 3 zu hoch...

Und für Schritt 2 müsste ich zu lange grübeln, hab jetzt aber Schicht im Schacht ^^.


Schönen Feierabend.

 

[robochris]

Da du noch nicht weisst was ein AST ist (Abstract Syntax Tree) würde ich dir aber erstmal empfehlen ein bisschen was über Parser/Compiler zu lernen bevor du beginnst zu Programmieren. Es gibt tolle Libraries die dir viel Arbeit abnehmen können (persönlich benutze ich CUP als Parsergenerator und JFlex als Lexergenerator).

Jaja, ich weis schon, dass es viele vorgefertigte Verfahren gibt. Ich möchte aber etwas über Java lernen und der Parser für einen Assembler ist ziemlich einfach ( keine Schachtelungen ), deshalb glaube ich auf AST, JFLEX, YACC verzichten zu können.

Was ich brauche ist eine Methode, um den StringBuffers Zeilenweise auszulesen. Man könnte einfach nach "\n" suchen und damit die einzelnen Zeilen des StringBuffers auslesen.

Die Frage ist: geht's einfacher?

 

[FArt]

Noch mal, falls das nicht klar rausgekommen sein sollte:

Nur mit den Kommentaren und den defines kommst du nicht weit, das ist langweilig... du brauchst einen Parser (dein Punkt 4 schreit danach). Da kannst du auch sehr viel lernen.

Hiermit habe ich schon gute Erfahrung gemacht: http://antlr.org/

 

[robochris]

Nur mit den Kommentaren und den defines kommst du nicht weit, das ist langweilig..

Für einen Experten ist es sicherlich langweilig. Was Java anbelangt, bin ich aber keiner. Deshalb muss ich klein anfangen.

Jetzt habe ich hier mal einen Code für die Kommentarentfernung geschrieben, ich hoffe, er erscheint euch nicht zu umständlich.

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;

public class LineReader 
{	
	ArrayList<String> buffer=new ArrayList<String>();
	
	public ArrayList<String> getBuffer()
	{
		return buffer;
	}
	public String removeComment(String line)
	{
        int i=line.indexOf("//",0);
        if(i!=-1)
        {
    	   line=line.substring(0,i); // remove comment
        }
        return line;
	}
	public ArrayList<String> removeComment(ArrayList<String> input)
	{
		ArrayList<String> result=new ArrayList<String>();
		
		for(int n=0;n<input.size();n++)
		{
			result.add(removeComment(input.get(n)));
			//System.out.println(n+": "+list.get(n));
		}
		return result;
	}

	public void readLines(File fp)
    throws Exception
    {
		BufferedReader in = new BufferedReader(new FileReader(fp));

        String line = null;
        int n=0;
        
        line=in.readLine();
        while(line !=null)
        {         
            System.out.println(line+"  ");
            buffer.add(line);
            n++;
            line=in.readLine();
        }
    }
	public void dumpStringArray(ArrayList<String> list)
	{
		for(int n=0;n<list.size();n++)
		{
			System.out.println(n+": "+list.get(n));
		}
	}

	public static void main(String[] args) 
	{
		String FileName="C:\\Dokumente und Einstellungen\\chris\\Desktop\\test.txt";
		System.out.println(FileName);
		File f = new File(FileName);
		LineReader lr=new LineReader();
		try{lr.readLines(f);}	catch(Exception e){System.out.println("raus");};
		lr.dumpStringArray(lr.getBuffer());
		System.out.println();
		System.out.println("Ohne Kommentare");
		lr.dumpStringArray(lr.removeComment(lr.getBuffer()));
		
	    System.out.println("program ended");
	}

}

0: bla
1: blub
2: hallo
3: // test
4: wirklich // so geht's

Ohne Kommentare
0: bla
1: blub
2: hallo
3:
4: wirklich
program ended

 

[Beni]

Noch eine Variante (die aber mit einigen Codierungen Schwierigkeiten haben wird. Vielleicht wäre es besser gewesen einen java.io.Reader zu benutzen). Ist nicht unbedingt besser als deines, aber dient vielleicht als Anregung wie es auch möglich wäre.

package test;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class NoCommentInputStream extends InputStream{
    // TEST
    public static void main( String[] args ) throws IOException {
        String file = "test.txt";
        InputStream in = new NoCommentInputStream( new FileInputStream( file ));
        int read;
        while( (read = in.read()) != -1 ){
            System.out.print( (char)read );
        }
    }
    // END TEST
    
    private InputStream in;
    private int last = 0;
    
    public NoCommentInputStream( InputStream in ){
        this.in = in;
    }
    
    @Override
    public int read() throws IOException {
        if( last == 0 )
            last = in.read();
        
        int next = in.read();
        
        if( last == '/' && next == '/' ){
            while( next != '\n' && next != '\r' && next != -1 )
                next = in.read();
            
            last = next;
            next = in.read();
        }
        
        int result = last;
        last = next;
        return result;
    }
}

 

[robochris]

Hallo Beni,

Dein Beispiel finde ich ganz gut, weil es sehr schön zeigt, wie man mit Streams arbeitet. Bis jetzt habe ich Streams noch nicht benutzt, aber man sieht ganz gut, wie man es für das Kommentar entfernen verwenden kann.

Besten Dank,
chris