Brauche Hilfe bei Übersetzung von Java in VB.NET - Regex, Pattern u. ä.

Mikro Fahrrad · 24. August 2016, 10:23

Hallo, ich bin gerade dabei, einen auto-generierten Code in VB.NET zu übersetzen. Das läuft soweit ganz gut, nur auf dem Gebiet "Regular Expression" habe ich gar keine Ahnung. Das Problem ist, zu genutzten Java-Klassen die nötigen .NET-Gegenstücke zu finden. Für jemanden mit Ahnung bestimmt kein Problem.

Hier die Methode, die von einem Online-Übersetzer automatisch in VB.NET übersetzt wurde:

Spoiler anzeigen

VB.NET-Quellcode

Imports java.io.Star
Imports java.util.Star
Imports java.util.regex.Star
Class V1
'....
Public Function FindToken(ByVal Rest As String) As AToken
Dim Results As ArrayList(Of Integer) = New ArrayList(Of Integer)
Dim ResultsV As ArrayList(Of String) = New ArrayList(Of String)
Try
Dim p As Pattern
Dim m As Matcher
p = Pattern.compile("^(\\()")
m = p.matcher(Rest)
If m.find Then
Results.add(New Integer(Me.t_CharKlammerAuf))
ResultsV.add(m.group)
End If
p = Pattern.compile("^(\\))")
m = p.matcher(Rest)
If m.find Then
Results.add(New Integer(Me.t_CharKlammerZu))
ResultsV.add(m.group)
End If
p = Pattern.compile("^(0)")
m = p.matcher(Rest)
If m.find Then
Results.add(New Integer(Me.t_T_0))
ResultsV.add(m.group)
End If
p = Pattern.compile("^(1)")
m = p.matcher(Rest)
If m.find Then
Results.add(New Integer(Me.t_T_1))
ResultsV.add(m.group)
End If
p = Pattern.compile("^(or)")
m = p.matcher(Rest)
If m.find Then
Results.add(New Integer(Me.t_or))
ResultsV.add(m.group)
End If
p = Pattern.compile("^(and)")
m = p.matcher(Rest)
If m.find Then
Results.add(New Integer(Me.t_and))
ResultsV.add(m.group)
End If
p = Pattern.compile("^(!)")
m = p.matcher(Rest)
If m.find Then
Results.add(New Integer(Me.t_CharNot))
ResultsV.add(m.group)
End If
p = Pattern.compile("^(gdw)")
m = p.matcher(Rest)
If m.find Then
Results.add(New Integer(Me.t_gdw))
ResultsV.add(m.group)
End If
p = Pattern.compile("^([\"& vbCr&"\"& vbLf&"\"& vbTab&"\\s])")
m = p.matcher(Rest)
If m.find Then
Results.add(New Integer(Me.t_ignore))
ResultsV.add(m.group)
End If
Catch e As Exception
End Try
Dim maxlength As Integer = 0
Dim besttoken As Integer = 0
Dim ret As AToken = New AToken
ret.token = besttoken
Dim i As Integer = 0
Do While (i < Results.size)
If (ResultsV.get(i).toString.length > maxlength) Then
maxlength = ResultsV.get(i).toString.length
besttoken = CType(Results.get(i),Integer).intValue
ret.token = besttoken
If (besttoken <> 0) Then
ret.val = ResultsV.get(i).toString
End If
End If
i = (i + 1)
Loop
Return ret
End Function

Kann mir jemand sagen, wo es die Typen "Pattern" und "Matcher" in .NET gibt und wie ich das entsprechend einbauen muss?

Besten Dank!

*Topic verschoben, Spoiler eingefügt (Code sehr lang)*

Radinator · 24. August 2016, 11:37

Was du sichst ist die Klasse RegEx aus dem Namespace System.Text.RegularExpressions.
Außerdem: Mach das Try-Catch weg und verwende keine ArrayList, sondern eine List(Of T)

Mikro Fahrrad · 24. August 2016, 11:51

Die Klasse habe ich auch bereits gefunden, nur meckert er dann:
"System.Text.RegularExpressions.Regex.pattern" ist in diesem Kontext nicht zugreifbar, da es "Protected Friend" ist.

Und was entspricht dem ".Get" in einer "List(Of T)"?

Radinator · 24. August 2016, 12:38

Entweder der zugriff über index: list(2) in vb, liste[2] in c# oder über die property Item:

VB.NET-Quellcode

