694 lines
33 KiB
Java
694 lines
33 KiB
Java
package tiny;
|
|
|
|
import tiny.tdf.*;
|
|
|
|
import java.io.*;
|
|
import java.util.*;
|
|
import java.util.function.Function;
|
|
|
|
public class TDF_FILE {
|
|
private static final String TINYDEFINEHEADER = "0000_TDF_HEADER_DEFINE";
|
|
|
|
private HashMap<String, TDF_DATA> data = null;
|
|
private String filepath;
|
|
private Map<Character, Function<String, TDF_DATA>> customFuncs = new HashMap<>();
|
|
|
|
public TDF_FILE(String filepath) {
|
|
this.filepath = filepath;
|
|
}
|
|
|
|
public void close() {
|
|
// No manual deletion needed in Java due to GC
|
|
}
|
|
|
|
public HashMap<String, TDF_DATA> load() throws TDF_ERR, IOException {
|
|
char cchar = ' ';
|
|
int index = 0;
|
|
BufferedReader reader = null;
|
|
try {
|
|
reader = new BufferedReader(new FileReader(filepath));
|
|
if (data != null) {
|
|
data = null; // Let GC handle
|
|
}
|
|
data = new HashMap<>();
|
|
HashMap<String, TDF_DATA> current = data;
|
|
Stack<HashMap<String, TDF_DATA>> stack = new Stack<>();
|
|
List<String> pathvec = new ArrayList<>();
|
|
boolean textblock = false;
|
|
String block = "";
|
|
String blockkey = "";
|
|
List<String> defines = new ArrayList<>();
|
|
TDF_DATA defdat = new TDF_DATA(TDF_TYPE.TDF_DEFINES, defines);
|
|
current.put(TINYDEFINEHEADER, defdat);
|
|
String line;
|
|
while ((line = reader.readLine()) != null) {
|
|
index++;
|
|
if (line.length() == 0) continue;
|
|
if (textblock) {
|
|
String blockline = line.replaceFirst("^\\s+", "");
|
|
if (blockline.equals("\\")) {
|
|
textblock = false;
|
|
TDF_DATA dat = new TDF_DATA(TDF_TYPE.TDF_BLOCK, block);
|
|
current.put(blockkey, dat);
|
|
} else {
|
|
block += line + "\n";
|
|
}
|
|
} else {
|
|
String trimmed = line.replaceFirst("^\\s+", "");
|
|
if (trimmed.isEmpty() || trimmed.charAt(0) == '#') continue;
|
|
if (trimmed.length() > 1 && trimmed.charAt(1) == ' ') {
|
|
cchar = trimmed.charAt(0);
|
|
switch (cchar) {
|
|
case '"':
|
|
int lastQuote = trimmed.indexOf(' ', 3);
|
|
if (lastQuote == -1) throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
String keyQuote = trimmed.substring(2, lastQuote);
|
|
String valueQuote = trimmed.substring(lastQuote + 1);
|
|
TDF_DATA datQuote = new TDF_DATA(TDF_TYPE.TDF_STR, valueQuote);
|
|
current.put(keyQuote, datQuote);
|
|
break;
|
|
case 'S':
|
|
int lastS = trimmed.indexOf(' ', 2);
|
|
String keyS;
|
|
if (lastS != -1) {
|
|
keyS = trimmed.substring(2, lastS);
|
|
} else {
|
|
keyS = trimmed.substring(2);
|
|
}
|
|
blockkey = keyS;
|
|
block = "";
|
|
textblock = true;
|
|
break;
|
|
case '\'':
|
|
int lastChar = trimmed.indexOf(' ', 3);
|
|
if (lastChar == -1) throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
String keyChar = trimmed.substring(2, lastChar);
|
|
if (lastChar + 1 >= trimmed.length()) throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
char valueChar = trimmed.charAt(lastChar + 1);
|
|
if (lastChar + 2 < trimmed.length()) throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
TDF_DATA datChar = new TDF_DATA(TDF_TYPE.TDF_CHAR, valueChar);
|
|
current.put(keyChar, datChar);
|
|
break;
|
|
case 'i':
|
|
int lastInt = trimmed.indexOf(' ', 3);
|
|
if (lastInt == -1) throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
String keyInt = trimmed.substring(2, lastInt);
|
|
String subInt = trimmed.substring(lastInt + 1);
|
|
Integer valueInt;
|
|
try {
|
|
valueInt = Integer.decode(subInt);
|
|
} catch (NumberFormatException e) {
|
|
throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
}
|
|
TDF_DATA datInt = new TDF_DATA(TDF_TYPE.TDF_INT, valueInt);
|
|
current.put(keyInt, datInt);
|
|
break;
|
|
case 'h':
|
|
int lastHex = trimmed.indexOf(' ', 3);
|
|
if (lastHex == -1) throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
String keyHex = trimmed.substring(2, lastHex);
|
|
String subHex = trimmed.substring(lastHex + 1);
|
|
Integer valueHex;
|
|
try {
|
|
valueHex = Integer.parseInt(subHex, 16);
|
|
} catch (NumberFormatException e) {
|
|
throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
}
|
|
TDF_DATA datHex = new TDF_DATA(TDF_TYPE.TDF_HEX, valueHex);
|
|
current.put(keyHex, datHex);
|
|
break;
|
|
case 'b':
|
|
int lastBin = trimmed.indexOf(' ', 3);
|
|
if (lastBin == -1) throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
String keyBin = trimmed.substring(2, lastBin);
|
|
String subBin = trimmed.substring(lastBin + 1);
|
|
Integer valueBin;
|
|
try {
|
|
valueBin = Integer.parseInt(subBin, 2);
|
|
} catch (NumberFormatException e) {
|
|
throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
}
|
|
TDF_DATA datBin = new TDF_DATA(TDF_TYPE.TDF_BINARY, valueBin);
|
|
current.put(keyBin, datBin);
|
|
break;
|
|
case 'B':
|
|
int lastBool = trimmed.indexOf(' ', 3);
|
|
if (lastBool == -1) throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
String keyBool = trimmed.substring(2, lastBool);
|
|
if (lastBool + 1 >= trimmed.length()) throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
char c = trimmed.charAt(lastBool + 1);
|
|
boolean valueBool = c == 'T';
|
|
if (lastBool + 2 < trimmed.length()) throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
TDF_DATA datBool = new TDF_DATA(TDF_TYPE.TDF_BOOL, valueBool);
|
|
current.put(keyBool, datBool);
|
|
break;
|
|
case 'f':
|
|
int lastFloat = trimmed.indexOf(' ', 3);
|
|
if (lastFloat == -1) throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
String keyFloat = trimmed.substring(2, lastFloat);
|
|
String subFloat = trimmed.substring(lastFloat + 1);
|
|
Float valueFloat;
|
|
try {
|
|
valueFloat = Float.parseFloat(subFloat);
|
|
} catch (NumberFormatException e) {
|
|
throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
}
|
|
TDF_DATA datFloat = new TDF_DATA(TDF_TYPE.TDF_FLOAT, valueFloat);
|
|
current.put(keyFloat, datFloat);
|
|
break;
|
|
case '@':
|
|
int lastPtr = trimmed.indexOf(' ', 3);
|
|
if (lastPtr == -1) throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
String keyPtr = trimmed.substring(2, lastPtr);
|
|
String valuePtr = trimmed.substring(lastPtr + 1);
|
|
List<String> ptr = new ArrayList<>();
|
|
int pos;
|
|
while ((pos = valuePtr.indexOf('.')) != -1) {
|
|
ptr.add(valuePtr.substring(0, pos));
|
|
valuePtr = valuePtr.substring(pos + 1);
|
|
}
|
|
ptr.add(valuePtr);
|
|
TDF_DATA datPtr = new TDF_DATA(TDF_TYPE.TDF_POINTER, ptr);
|
|
current.put(keyPtr, datPtr);
|
|
break;
|
|
case '{':
|
|
int lastClass = trimmed.indexOf(' ', 3);
|
|
String keyClass;
|
|
if (lastClass != -1) {
|
|
keyClass = trimmed.substring(2, lastClass);
|
|
} else {
|
|
keyClass = trimmed.substring(2);
|
|
}
|
|
HashMap<String, TDF_DATA> newmap = new HashMap<>();
|
|
TDF_DATA datClass = new TDF_DATA(TDF_TYPE.TDF_CLASS, newmap);
|
|
current.put(keyClass, datClass);
|
|
List<String> definesNew = new ArrayList<>();
|
|
TDF_DATA defdatNew = new TDF_DATA(TDF_TYPE.TDF_DEFINES, definesNew);
|
|
newmap.put(TINYDEFINEHEADER, defdatNew);
|
|
stack.push(current);
|
|
pathvec.add(keyClass);
|
|
current = newmap;
|
|
break;
|
|
default:
|
|
if (customFuncs.containsKey(cchar)) {
|
|
TDF_DATA datCustom = customFuncs.get(cchar).apply(trimmed);
|
|
if (datCustom.data == null) throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
int lastCustom = trimmed.indexOf(' ', 3);
|
|
if (lastCustom == -1) throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
String keyCustom = trimmed.substring(2, lastCustom);
|
|
current.put(keyCustom, datCustom);
|
|
}
|
|
break;
|
|
}
|
|
} else if (trimmed.equals("}")) {
|
|
if (stack.isEmpty()) throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
current = stack.pop();
|
|
if (!pathvec.isEmpty()) pathvec.remove(pathvec.size() - 1);
|
|
} else {
|
|
TDF_DATA it = current.get(TINYDEFINEHEADER);
|
|
if (it == null || it.type != TDF_TYPE.TDF_DEFINES) throw new TDF_ERR(TDF_ERROR.FAILED_TO_PARSE, filepath, Arrays.asList(String.valueOf(index)));
|
|
@SuppressWarnings("unchecked")
|
|
List<String> currentDefines = (List<String>) it.data;
|
|
currentDefines.add(line);
|
|
}
|
|
}
|
|
}
|
|
return data;
|
|
} catch (FileNotFoundException e) {
|
|
throw new TDF_ERR(TDF_ERROR.FILE_NOT_FOUND, filepath, new ArrayList<>());
|
|
} finally {
|
|
if (reader != null) {
|
|
try {
|
|
reader.close();
|
|
} catch (IOException e) {
|
|
// Ignore
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void warning(String msg) {
|
|
System.err.println(msg);
|
|
}
|
|
|
|
public boolean defined(List<String> path) {
|
|
HashMap<String, TDF_DATA> current = data;
|
|
for (int i = 0; i < path.size(); i++) {
|
|
TDF_DATA it = current.get(path.get(i));
|
|
if (it == null) return false;
|
|
if (i == path.size() - 1) return true;
|
|
if (it.type != TDF_TYPE.TDF_CLASS) return false;
|
|
current = (HashMap<String, TDF_DATA>) it.data;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean defined(List<String> path, boolean defaultval) {
|
|
return defined(path);
|
|
}
|
|
|
|
public boolean getbool(List<String> path) throws TDF_ERR {
|
|
HashMap<String, TDF_DATA> current = data;
|
|
for (int i = 0; i < path.size(); i++) {
|
|
TDF_DATA it = current.get(path.get(i));
|
|
if (it == null) throw new TDF_ERR(TDF_ERROR.PATH_NOT_FOUND, filepath, path);
|
|
if (i == path.size() - 1) {
|
|
if (it.type != TDF_TYPE.TDF_BOOL) throw new TDF_ERR(TDF_ERROR.GET_MISMATCH, filepath, path);
|
|
return (Boolean) it.data;
|
|
}
|
|
if (it.type != TDF_TYPE.TDF_CLASS) throw new TDF_ERR(TDF_ERROR.GET_MISMATCH, filepath, path);
|
|
current = (HashMap<String, TDF_DATA>) it.data;
|
|
}
|
|
throw new TDF_ERR(TDF_ERROR.PATH_NOT_FOUND, filepath, path);
|
|
}
|
|
|
|
public boolean getbool(List<String> path, boolean defaultval) {
|
|
try {
|
|
return getbool(path);
|
|
} catch (TDF_ERR e) {
|
|
warning(e.getMessage());
|
|
return defaultval;
|
|
}
|
|
}
|
|
|
|
public int getint(List<String> path) throws TDF_ERR {
|
|
HashMap<String, TDF_DATA> current = data;
|
|
for (int i = 0; i < path.size(); i++) {
|
|
TDF_DATA it = current.get(path.get(i));
|
|
if (it == null) throw new TDF_ERR(TDF_ERROR.PATH_NOT_FOUND, filepath, path);
|
|
if (i == path.size() - 1) {
|
|
if (it.type != TDF_TYPE.TDF_INT && it.type != TDF_TYPE.TDF_HEX && it.type != TDF_TYPE.TDF_BINARY)
|
|
throw new TDF_ERR(TDF_ERROR.GET_MISMATCH, filepath, path);
|
|
return (Integer) it.data;
|
|
}
|
|
if (it.type != TDF_TYPE.TDF_CLASS) throw new TDF_ERR(TDF_ERROR.GET_MISMATCH, filepath, path);
|
|
current = (HashMap<String, TDF_DATA>) it.data;
|
|
}
|
|
throw new TDF_ERR(TDF_ERROR.PATH_NOT_FOUND, filepath, path);
|
|
}
|
|
|
|
public int getint(List<String> path, int defaultval) {
|
|
try {
|
|
return getint(path);
|
|
} catch (TDF_ERR e) {
|
|
warning(e.getMessage());
|
|
return defaultval;
|
|
}
|
|
}
|
|
|
|
public String getstring(List<String> path) throws TDF_ERR {
|
|
HashMap<String, TDF_DATA> current = data;
|
|
for (int i = 0; i < path.size(); i++) {
|
|
TDF_DATA it = current.get(path.get(i));
|
|
if (it == null) throw new TDF_ERR(TDF_ERROR.PATH_NOT_FOUND, filepath, path);
|
|
if (i == path.size() - 1) {
|
|
if (it.type != TDF_TYPE.TDF_STR && it.type != TDF_TYPE.TDF_BLOCK)
|
|
throw new TDF_ERR(TDF_ERROR.GET_MISMATCH, filepath, path);
|
|
return (String) it.data;
|
|
}
|
|
if (it.type != TDF_TYPE.TDF_CLASS) throw new TDF_ERR(TDF_ERROR.GET_MISMATCH, filepath, path);
|
|
current = (HashMap<String, TDF_DATA>) it.data;
|
|
}
|
|
throw new TDF_ERR(TDF_ERROR.PATH_NOT_FOUND, filepath, path);
|
|
}
|
|
|
|
public String getstring(List<String> path, String defaultval) {
|
|
try {
|
|
return getstring(path);
|
|
} catch (TDF_ERR e) {
|
|
warning(e.getMessage());
|
|
return defaultval;
|
|
}
|
|
}
|
|
|
|
public List<String> getpointer(List<String> path) throws TDF_ERR {
|
|
HashMap<String, TDF_DATA> current = data;
|
|
for (int i = 0; i < path.size(); i++) {
|
|
TDF_DATA it = current.get(path.get(i));
|
|
if (it == null) throw new TDF_ERR(TDF_ERROR.PATH_NOT_FOUND, filepath, path);
|
|
if (i == path.size() - 1) {
|
|
if (it.type != TDF_TYPE.TDF_POINTER) throw new TDF_ERR(TDF_ERROR.GET_MISMATCH, filepath, path);
|
|
return (List<String>) it.data;
|
|
}
|
|
if (it.type != TDF_TYPE.TDF_CLASS) throw new TDF_ERR(TDF_ERROR.GET_MISMATCH, filepath, path);
|
|
current = (HashMap<String, TDF_DATA>) it.data;
|
|
}
|
|
throw new TDF_ERR(TDF_ERROR.PATH_NOT_FOUND, filepath, path);
|
|
}
|
|
|
|
public List<String> getpointer(List<String> path, List<String> defaultval) {
|
|
try {
|
|
return getpointer(path);
|
|
} catch (TDF_ERR e) {
|
|
warning(e.getMessage());
|
|
return defaultval;
|
|
}
|
|
}
|
|
|
|
public char getchar(List<String> path) throws TDF_ERR {
|
|
HashMap<String, TDF_DATA> current = data;
|
|
for (int i = 0; i < path.size(); i++) {
|
|
TDF_DATA it = current.get(path.get(i));
|
|
if (it == null) throw new TDF_ERR(TDF_ERROR.PATH_NOT_FOUND, filepath, path);
|
|
if (i == path.size() - 1) {
|
|
if (it.type != TDF_TYPE.TDF_CHAR) throw new TDF_ERR(TDF_ERROR.GET_MISMATCH, filepath, path);
|
|
return (Character) it.data;
|
|
}
|
|
if (it.type != TDF_TYPE.TDF_CLASS) throw new TDF_ERR(TDF_ERROR.GET_MISMATCH, filepath, path);
|
|
current = (HashMap<String, TDF_DATA>) it.data;
|
|
}
|
|
throw new TDF_ERR(TDF_ERROR.PATH_NOT_FOUND, filepath, path);
|
|
}
|
|
|
|
public char getchar(List<String> path, char defaultval) {
|
|
try {
|
|
return getchar(path);
|
|
} catch (TDF_ERR e) {
|
|
warning(e.getMessage());
|
|
return defaultval;
|
|
}
|
|
}
|
|
|
|
public float getfloat(List<String> path) throws TDF_ERR {
|
|
HashMap<String, TDF_DATA> current = data;
|
|
for (int i = 0; i < path.size(); i++) {
|
|
TDF_DATA it = current.get(path.get(i));
|
|
if (it == null) throw new TDF_ERR(TDF_ERROR.PATH_NOT_FOUND, filepath, path);
|
|
if (i == path.size() - 1) {
|
|
if (it.type != TDF_TYPE.TDF_FLOAT) throw new TDF_ERR(TDF_ERROR.GET_MISMATCH, filepath, path);
|
|
return (Float) it.data;
|
|
}
|
|
if (it.type != TDF_TYPE.TDF_CLASS) throw new TDF_ERR(TDF_ERROR.GET_MISMATCH, filepath, path);
|
|
current = (HashMap<String, TDF_DATA>) it.data;
|
|
}
|
|
throw new TDF_ERR(TDF_ERROR.PATH_NOT_FOUND, filepath, path);
|
|
}
|
|
|
|
public float getfloat(List<String> path, float defaultval) {
|
|
try {
|
|
return getfloat(path);
|
|
} catch (TDF_ERR e) {
|
|
warning(e.getMessage());
|
|
return defaultval;
|
|
}
|
|
}
|
|
|
|
public HashMap<String, TDF_DATA> getclass(List<String> path) throws TDF_ERR {
|
|
HashMap<String, TDF_DATA> current = data;
|
|
for (int i = 0; i < path.size(); i++) {
|
|
TDF_DATA it = current.get(path.get(i));
|
|
if (it == null) throw new TDF_ERR(TDF_ERROR.PATH_NOT_FOUND, filepath, path);
|
|
if (i == path.size() - 1) {
|
|
if (it.type != TDF_TYPE.TDF_CLASS) throw new TDF_ERR(TDF_ERROR.GET_MISMATCH, filepath, path);
|
|
return (HashMap<String, TDF_DATA>) it.data;
|
|
}
|
|
if (it.type != TDF_TYPE.TDF_CLASS) throw new TDF_ERR(TDF_ERROR.GET_MISMATCH, filepath, path);
|
|
current = (HashMap<String, TDF_DATA>) it.data;
|
|
}
|
|
throw new TDF_ERR(TDF_ERROR.PATH_NOT_FOUND, filepath, path);
|
|
}
|
|
|
|
public HashMap<String, TDF_DATA> getclass(List<String> path, HashMap<String, TDF_DATA> defaultval) {
|
|
try {
|
|
return getclass(path);
|
|
} catch (TDF_ERR e) {
|
|
warning(e.getMessage());
|
|
return defaultval;
|
|
}
|
|
}
|
|
|
|
public void setbool(List<String> path, boolean value) throws TDF_ERR {
|
|
HashMap<String, TDF_DATA> current = data;
|
|
for (int i = 0; i < path.size(); i++) {
|
|
TDF_DATA it = current.get(path.get(i));
|
|
if (it == null) {
|
|
if (i == path.size() - 1) {
|
|
TDF_DATA dat = new TDF_DATA(TDF_TYPE.TDF_BOOL, value);
|
|
current.put(path.get(i), dat);
|
|
return;
|
|
} else {
|
|
HashMap<String, TDF_DATA> newmap = new HashMap<>();
|
|
TDF_DATA dat = new TDF_DATA(TDF_TYPE.TDF_CLASS, newmap);
|
|
current.put(path.get(i), dat);
|
|
current = newmap;
|
|
}
|
|
} else {
|
|
if (i == path.size() - 1) {
|
|
if (it.type != TDF_TYPE.TDF_BOOL) throw new TDF_ERR(TDF_ERROR.SET_MISMATCH, filepath, path);
|
|
it.data = value;
|
|
return;
|
|
}
|
|
if (it.type != TDF_TYPE.TDF_CLASS) throw new TDF_ERR(TDF_ERROR.SET_MISMATCH, filepath, path);
|
|
current = (HashMap<String, TDF_DATA>) it.data;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setint(List<String> path, int value) throws TDF_ERR {
|
|
HashMap<String, TDF_DATA> current = data;
|
|
for (int i = 0; i < path.size(); i++) {
|
|
TDF_DATA it = current.get(path.get(i));
|
|
if (it == null) {
|
|
if (i == path.size() - 1) {
|
|
TDF_DATA dat = new TDF_DATA(TDF_TYPE.TDF_INT, value);
|
|
current.put(path.get(i), dat);
|
|
return;
|
|
} else {
|
|
HashMap<String, TDF_DATA> newmap = new HashMap<>();
|
|
TDF_DATA dat = new TDF_DATA(TDF_TYPE.TDF_CLASS, newmap);
|
|
current.put(path.get(i), dat);
|
|
current = newmap;
|
|
}
|
|
} else {
|
|
if (i == path.size() - 1) {
|
|
if (it.type != TDF_TYPE.TDF_INT) throw new TDF_ERR(TDF_ERROR.SET_MISMATCH, filepath, path);
|
|
it.data = value;
|
|
return;
|
|
}
|
|
if (it.type != TDF_TYPE.TDF_CLASS) throw new TDF_ERR(TDF_ERROR.SET_MISMATCH, filepath, path);
|
|
current = (HashMap<String, TDF_DATA>) it.data;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setstring(List<String> path, String value) throws TDF_ERR {
|
|
HashMap<String, TDF_DATA> current = data;
|
|
for (int i = 0; i < path.size(); i++) {
|
|
TDF_DATA it = current.get(path.get(i));
|
|
if (it == null) {
|
|
if (i == path.size() - 1) {
|
|
TDF_DATA dat = new TDF_DATA(TDF_TYPE.TDF_STR, value);
|
|
current.put(path.get(i), dat);
|
|
return;
|
|
} else {
|
|
HashMap<String, TDF_DATA> newmap = new HashMap<>();
|
|
TDF_DATA dat = new TDF_DATA(TDF_TYPE.TDF_CLASS, newmap);
|
|
current.put(path.get(i), dat);
|
|
current = newmap;
|
|
}
|
|
} else {
|
|
if (i == path.size() - 1) {
|
|
if (it.type != TDF_TYPE.TDF_STR) throw new TDF_ERR(TDF_ERROR.SET_MISMATCH, filepath, path);
|
|
it.data = value;
|
|
return;
|
|
}
|
|
if (it.type != TDF_TYPE.TDF_CLASS) throw new TDF_ERR(TDF_ERROR.SET_MISMATCH, filepath, path);
|
|
current = (HashMap<String, TDF_DATA>) it.data;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setblock(List<String> path, String value) throws TDF_ERR {
|
|
HashMap<String, TDF_DATA> current = data;
|
|
for (int i = 0; i < path.size(); i++) {
|
|
TDF_DATA it = current.get(path.get(i));
|
|
if (it == null) {
|
|
if (i == path.size() - 1) {
|
|
TDF_DATA dat = new TDF_DATA(TDF_TYPE.TDF_BLOCK, value);
|
|
current.put(path.get(i), dat);
|
|
return;
|
|
} else {
|
|
HashMap<String, TDF_DATA> newmap = new HashMap<>();
|
|
TDF_DATA dat = new TDF_DATA(TDF_TYPE.TDF_CLASS, newmap);
|
|
current.put(path.get(i), dat);
|
|
current = newmap;
|
|
}
|
|
} else {
|
|
if (i == path.size() - 1) {
|
|
if (it.type != TDF_TYPE.TDF_BLOCK) throw new TDF_ERR(TDF_ERROR.SET_MISMATCH, filepath, path);
|
|
it.data = value;
|
|
return;
|
|
}
|
|
if (it.type != TDF_TYPE.TDF_CLASS) throw new TDF_ERR(TDF_ERROR.SET_MISMATCH, filepath, path);
|
|
current = (HashMap<String, TDF_DATA>) it.data;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setfloat(List<String> path, float value) throws TDF_ERR {
|
|
HashMap<String, TDF_DATA> current = data;
|
|
for (int i = 0; i < path.size(); i++) {
|
|
TDF_DATA it = current.get(path.get(i));
|
|
if (it == null) {
|
|
if (i == path.size() - 1) {
|
|
TDF_DATA dat = new TDF_DATA(TDF_TYPE.TDF_FLOAT, value);
|
|
current.put(path.get(i), dat);
|
|
return;
|
|
} else {
|
|
HashMap<String, TDF_DATA> newmap = new HashMap<>();
|
|
TDF_DATA dat = new TDF_DATA(TDF_TYPE.TDF_CLASS, newmap);
|
|
current.put(path.get(i), dat);
|
|
current = newmap;
|
|
}
|
|
} else {
|
|
if (i == path.size() - 1) {
|
|
if (it.type != TDF_TYPE.TDF_FLOAT) throw new TDF_ERR(TDF_ERROR.SET_MISMATCH, filepath, path);
|
|
it.data = value;
|
|
return;
|
|
}
|
|
if (it.type != TDF_TYPE.TDF_CLASS) throw new TDF_ERR(TDF_ERROR.SET_MISMATCH, filepath, path);
|
|
current = (HashMap<String, TDF_DATA>) it.data;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setchar(List<String> path, char value) throws TDF_ERR {
|
|
HashMap<String, TDF_DATA> current = data;
|
|
for (int i = 0; i < path.size(); i++) {
|
|
TDF_DATA it = current.get(path.get(i));
|
|
if (it == null) {
|
|
if (i == path.size() - 1) {
|
|
TDF_DATA dat = new TDF_DATA(TDF_TYPE.TDF_CHAR, value);
|
|
current.put(path.get(i), dat);
|
|
return;
|
|
} else {
|
|
HashMap<String, TDF_DATA> newmap = new HashMap<>();
|
|
TDF_DATA dat = new TDF_DATA(TDF_TYPE.TDF_CLASS, newmap);
|
|
current.put(path.get(i), dat);
|
|
current = newmap;
|
|
}
|
|
} else {
|
|
if (i == path.size() - 1) {
|
|
if (it.type != TDF_TYPE.TDF_CHAR) throw new TDF_ERR(TDF_ERROR.SET_MISMATCH, filepath, path);
|
|
it.data = value;
|
|
return;
|
|
}
|
|
if (it.type != TDF_TYPE.TDF_CLASS) throw new TDF_ERR(TDF_ERROR.SET_MISMATCH, filepath, path);
|
|
current = (HashMap<String, TDF_DATA>) it.data;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setpointer(List<String> path, List<String> value) throws TDF_ERR {
|
|
HashMap<String, TDF_DATA> current = data;
|
|
for (int i = 0; i < path.size(); i++) {
|
|
TDF_DATA it = current.get(path.get(i));
|
|
if (it == null) {
|
|
if (i == path.size() - 1) {
|
|
TDF_DATA dat = new TDF_DATA(TDF_TYPE.TDF_POINTER, new ArrayList<>(value));
|
|
current.put(path.get(i), dat);
|
|
return;
|
|
} else {
|
|
HashMap<String, TDF_DATA> newmap = new HashMap<>();
|
|
TDF_DATA dat = new TDF_DATA(TDF_TYPE.TDF_CLASS, newmap);
|
|
current.put(path.get(i), dat);
|
|
current = newmap;
|
|
}
|
|
} else {
|
|
if (i == path.size() - 1) {
|
|
if (it.type != TDF_TYPE.TDF_POINTER) throw new TDF_ERR(TDF_ERROR.SET_MISMATCH, filepath, path);
|
|
it.data = new ArrayList<>(value);
|
|
return;
|
|
}
|
|
if (it.type != TDF_TYPE.TDF_CLASS) throw new TDF_ERR(TDF_ERROR.SET_MISMATCH, filepath, path);
|
|
current = (HashMap<String, TDF_DATA>) it.data;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void define(List<String> defines, String name) {
|
|
TDF_DATA it = data.get(TINYDEFINEHEADER);
|
|
if (it == null || it.type != TDF_TYPE.TDF_DEFINES) {
|
|
List<String> newdefines = new ArrayList<>();
|
|
TDF_DATA defdat = new TDF_DATA(TDF_TYPE.TDF_DEFINES, newdefines);
|
|
data.put(TINYDEFINEHEADER, defdat);
|
|
it = data.get(TINYDEFINEHEADER);
|
|
}
|
|
@SuppressWarnings("unchecked")
|
|
List<String> currentdefines = (List<String>) it.data;
|
|
for (String def : defines) {
|
|
currentdefines.add(def);
|
|
}
|
|
currentdefines.add("#define " + name);
|
|
}
|
|
|
|
public void save() throws IOException {
|
|
try (FileWriter file = new FileWriter(filepath, false)) {
|
|
StringBuilder dataStr = new StringBuilder();
|
|
crawl(data, dataStr, "");
|
|
file.write(dataStr.toString());
|
|
}
|
|
}
|
|
|
|
private void crawl(HashMap<String, TDF_DATA> map, StringBuilder str, String indent) {
|
|
TDF_DATA it = map.get(TINYDEFINEHEADER);
|
|
if (it != null && it.type == TDF_TYPE.TDF_DEFINES) {
|
|
@SuppressWarnings("unchecked")
|
|
List<String> defines = (List<String>) it.data;
|
|
for (String def : defines) {
|
|
str.append(def).append("\n");
|
|
}
|
|
}
|
|
for (Map.Entry<String, TDF_DATA> entry : map.entrySet()) {
|
|
String key = entry.getKey();
|
|
TDF_DATA val = entry.getValue();
|
|
if (key.equals(TINYDEFINEHEADER)) continue;
|
|
switch (val.type) {
|
|
case TDF_STR:
|
|
str.append("\" ").append(key).append(" ").append((String) val.data).append("\n");
|
|
break;
|
|
case TDF_CHAR:
|
|
str.append("' ").append(key).append(" ").append((Character) val.data).append("\n");
|
|
break;
|
|
case TDF_BLOCK:
|
|
str.append("S ").append(key).append("\n").append((String) val.data).append("\n\\\n");
|
|
break;
|
|
case TDF_BOOL:
|
|
str.append("B ").append(key).append(" ").append(((Boolean) val.data) ? "T" : "F").append("\n");
|
|
break;
|
|
case TDF_BINARY:
|
|
str.append("b ").append(key).append(" ").append(Integer.toBinaryString((Integer) val.data)).append("\n");
|
|
break;
|
|
case TDF_INT:
|
|
str.append("i ").append(key).append(" ").append((Integer) val.data).append("\n");
|
|
break;
|
|
case TDF_FLOAT:
|
|
str.append("f ").append(key).append(" ").append((Float) val.data).append("\n");
|
|
break;
|
|
case TDF_HEX:
|
|
str.append("h ").append(key).append(" ").append(Integer.toHexString((Integer) val.data)).append("\n");
|
|
break;
|
|
case TDF_POINTER:
|
|
@SuppressWarnings("unchecked")
|
|
List<String> ptr = (List<String>) val.data;
|
|
str.append("@ ").append(key).append(" ");
|
|
for (int i = 0; i < ptr.size(); i++) {
|
|
str.append(ptr.get(i));
|
|
if (i < ptr.size() - 1) str.append(".");
|
|
}
|
|
str.append("\n");
|
|
break;
|
|
case TDF_CLASS:
|
|
str.append("{ ").append(key).append("\n");
|
|
crawl((HashMap<String, TDF_DATA>) val.data, str, "");
|
|
str.append("}\n");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Method to add custom functions if needed
|
|
public void addCustomFunc(char key, Function<String, TDF_DATA> func) {
|
|
customFuncs.put(key, func);
|
|
}
|
|
}
|