解析文件，传入一个字符串或者一个文件，得到json对象，或者json格式字符串

这是一个适配器类，用来管理各个文件的解析文件，并对传入的参数进行分析，并调用相应的解析文件，得到相应的字符串和json对象

package com.techmation.tmstduio.iecAdapter;

import java.io.File;

import java.io.IOException;

import java.util.HashMap;

import java.util.Map;

import com.techmation.tmstduio.iec2json.TMiec_dut_alias2json;

import com.techmation.tmstduio.iec2json.TMiec_dut_array2json;

import com.techmation.tmstduio.iec2json.TMiec_dut_enumerated2json;

import com.techmation.tmstduio.iec2json.TMiec_dut_reffunction2json;

import com.techmation.tmstduio.iec2json.TMiec_dut_structure2json;

import com.techmation.tmstduio.iec2json.TMiec_dut_subrange2json;

import com.techmation.tmstduio.iec2json.TMiec_dut_union2json;

import com.techmation.tmstduio.iec2json.TMiec_globalvariable2json;

import com.techmation.tmstduio.iec2json.TMiec_pou_st_function2json;

import com.techmation.tmstduio.iecInterface.ItmIEC2Json;

import net.sf.json.JSONObject;

public class TMiec2jsonAdapter {
public static final int iec_dut_alias=1;
public static final int iec_dut_arry=2;
public static final int iec_dut_enumerated=3;
public static final int iec_dut_reffunction=4;
public static final int iec_dut_structure=5;
public static final int iec_dut_subrange=6;
public static final int iec_dut_union=7;
public static final int iec_globalvariable=8;
public static final int iec_pou_st_function=9;
public static final int iec_pou_st_functionblock=10;
public static final int iec_pou_st_program=11;

private Map<Integer,ItmIEC2Json> g_map;

private static TMiec2jsonAdapter g_Default = null;

public TMiec2jsonAdapter() {
g_map = new HashMap<>();
}

public void registerIEC2Json(int type,ItmIEC2Json iec2json) {
g_map.put(type, iec2json);
}

public ItmIEC2Json findIEC2Json(int type) {
ItmIEC2Json result = g_map.get(type);
return result;
}

//传入一个文件 返回值为字符串
public static String selectType(int type,File file) throws IOException {
ItmIEC2Json p = getDefault().findIEC2Json(type);
return p.IEC2JsonText(file);

}
//传入一个文件 返回值为json对象
public static JSONObject selectType1(int type,File file) throws IOException {
ItmIEC2Json p = getDefault().findIEC2Json(type);
return p.IEC2JsonObj(file);

}
public static String selectType(int type,String text) throws IOException {
ItmIEC2Json p = getDefault().findIEC2Json(type);
return p.IEC2JsonText(text);

}
public static JSONObject selectType1(int type,String text) throws IOException {
ItmIEC2Json p = getDefault().findIEC2Json(type);
return p.IEC2JsonObj(text);

}

public static TMiec2jsonAdapter getDefault() {
if(g_Default == null) {
g_Default = new TMiec2jsonAdapter();

TMiec_dut_alias2json dut_alias = new TMiec_dut_alias2json();
g_Default.registerIEC2Json(iec_dut_alias, dut_alias);

TMiec_dut_array2json dut_array=new TMiec_dut_array2json();
g_Default.registerIEC2Json(iec_dut_arry, dut_array);
TMiec_dut_enumerated2json dut_enumerated=new TMiec_dut_enumerated2json();
g_Default.registerIEC2Json(iec_dut_enumerated, dut_enumerated);
TMiec_dut_reffunction2json dut_reffunction=new TMiec_dut_reffunction2json();
g_Default.registerIEC2Json(iec_dut_reffunction, dut_reffunction);
TMiec_dut_structure2json dut_structure=new TMiec_dut_structure2json();
g_Default.registerIEC2Json(iec_dut_structure, dut_structure);
TMiec_dut_subrange2json dut_subrange=new TMiec_dut_subrange2json();
g_Default.registerIEC2Json(iec_dut_subrange, dut_subrange);
TMiec_dut_union2json dut_union=new TMiec_dut_union2json();
g_Default.registerIEC2Json(iec_dut_union, dut_union);
TMiec_globalvariable2json  globalvariable=new TMiec_globalvariable2json();
g_Default.registerIEC2Json(iec_globalvariable, globalvariable);
TMiec_pou_st_function2json pou_st_function=new TMiec_pou_st_function2json();
g_Default.registerIEC2Json(iec_pou_st_function, pou_st_function);
}
return g_Default;
}

}