Dim liste = New List(Of String)
Dim item1 = liste(1)
Dim item2 = liste.Item(1)

Mikro Fahrrad · 24. August 2016, 13:11

Jetzt habe ich nur noch das Problem, die Typen "Pattern" und "Matcher" fehlen.

Und wenn ich Regex importiere, kommt eben der Fehler:
"System.Text.RegularExpressions.Regex.pattern" ist in diesem Kontext nicht zugreifbar, da es "Protected Friend" ist.

ErfinderDesRades · 24. August 2016, 21:17

Also wenn das "kommt", dann haste wohl einen Fehler in deim Code.
Korrigiere den Code, dann "kommt" das nicht mehr.

Mikro Fahrrad · 24. August 2016, 21:31

ErfinderDesRades schrieb:

Also wenn das "kommt", dann haste wohl einen Fehler in deim Code.
Korrigiere den Code, dann "kommt" das nicht mehr.

Und genau deswegen habe ich ja das Thema erstellt, weil der "Fehler" ist, dass die Typen "Pattern" und "Matcher" so nicht in VB.NET existieren. Da ich mich auf dem Gebiet nicht auskenne, ist meine Frage ob es zu diesen Java-Typen äquivalente Typen in .NET gibt.

ErfinderDesRades · 24. August 2016, 21:34

Nein - derlei Typen gibt es nicht.
in vb.net-Regex ist der Pattern einfach ein String. - Ist in Java "Pattern" wirklich ein eigener Datentyp?

Mikro Fahrrad · 24. August 2016, 21:38

Hier mal der komplette Auto-generierte Code von AtoCC (Visual Compiler Compiler):
(Es geht um die unterste Methode)

Spoiler anzeigen

Quellcode

import java.io.*;
import java.util.*;
import java.util.regex.*;
class V1
{
YYARec[] yya;
YYARec[] yyg;
YYRRec[] yyr;
int[] yyd;
int[] yyal;
int[] yyah;
int[] yygl;
int[] yygh;
int yyn = 0;
int yystate = 0;
int yychar = -1;
int yynerrs = 0;
int yyerrflag = 0;
int yysp = 0;
int yymaxdepth = 1024;
int yyflag = 0;
int yyfnone = 0;
int[] yys = new int[1024];
String[] yyv = new String[1024];
String yyval = "";
/*public static class TOutput extends PrintWriter {
public TOutput(OutputStreamWriter o) { super(o); }
public TOutput(BufferedWriter b) { super(b); }
public TOutput(PrintStream s) { super(s); }
public void WriteLine(String s) { println(s); }
}
TOutput Output; */
String Output;
class YYARec
{
public int sym;
public int act;
public YYARec (int s, int a){ sym = s; act = a; }
}
class YYRRec
{
public int len;
public int sym;
public YYRRec (int l, int s){ sym = s; len = l; }
}
////////////////////////////////////////////////////////////////
/// Constant values / tokens
////////////////////////////////////////////////////////////////
int t_CharKlammerAuf = 257;
int t_CharKlammerZu = 258;
int t_T_0 = 259;
int t_T_1 = 260;
int t_or = 261;
int t_and = 262;
int t_CharNot = 263;
int t_gdw = 264;
int t_ignore = 256;
///////////////////////////////////////////////////////////
/// Global settings:
///////////////////////////////////////////////////////////
/*Verstaendnis-Sachen:
$$ := Rückgabewert
$1 := 1. Argument
$2 := 2. Argument */
///////////////////////////////////////////////////////////
/// <summary>
/// Der Haupteinstiegspunkt für die Anwendung.
/// </summary>
public static void main(String[] args)
{
V1 compiler = new V1();
Scanner inp = new Scanner (System.in);
String inputstream = inp.nextLine();
////////////////////////////////////////////////////////////////
/// Compiler Code:
////////////////////////////////////////////////////////////////
if (!compiler.Scanner(inputstream)) {
System.out.println("Error while scanning");
System.exit(1);
}
compiler.InitTables();
if(!compiler.yyparse()) {
System.out.println("Error while parsing");
System.exit(1);
}
System.out.println(compiler.Output);
}
public void yyaction (int yyruleno)
{
switch (yyruleno)
{
////////////////////////////////////////////////////////////////
/// YYAction code:
////////////////////////////////////////////////////////////////
case 1 :
//expression -> term A
//Bedeutung: yyval = yyv[yysp-1] or yyv[yysp-0]
if (yyv[yysp-0].equals("1")){
yyval = "1";
}else{
yyval = yyv[yysp-1];
}
break;
case 2 :
//expression -> term
yyval = yyv[yysp-0];
break;
case 3 :
//A -> oder term
yyval = yyv[yysp-0];
break;
case 4 :
// A -> oder term A
if (yyv[yysp-0].equals("1")){
yyval = "1";
}else{
yyval = yyv[yysp-1];
}
break;
case 5 :
//term -> factor B
// Bedeutung: yyval = yyv[yysp-1] and yyv[yysp-0]
if (yyv[yysp-0].equals("0")){
yyval = "0";
}else{
yyval = yyv[yysp-1];
}
break;
case 6 :
//term -> factor
yyval = yyv[yysp-0];
break;
case 7 :
// B -> und factor
yyval = yyv[yysp-0];
break;
case 8 :
// B -> und factor B
if (yyv[yysp-0].equals("0")){
yyval = "0";
}else{
yyval = yyv[yysp-1];
}
break;
case 9 :
//factor -> ( S )
yyval = yyv[yysp-1];
break;
case 10 :
//factor -> constant
yyval = yyv[yysp-0];
break;
case 11 :
//factor -> not factor
if (yyv[yysp-0].equals("0")){
yyval = "1";
}else{
yyval = "0";
}
break;
case 12 :
yyval = yyv[yysp-0];
break;
case 13 :
yyval = yyv[yysp-0];
break;
case 14 :
yyval = yyv[yysp-0];
break;
case 15 :
yyval = yyv[yysp-0];
break;
case 16 :
//expression -> term A
if (yyv[yysp-0].equals("1")){
yyval = "0";
}else{
yyval = yyv[yysp-0];
}
break;
case 17 :
yyval = yyv[yysp-0];
break;
default : return;
}
}
public void InitTables()
{
////////////////////////////////////////////////////////////////
/// Init Table code:
////////////////////////////////////////////////////////////////
int yynacts = 36;
int yyngotos = 28;
int yynstates = 23;
int yynrules = 17;
yya = new YYARec[yynacts+1]; int yyac = 1;
yyg = new YYARec[yyngotos+1]; int yygc = 1;
yyr = new YYRRec[yynrules+1]; int yyrc = 1;
yya[yyac] = new YYARec(257,6);yyac++;
yya[yyac] = new YYARec(259,7);yyac++;
yya[yyac] = new YYARec(260,8);yyac++;
yya[yyac] = new YYARec(263,9);yyac++;
yya[yyac] = new YYARec(257,6);yyac++;
yya[yyac] = new YYARec(259,7);yyac++;
yya[yyac] = new YYARec(260,8);yyac++;
yya[yyac] = new YYARec(263,9);yyac++;
yya[yyac] = new YYARec(262,13);yyac++;
yya[yyac] = new YYARec(0,-6 );yyac++;
yya[yyac] = new YYARec(258,-6 );yyac++;
yya[yyac] = new YYARec(261,-6 );yyac++;
yya[yyac] = new YYARec(261,16);yyac++;
yya[yyac] = new YYARec(0,-2 );yyac++;
yya[yyac] = new YYARec(258,-2 );yyac++;
yya[yyac] = new YYARec(0,0);yyac++;
yya[yyac] = new YYARec(257,6);yyac++;
yya[yyac] = new YYARec(259,7);yyac++;
yya[yyac] = new YYARec(260,8);yyac++;
yya[yyac] = new YYARec(263,9);yyac++;
yya[yyac] = new YYARec(257,6);yyac++;
yya[yyac] = new YYARec(259,7);yyac++;
yya[yyac] = new YYARec(260,8);yyac++;
yya[yyac] = new YYARec(263,9);yyac++;
yya[yyac] = new YYARec(257,6);yyac++;
yya[yyac] = new YYARec(259,7);yyac++;
yya[yyac] = new YYARec(260,8);yyac++;
yya[yyac] = new YYARec(263,9);yyac++;
yya[yyac] = new YYARec(258,20);yyac++;
yya[yyac] = new YYARec(262,13);yyac++;
yya[yyac] = new YYARec(0,-7 );yyac++;
yya[yyac] = new YYARec(258,-7 );yyac++;
yya[yyac] = new YYARec(261,-7 );yyac++;
yya[yyac] = new YYARec(261,16);yyac++;
yya[yyac] = new YYARec(0,-3 );yyac++;
yya[yyac] = new YYARec(258,-3 );yyac++;
yyg[yygc] = new YYARec(-10,1);yygc++;
yyg[yygc] = new YYARec(-9,2);yygc++;
yyg[yygc] = new YYARec(-6,3);yygc++;
yyg[yygc] = new YYARec(-3,4);yygc++;
yyg[yygc] = new YYARec(-2,5);yygc++;
yyg[yygc] = new YYARec(-10,1);yygc++;
yyg[yygc] = new YYARec(-9,2);yygc++;
yyg[yygc] = new YYARec(-6,10);yygc++;
yyg[yygc] = new YYARec(-8,11);yygc++;
yyg[yygc] = new YYARec(-7,12);yygc++;
yyg[yygc] = new YYARec(-5,14);yygc++;
yyg[yygc] = new YYARec(-4,15);yygc++;
yyg[yygc] = new YYARec(-10,1);yygc++;
yyg[yygc] = new YYARec(-9,2);yygc++;
yyg[yygc] = new YYARec(-6,3);yygc++;
yyg[yygc] = new YYARec(-3,4);yygc++;
yyg[yygc] = new YYARec(-2,17);yygc++;
yyg[yygc] = new YYARec(-10,1);yygc++;
yyg[yygc] = new YYARec(-9,2);yygc++;
yyg[yygc] = new YYARec(-6,18);yygc++;
yyg[yygc] = new YYARec(-10,1);yygc++;
yyg[yygc] = new YYARec(-9,2);yygc++;
yyg[yygc] = new YYARec(-6,3);yygc++;
yyg[yygc] = new YYARec(-3,19);yygc++;
yyg[yygc] = new YYARec(-8,11);yygc++;
yyg[yygc] = new YYARec(-7,21);yygc++;
yyg[yygc] = new YYARec(-5,14);yygc++;
yyg[yygc] = new YYARec(-4,22);yygc++;
yyd = new int[yynstates];
yyd[0] = 0;
yyd[1] = 0;
yyd[2] = -10;
yyd[3] = 0;
yyd[4] = 0;
yyd[5] = 0;
yyd[6] = 0;
yyd[7] = -12;
yyd[8] = -13;
yyd[9] = -16;
yyd[10] = -11;
yyd[11] = 0;
yyd[12] = -5;
yyd[13] = -15;
yyd[14] = 0;
yyd[15] = -1;
yyd[16] = -14;
yyd[17] = 0;
yyd[18] = 0;
yyd[19] = 0;
yyd[20] = -9;
yyd[21] = -8;
yyd[22] = -4;
yyal = new int[yynstates];
yyal[0] = 1;
yyal[1] = 5;
yyal[2] = 9;
yyal[3] = 9;
yyal[4] = 13;
yyal[5] = 16;
yyal[6] = 17;
yyal[7] = 21;
yyal[8] = 21;
yyal[9] = 21;
yyal[10] = 21;
yyal[11] = 21;
yyal[12] = 25;
yyal[13] = 25;
yyal[14] = 25;
yyal[15] = 29;
yyal[16] = 29;
yyal[17] = 29;
yyal[18] = 30;
yyal[19] = 34;
yyal[20] = 37;
yyal[21] = 37;
yyal[22] = 37;
yyah = new int[yynstates];
yyah[0] = 4;
yyah[1] = 8;
yyah[2] = 8;
yyah[3] = 12;
yyah[4] = 15;
yyah[5] = 16;
yyah[6] = 20;
yyah[7] = 20;
yyah[8] = 20;
yyah[9] = 20;
yyah[10] = 20;
yyah[11] = 24;
yyah[12] = 24;
yyah[13] = 24;
yyah[14] = 28;
yyah[15] = 28;
yyah[16] = 28;
yyah[17] = 29;
yyah[18] = 33;
yyah[19] = 36;
yyah[20] = 36;
yyah[21] = 36;
yyah[22] = 36;
yygl = new int[yynstates];
yygl[0] = 1;
yygl[1] = 6;
yygl[2] = 9;
yygl[3] = 9;
yygl[4] = 11;
yygl[5] = 13;
yygl[6] = 13;
yygl[7] = 18;
yygl[8] = 18;
yygl[9] = 18;
yygl[10] = 18;
yygl[11] = 18;
yygl[12] = 21;
yygl[13] = 21;
yygl[14] = 21;
yygl[15] = 25;
yygl[16] = 25;
yygl[17] = 25;
yygl[18] = 25;
yygl[19] = 27;
yygl[20] = 29;
yygl[21] = 29;
yygl[22] = 29;
yygh = new int[yynstates];
yygh[0] = 5;
yygh[1] = 8;
yygh[2] = 8;
yygh[3] = 10;
yygh[4] = 12;
yygh[5] = 12;
yygh[6] = 17;
yygh[7] = 17;
yygh[8] = 17;
yygh[9] = 17;
yygh[10] = 17;
yygh[11] = 20;
yygh[12] = 20;
yygh[13] = 20;
yygh[14] = 24;
yygh[15] = 24;
yygh[16] = 24;
yygh[17] = 24;
yygh[18] = 26;
yygh[19] = 28;
yygh[20] = 28;
yygh[21] = 28;
yygh[22] = 28;
yyr[yyrc] = new YYRRec(2,-2);yyrc++;
yyr[yyrc] = new YYRRec(1,-2);yyrc++;
yyr[yyrc] = new YYRRec(2,-4);yyrc++;
yyr[yyrc] = new YYRRec(3,-4);yyrc++;
yyr[yyrc] = new YYRRec(2,-3);yyrc++;
yyr[yyrc] = new YYRRec(1,-3);yyrc++;
yyr[yyrc] = new YYRRec(2,-7);yyrc++;
yyr[yyrc] = new YYRRec(3,-7);yyrc++;
yyr[yyrc] = new YYRRec(3,-6);yyrc++;
yyr[yyrc] = new YYRRec(1,-6);yyrc++;
yyr[yyrc] = new YYRRec(2,-6);yyrc++;
yyr[yyrc] = new YYRRec(1,-9);yyrc++;
yyr[yyrc] = new YYRRec(1,-9);yyrc++;
yyr[yyrc] = new YYRRec(1,-5);yyrc++;
yyr[yyrc] = new YYRRec(1,-8);yyrc++;
yyr[yyrc] = new YYRRec(1,-10);yyrc++;
yyr[yyrc] = new YYRRec(1,-11);yyrc++;
}
public boolean yyact(int state, int sym)
{
int k = yyal[state];
while ( k <= yyah[state] && yya[k].sym != sym) k++;
if (k > yyah[state]) return false;
yyn = yya[k].act;
return true;
}
public boolean yygoto(int state, int sym)
{
int k = yygl[state];
while ( k <= yygh[state] && yyg[k].sym != sym) k++;
if (k > yygh[state]) return false;
yyn = yyg[k].act;
return true;
}
public void yyerror (String s)
{
System.out.println("Error" + s);
}
int yylexpos = -1;
String yylval = "";
public int yylex ()
{
yylexpos++;
if(yylexpos >= TokenList.size())
{
yylval = "";
return 0;
}
else
{
yylval = ((AToken)TokenList.get(yylexpos)).val;
return ((AToken)TokenList.get(yylexpos)).token;
}
}
public boolean yyparse ()
{
boolean jumpToNext = false;
while(true){ // Parse:
if (!jumpToNext){
yysp++;
if (yysp>yymaxdepth)
{
yyerror("yyparse stack overflow");
return false;
}
yys[yysp] = yystate;
yyv[yysp] = yyval;
}
jumpToNext = false;
if (yyd[yystate]==0 && yychar==-1)
{
yychar = yylex();
if (yychar<0) yychar = 0;
}
yyn = yyd[yystate];
if (yyn != 0) {
/// reduce:
yyflag = yyfnone;
yyaction(-yyn);
yysp -= yyr[-yyn].len;
if (yygoto(yys[yysp], yyr[-yyn].sym)) yystate = yyn;
switch (yyflag)
{
case 1 : return true;
case 2 : return false;
case 3 : {
int r = yy_errlab();
if (r == 0) return false;
if (r == 1) continue;
if (r == 2) {jumpToNext = true; continue; }
}
}
continue; // PARSE:
///////////////
}
if (! yyact(yystate, yychar)) {
if (yyerrflag==0) yyerror("syntax error");
int r = yy_errlab();
if (r == 0) return false;
if (r == 1) continue;
if (r == 2) {jumpToNext = true; continue; }
}
else if (yyn>0) {
/// shift:
yystate = yyn;
yychar = -1;
yyval = yylval;
if (yyerrflag>0) yyerrflag--;
continue; // PARSE:
///////////////
}
else if (yyn<0) {
/// reduce:
yyflag = yyfnone;
yyaction(-yyn);
yysp -= yyr[-yyn].len;
if (yygoto(yys[yysp], yyr[-yyn].sym)) yystate = yyn;
switch (yyflag)
{
case 1 : return true;
case 2 : return false;
case 3 : {
int r = yy_errlab();
if (r == 0) return false;
if (r == 1) continue;
if (r == 2) {jumpToNext = true; continue; }
}
}
continue; // PARSE:
///////////////
}
else return true;
} // WHILE Parse:
}
public int yy_errlab (){
if (yyerrflag==0) yynerrs++;
if (yyerrflag<=2)
{
yyerrflag = 3;
while (yysp>0 && !(yyact(yys[yysp], 255) && yyn > 0)) yysp--;
if (yysp==0) return 0;
yystate = yyn;
return 1; // PARSE:
}
else
{
if (yychar==0) return 0;
yychar = -1;
return 2;
}
}
////////////////////////////////////////////////////////////////
/// Scanner
////////////////////////////////////////////////////////////////
public class AToken
{
public int token;
public String val;
}
ArrayList<AToken> TokenList = new ArrayList<AToken>();
public boolean Scanner (String Input)
{
if (Input.length() == 0) return true;
TokenList = new ArrayList<AToken>();
while (1==1)
{
AToken lasttoken = FindToken(Input);
if (lasttoken.token == 0) break;
if (lasttoken.token != t_ignore) TokenList.add(lasttoken);
if (Input.length() > lasttoken.val.length())
Input = Input.substring(lasttoken.val.length()); else return true;
}
System.out.println(Input);
System.out.println();
System.out.println("No matching token found!");
return false;
}
public AToken FindToken (String Rest)
{
ArrayList<Integer> Results = new ArrayList<Integer>();
ArrayList<String> ResultsV = new ArrayList<String>();
try{
Pattern p;
Matcher m;
p = Pattern.compile("^(\\()");
m = p.matcher(Rest);
if (m.find()){
Results.add (new Integer(t_CharKlammerAuf));
ResultsV.add(m.group());}
p = Pattern.compile("^(\\))");
m = p.matcher(Rest);
if (m.find()){
Results.add (new Integer(t_CharKlammerZu));
ResultsV.add(m.group());}
p = Pattern.compile("^(0)");
m = p.matcher(Rest);
if (m.find()){
Results.add (new Integer(t_T_0));
ResultsV.add(m.group());}
p = Pattern.compile("^(1)");
m = p.matcher(Rest);
if (m.find()){
Results.add (new Integer(t_T_1));
ResultsV.add(m.group());}
p = Pattern.compile("^(or)");
m = p.matcher(Rest);
if (m.find()){
Results.add (new Integer(t_or));
ResultsV.add(m.group());}
p = Pattern.compile("^(and)");
m = p.matcher(Rest);
if (m.find()){
Results.add (new Integer(t_and));
ResultsV.add(m.group());}
p = Pattern.compile("^(!)");
m = p.matcher(Rest);
if (m.find()){
Results.add (new Integer(t_CharNot));
ResultsV.add(m.group());}
p = Pattern.compile("^(gdw)");
m = p.matcher(Rest);
if (m.find()){
Results.add (new Integer(t_gdw));
ResultsV.add(m.group());}
p = Pattern.compile("^([\\r\\n\\t\\s])");
m = p.matcher(Rest);
if (m.find()){
Results.add (new Integer(t_ignore));
ResultsV.add(m.group());}
} catch (Exception e) {}
int maxlength = 0;
int besttoken = 0;
AToken ret = new AToken();
ret.token = besttoken;
for (int i = 0; i < Results.size(); i++){
if (ResultsV.get(i).toString().length() > maxlength)
{
maxlength = ResultsV.get(i).toString().length();
besttoken = ((Integer)Results.get(i)).intValue();
ret.token = besttoken;
if (besttoken != 0)
ret.val = ResultsV.get(i).toString();
}
}
return ret;
}
}