需要定义一个接口，接口里面有相应的方法解析传入的文件或字符串

package com.techmation.tmstduio.iecInterface;

import java.io.File;

import net.sf.json.JSONObject;

public interface ItmIEC2Json {

String IEC2JsonText(File file);
String IEC2JsonText(String text);
JSONObject IEC2JsonObj(File file);
JSONObject IEC2JsonObj(String text);

}

这是一个pojo对象，方便在json数组中存储对象

package com.techmation.tmstduio.iecPojo;

public class Parameter {
private String  keyword;
private String  name;
private String retain;
private String  type;
private boolean pointer;
private String  value;
private String anno;
public Parameter() {
super();
}
public Parameter(String keyword, String name, String retain, String type, boolean pointer, String value,
String anno) {
super();
this.keyword = keyword;
this.name = name;
this.retain = retain;
this.type = type;
this.pointer = pointer;
this.value = value;
this.anno = anno;
}
public String getKeyword() {
return keyword;
}
public void setKeyword(String keyword) {
this.keyword = keyword;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getRetain() {
return retain;
}
public void setRetain(String retain) {
this.retain = retain;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public boolean isPointer() {
return pointer;
}
public void setPointer(boolean pointer) {
this.pointer = pointer;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public String getAnno() {
return anno;
}
public void setAnno(String anno) {
this.anno = anno;
}
@Override
public String toString() {
return "keyword:" + keyword +", retain:" + retain  + ", name:" + name + ", type:" + type
+ ", pointer:" + pointer + ", value:" + value + ", anno:" + anno + "]";
}

}

具体实现接口，定义具体的实现类，下面提供一个实现类

package com.techmation.tmstduio.iec2json;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.util.regex.Pattern;

import com.techmation.tmstduio.iecInterface.ItmIEC2Json;

import com.techmation.tmstduio.iecPojo.Parameter;

import net.sf.json.JSONArray;

import net.sf.json.JSONObject;

public class TMiec_pou_st_function2json implements ItmIEC2Json{
@Override
public String IEC2JsonText(File file) {
return IEC2JsonObj(file).toString();
}

@Override
public String IEC2JsonText(String text) {
return IEC2JsonObj(text).toString();
}

public String inputStream2String(InputStream is) {
BufferedReader in = new BufferedReader(new InputStreamReader(is));
StringBuffer buffer = new StringBuffer();
String line = "";
try {
while ((line = in.readLine()) != null) {
buffer.append(line+"\n");
}
} catch (IOException e) {

e.printStackTrace();
}
return buffer.toString();
}

@Override
public JSONObject IEC2JsonObj(File file) {
String text = "";
try {
text = inputStream2String(new FileInputStream(file));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return IEC2JsonObj(text);
}

@Override
public JSONObject IEC2JsonObj(String text) {
JSONObject jsonObject =new JSONObject();
JSONArray jsonArray=new JSONArray();
JSONArray js = new JSONArray();
Parameter p = new Parameter();

String regex = "\\s";
String regexFunction = "[A-Z]+\\s[A-Za-z0-9_]+\\s:\\s[A-Za-z0-9_]+\\s[A-Z]+(\\s|)";
String regexFunction1="[A-Z_]+\\s[A-Za-z_]+";

String regexVar = "(VAR.[A-Z_]+|VAR)\\s[A-Z_]+";
String regexVar1 = "VAR.[A-Z_]+";
String regexArgument1 = ".*\\s:\\s[A-Za-z_]+(\\s|)";

String regexPointer = "[A-Z]+\\s:\\s[A-Z_]+\\s[A-Z]+\\s:=\\s[0-9]+\\s;";

String misTake = ".*[\u4e00-\u9fa5]+.*";
Pattern compile = Pattern.compile(misTake);
Pattern pattern = Pattern.compile(regex);
String lineStri = null;
String annotation = new String();

String s = new String();

int x=0;
String[] lines = text.split("\n");
for(String line : lines) {

String lineStr = line.replaceAll(" {2,}", " ");
lineStr = lineStr.trim();
if(x==1) {
s=s+line;
}
String[] lineWords =null;
if(lineStr.matches(".*\\//.*")) {

annotation=annotation+lineStr.substring(lineStr.indexOf("//")+2,lineStr.length());

lineStr=lineStr.substring(0, lineStr.indexOf("/"));

if(lineStr.matches(".*;.*")) {
lineStr = lineStr.substring(0,lineStr.indexOf(";"));
lineWords = pattern.split(lineStr);
}
else {
lineWords = pattern.split(lineStr);
}

}else if(lineStr.matches(".*;.*")){

lineStr = lineStr.substring(0,lineStr.indexOf(";"));

lineWords = pattern.split(lineStr);
}else {
lineWords = pattern.split(lineStr);
}

for (int i = 0; i < lineWords.length; i++) {
if (lineStr.matches(regexFunction)) {

jsonObject.put("type", lineWords[0]);
jsonObject.put("name", lineWords[1]);
jsonObject.put("returnValue", lineWords[3]);
break;

}  else if(lineStr.matches(regexFunction1)) {

jsonObject.put("type", lineWords[0]);
jsonObject.put("name", lineWords[1]);
break;
}
else if (lineStr.matches(regexVar)) {

p.setKeyword(lineWords[i]);
p.setRetain(lineWords[i + 1]);
break;
} else if (lineStr.matches(regexVar1)) {

p.setKeyword(lineWords[i]);
p.setRetain(null);
break;
}
else if (lineStr.matches("VAR")) {

p.setKeyword(lineWords[i]);
p.setRetain(null);
break;
}

else if (lineWords[i].matches("END_VAR")) {

jsonArray.add(js);
p = new Parameter();
js = new JSONArray();
break;
} else if (lineStr.matches(regexPointer)) {

p.setName(lineWords[0]);
p.setPointer(true);
p.setType(lineWords[2]);
p.setValue(lineWords[5]);
p.setAnno(annotation);
annotation = new String();

js.add(p);
break;

} else if (lineStr.matches(regexArgument1)) {

p.setName(lineWords[0]);
p.setType(lineWords[2]);
p.setAnno(annotation);
annotation = new String();

js.add(p);
break;

ce8a

} 
else if (compile.matcher(lineStr).find()) {
System.out.println("无法解析");
System.exit(0);

} else if(line.matches(".*IF.*")){

s = s + line;
x=1;
break;
}

}

}

jsonObject.put(" variable", jsonArray);

jsonObject.put("代码", s);

return jsonObject;
}

}

需要解析的文件

FUNCTION MI_MovePressurePosition : REF_TO WORD

  VAR

    i : WORD;

    wItemUseBit,wItemNum : WORD;

    m_xLastExecute : BOOL;

    m_fbMC_MovePressurePosition_HYB_EX : MC_MovePressurePosition_HYB_EX;

  END_VAR

  VAR_INPUT

    xExecute : BOOL;

    byDirection : BYTE;  //0: Unknow; 1: Positive; 2: Negative;

    xOpenLoop : BOOL;  //True: openloop; False: closeloop.

  END_VAR

  VAR_OUTPUT

    xDone : BOOL;

    xBusy : BOOL;

    xActive : BOOL;

    xCommandAborted : BOOL;

    xError : BOOL;

    dwErrorID : DWORD;

  END_VAR

  VAR_IN_OUT

    Axis_mi_ref : AXIS_MI;

  END_VAR
// Check machine state 
IF Axis_mi_ref.output_mi^.byCurrMotionID <> MOTIONID_MOVEPRESSUREPOSITION_HYB THEN
IF NOT xExecute THEN
Axis_mi_ref.output_mi^.byCurrMotionID := MOTIONID_MOVEPRESSUREPOSITION_HYB;
ELSE
xError
:= TRUE;
dwErrorID
:= ERROR_MACHINESTATE;
Axis_mi_ref.output_mi^.dwErrorID := ERROR_MACHINESTATE;
RETURN;
END_IF
END_IF

IF NOT xExecute THEN
    xDone := FALSE;
    xBusy := FALSE;
    xActive := FALSE;
    xError := FALSE;
    dwErrorID := 0;
    m_xLastExecute := FALSE;
    RETURN;
END_IF
    
IF NOT m_xLastExecute THEN
    m_xLastExecute := TRUE;
    
    Axis_mi_ref.m_AXIS_HYB_EX.AxisID := Axis_mi_ref.wAxisNo;
    Axis_mi_ref.m_AXIS_HYB_EX.CtrlCycleTime := Axis_mi_ref.input_mi^.pConfig_mi^.rSystemCycletime;
    Axis_mi_ref.m_AXIS_HYB_EX.MaxPressure := Axis_mi_ref.input_mi^.pConfig_mi^.rMaxPressure;
    Axis_mi_ref.m_AXIS_HYB_EX.ReverseSpeedLimit := Axis_mi_ref.input_mi^.pLimit_mi^.rMaxReverseVeloLimit;
    Axis_mi_ref.m_AXIS_HYB_EX.DepressMinPressure := Axis_mi_ref.input_mi^.pLimit_mi^.rDepressMinPressure;
    
    Axis_mi_ref.m_AXIS_HYB_EX.PIDOutVelocity := Axis_mi_ref.output_mi^.rOutVelocity;
wItemNum := 0;
wItemUseBit := Axis_mi_ref.input_mi^.pSetpoint^.wItemUseBit;
FOR i:=1 TO 6 DO
IF WORD_TO_BOOL(wItemUseBit AND SHL(1,i-1)) THEN
m_fbMC_MovePressurePosition_HYB_EX.Setpoint.Items[wItemNum].Pressure     := Axis_mi_ref.input_mi^.pSetpoint^.aryItems[i].rPressure;   
m_fbMC_MovePressurePosition_HYB_EX.Setpoint.Items[wItemNum].Velocity     := Axis_mi_ref.input_mi^.pSetpoint^.aryItems[i].rVelocity;   
m_fbMC_MovePressurePosition_HYB_EX.Setpoint.Items[wItemNum].Position     := Axis_mi_ref.input_mi^.pSetpoint^.aryItems[i].rPosition;

m_fbMC_MovePressurePosition_HYB_EX.Setpoint.Items[wItemNum].PressRampUp     := Axis_mi_ref.input_mi^.pSetpoint^.aryItems[i].rPressUpRamp;   
m_fbMC_MovePressurePosition_HYB_EX.Setpoint.Items[wItemNum].PressRampDown   := Axis_mi_ref.input_mi^.pSetpoint^.aryItems[i].rPressDnRamp;   
m_fbMC_MovePressurePosition_HYB_EX.Setpoint.Items[wItemNum].SpeedRampUp     := Axis_mi_ref.input_mi^.pSetpoint^.aryItems[i].rSpeedUpRamp;   
m_fbMC_MovePressurePosition_HYB_EX.Setpoint.Items[wItemNum].SpeedRampDown   := Axis_mi_ref.input_mi^.pSetpoint^.aryItems[i].rSpeedDnRamp; 

wItemNum := wItemNum +1;
END_IF
END_FOR
m_fbMC_MovePressurePosition_HYB_EX.Setpoint.ItemNum := wItemNum;

    m_fbMC_MovePressurePosition_HYB_EX(
Axis := Axis_mi_ref.m_AXIS_HYB_EX, 
Execute := FALSE,
BlendingPrevious := BYTE_TO_BOOL(Axis_mi_ref.input_mi^.pParam^.byBufferMode),

Direction
:= byDirection,
Openloop        := xOpenLoop,
PIDOption       := Axis_mi_ref.input_mi^.pPressPID^.byPIDOption,
Kp              := Axis_mi_ref.input_mi^.pPressPID^.rKP,
Ki              := Axis_mi_ref.input_mi^.pPressPID^.rKI,
Kd              := 0,
LowPressKp      := Axis_mi_ref.input_mi^.pPressPID^.rLowPressKP, 
LowPress        := Axis_mi_ref.input_mi^.pPressPID^.rLowPress,   
HiPressKp       := Axis_mi_ref.input_mi^.pPressPID^.rHighPressKP,  
HiPress         := Axis_mi_ref.input_mi^.pPressPID^.rHighPress,
  
PressFeedFwd    := Axis_mi_ref.input_mi^.pPressPID^.rPresFeedForward,
VelocityFeedFwd := Axis_mi_ref.input_mi^.pPressPID^.rVeloFeedForward, 
);
END_IF

Axis_mi_ref.m_AXIS_HYB_EX.ActualPressure := Axis_mi_ref.input_mi^.pActual_mi^.rActualPressure;
Axis_mi_ref.m_AXIS_HYB_EX.ActualPosition := Axis_mi_ref.input_mi^.pActual_mi^.rActualPosition;

m_fbMC_MovePressurePosition_HYB_EX(

Axis := Axis_mi_ref.m_AXIS_HYB_EX,
Execute := TRUE, 
);
xDone := m_fbMC_MovePressurePosition_HYB_EX.Done;
xBusy := m_fbMC_MovePressurePosition_HYB_EX.Busy;
xActive := m_fbMC_MovePressurePosition_HYB_EX.Active;
xError := m_fbMC_MovePressurePosition_HYB_EX.Error;
dwErrorID := m_fbMC_MovePressurePosition_HYB_EX.ErrorID;

Axis_mi_ref.output_mi^.rProfileSpeed  := Axis_mi_ref.m_AXIS_HYB_EX.ProfileVelocity; 
Axis_mi_ref.output_mi^.rProfilePressure := Axis_mi_ref.m_AXIS_HYB_EX.ProfilePressure; 
Axis_mi_ref.output_mi^.rProfileTorque := 0;
Axis_mi_ref.output_mi^.rOutVelocity := Axis_mi_ref.m_AXIS_HYB_EX.PIDOutVelocity; 
// When open loop and close loop with single valve pressure.
Axis_mi_ref.output_mi^.rOutPressure := Axis_mi_ref.m_AXIS_HYB_EX.ProfilePressure;
Axis_mi_ref.output_mi^.rOutTorque := 100;
Axis_mi_ref.output_mi^.rOutPosition := 0;
Axis_mi_ref.output_mi^.rOutServoValveSpeed := Axis_mi_ref.m_AXIS_HYB_EX.ProfileVelocity;
Axis_mi_ref.output_mi^.byMotionStep := WORD_TO_BYTE(Axis_mi_ref.m_AXIS_HYB_EX.HMISetpoint);

IF xError THEN
Axis_mi_ref.output_mi^.byMotionState := MOTIONSTATUS_ERROR;
ELSIF xDone THEN
Axis_mi_ref.output_mi^.byMotionState := MOTIONSTATUS_DONE;
ELSIF xActive THEN
Axis_mi_ref.output_mi^.byMotionState := MOTIONSTATUS_ACTIVE;
ELSE 
Axis_mi_ref.output_mi^.byMotionState := MOTIONSTATUS_IDLE;
END_IF

END_FUNCTION

测试

@Test
public void test10() throws IOException {
String s = TMiec2jsonAdapter.selectType(9, new File("传入你要解析文件路径"));//或者直接传入字符串

System.out.println(s);
}