Ich möchte eigentlich diesen Code in VB.NET übersetzen, da meine Java-Fähigkeiten stark eingerostet sind. Aber ich habe mich schon mit der Idee angefreundet, es in Java zu lassen und mir da eine passende GUI etc. zu bauen.

ErfinderDesRades · 24. August 2016, 21:53

ja, also scheints hat java da eine Pattern - Klasse, die iwas compilen kann, um reguläre Ausdrücke anzuwenden.

.net tickt da anders, da gibts die Regex - Klasse, um reguläre Ausdrücke anzuwenden.
Aber .net tickt auch mitte ArrayList anders, in .Net gibts keine ArrayList(Of T), sondern man nähme List(Of T).

Bestimmt sind da noch lauter so Ungereimtheiten im Code - scheints lässt sich das Zeugs nur sehr bedingt einfach nach .Net übersetzen...

Mikro Fahrrad · 24. August 2016, 21:57

Ich habe den Code soweit übersetzt, auch die Listen geändert. Nur das genannte Problem ist noch da - alles andere passt.

ErfinderDesRades · 25. August 2016, 07:52

Na, dass du es übersetzt hättest, ist eine starke Behauptung - solange du es ühaupt nicht testen kannst.

Aber die letzte Methode habich mal versucht, nach vb zu übertragen - ob das so Sinn ergibt, weiß ich nicht.

Auch der Java-Code sieht mir nicht sonderlich professionell aus - voll mit lauter Wiederholungen...

Spoiler anzeigen

VB.NET-Quellcode

Public Class AToken
Public token As Integer
Public val As [String]
End Class
Public Class Scanner
Private t_CharKlammerAuf As Integer = 257
Private t_CharKlammerZu As Integer = 258
Private t_T_0 As Integer = 259
Private t_T_1 As Integer = 260
Private t_or As Integer = 261
Private t_and As Integer = 262
Private t_CharNot As Integer = 263
Private t_gdw As Integer = 264
Private t_ignore As Integer = 256
Public Function FindToken(Rest As [String]) As AToken
Dim Results As New List(Of Integer)()
Dim ResultsV As New List(Of [String])()
Try
Dim p As Regex
Dim m As Match
p = New Regex("^(\()")
m = p.Match(Rest)
If m.Success Then
Results.Add(t_CharKlammerAuf)
ResultsV.Add(m.Value)
End If
p = New Regex("^(\))")
m = p.Match(Rest)
If m.Success Then
Results.Add(t_CharKlammerZu)
ResultsV.Add(m.Value)
End If
p = New Regex("^(0)")
m = p.Match(Rest)
If m.Success Then
Results.Add(t_T_0)
ResultsV.Add(m.Value)
End If
p = New Regex("^(1)")
m = p.Match(Rest)
If m.Success Then
Results.Add(t_T_1)
ResultsV.Add(m.Value)
End If
p = New Regex("^(or)")
m = p.Match(Rest)
If m.Success Then
Results.Add(t_or)
ResultsV.Add(m.Value)
End If
p = New Regex("^(and)")
m = p.Match(Rest)
If m.Success Then
Results.Add(t_and)
ResultsV.Add(m.Value)
End If
p = New Regex("^(!)")
m = p.Match(Rest)
If m.Success Then
Results.Add(t_CharNot)
ResultsV.Add(m.Value)
End If
p = New Regex("^(gdw)")
m = p.Match(Rest)
If m.Success Then
Results.Add(t_gdw)
ResultsV.Add(m.Value)
End If
p = New Regex("^([\r\n\t\s])")
m = p.Match(Rest)
If m.Success Then
Results.Add(t_ignore)
ResultsV.Add(m.Value)
End If
Catch e As Exception
End Try
Dim maxlength As Integer = 0
Dim besttoken As Integer = 0
Dim ret As New AToken()
ret.token = besttoken
For i As Integer = 0 To Results.Count - 1
If ResultsV(i).Length > maxlength Then
maxlength = ResultsV(i).Length
besttoken = Results(i)
ret.token = besttoken
If besttoken <> 0 Then
ret.val = ResultsV(i)
End If
End If
Next
Return ret
End Function
End Class

Also die Klasse habich da einfach drumrum gemacht - die gehört eiglich nicht da hin, aber es soll ja kompilieren.

Brauche Hilfe bei Übersetzung von Java in VB.NET - Regex, Pattern u. ä.

Brauche Hilfe bei Übersetzung von Java in VB.NET - Regex, Pattern u. ä.

VB.NET-Quellcode

VB.NET-Quellcode

ErfinderDesRades schrieb:

Quellcode

VB.NET-Quellcode

Benutzer online 1

Ähnliche Themen

3 Benutzer haben hier geschrieben