internal static ParseException forInvalidEnd(ParseStringRunner parseStrignRunner)
{
StringPointer sp = parseStrignRunner.getStringPointer();
string fullMessage = "Unexpected end of input - " + sp.getLineAndColumnForException() + ", near: " + sp.getSubStringForException(16) + getExceptionMessageTail(parseStrignRunner);
return(new ParseException(fullMessage));
}
internal static ParseException forCharactersAfterEnd(ParseStringRunner parseStrignRunner)
{
StringPointer sp = parseStrignRunner.getStringPointer();
string fullMessage = "Unexpected non-white character after end of object - " + sp.getLineAndColumnForException() + ", near: " + sp.getSubStringForException(32) + getExceptionMessageTail(parseStrignRunner);
return(new ParseException(fullMessage));
}
internal static ParseException forInvalidCharacter(String message, ParseStringRunner parseStrignRunner)
{
StringPointer sp = parseStrignRunner.getStringPointer();
string fullMessage = message + " - " + sp.getLineAndColumnForException() + ", near: " + sp.getSubStringForException(32) + getExceptionMessageTail(parseStrignRunner);
return(new ParseException(fullMessage));
}
public override IEnumerable <RegexMatch> SimpleMatchings(StringPointer str, MatingContext context)
{
if (str.Value().Length > 0)
{
yield return(new AtomicMatch(this, str, 1));
}
}
public override IEnumerable <RegexMatch> SimpleMatchings(StringPointer str, MatingContext context)
{
foreach (var match in _content.HeadMatches(str, context))
{
yield return(new CompositeMatch(this, str, match));
}
}
internal static JBoolean zParse(ParseStringRunner parseStringRunner, bool expectingTrue)
{
StringPointer sp = parseStringRunner.getStringPointer();
if (expectingTrue)
{
if (sp.isNextChars(TRUE.Substring(1)))
{
return(new JBoolean(true));
}
else
{
throw ParseException.forInvalidCharacter("Invalid string when expecting '" + TRUE + "'", parseStringRunner);
}
}
else
{
if (sp.isNextChars(FALSE.Substring(1)))
{
return(new JBoolean(false));
}
else
{
throw ParseException.forInvalidCharacter("Invalid string when expecting '" + FALSE + "'", parseStringRunner);
}
}
}
public override IEnumerable <RegexMatch> SimpleMatchings(StringPointer str, MatingContext context)
{
if (str.Pointer == str.RawStr.Length)
{
yield return(new PositionMatch(this, str));
}
}
public AtomicMatch(Regex regex, StringPointer str, int length) : base(regex, str)
{
if (str.Length < length)
{
throw new Exception("すすめすぎ");
}
_length = length;
}
public override IEnumerable <RegexMatch> SimpleMatchings(StringPointer str, MatingContext context)
{
foreach (var match in _arg.SimpleMatchings(str, context))
{
yield break;
}
yield return(new PositionMatch(this, str));
}
public override IEnumerable <RegexMatch> SimpleMatchings(StringPointer str, MatingContext context)
{
//NamedはMatchTreeに影響しない
if (!context.NamedRegexes.ContainsKey(_label))
{
context.NamedRegexes.Add(_label, this);
}
return(_content.HeadMatches(str, context));
}
internal ParseStringRunner(string sourceString, ParseStringSettings settings)
{
if (settings == null)
{
settings = new ParseStringSettings();
}
this.settings = settings;
stringPointer = new StringPointer(sourceString, settings.ParseStartIndex, this);
}
public override IEnumerable <RegexMatch> SimpleMatchings(StringPointer str, MatingContext context)
{
var matches = _content.HeadMatches(str, context).ToList();
for (int i = 0; i < matches.Count; i++)
{
yield return(matches[matches.Count - 1 - i]);
}
}
public override IEnumerable <RegexMatch> SimpleMatchings(StringPointer str, MatingContext context)
{
var match = _target.HeadMatch(str, context);
if (match != null)
{
yield return(new CompositeMatch(this, str, match));
}
yield return(new PositionMatch(this, str));
}
public override IEnumerable <RegexMatch> SimpleMatchings(StringPointer str, MatingContext context)
{
foreach (var targetMatch in _target.SimpleMatchings(str, context))
{
var nextPos = str.SubString(targetMatch.Length);
var conditionMatch = _condition.SimpleMatchings(nextPos, context).FirstOrDefault();
if (conditionMatch == null)
{
yield return(new CompositeMatch(this, str, targetMatch));
}
}
}
public override IEnumerable <RegexMatch> SimpleMatchings(StringPointer str, MatingContext context)
{
foreach (var targetMatch in _target.SimpleMatchings(str, context))
{
var nextPos = str.RawStr.Substring(0, str.Pointer); //ここより前の文字列
var conditionMatch = _condition.TailMatches((StringPointer)nextPos, context).FirstOrDefault(); //条件の直前へのマッチ
if (conditionMatch != null)
{
yield return(new CompositeMatch(this, str, targetMatch));
}
}
}
public sealed override IEnumerable <RegexMatch> SimpleMatchings(StringPointer str, MatingContext context)
{
if (str.Length == 0)
{
yield break;
}
var sub = str.Value()[0];
if (CheckChar(sub))
{
yield return(new AtomicMatch(this, str, 1));
}
}
internal static JNull zParse(ParseStringRunner parseStringRunner)
{
StringPointer sp = parseStringRunner.getStringPointer();
if (sp.isNextChars(NULL.Substring(1)))
{
return(new JNull());
}
else
{
throw ParseException.forInvalidCharacter("Invalid string when expecting '" + NULL + "'", parseStringRunner);
}
}
private void refreshInformation()
{
//lambda functions WOO!
new Thread(() =>
{
StringPointer busyLock = new StringPointer("refreshInformation");
business.Add(busyLock);
version = (execute("git", "version")).Trim();
string name = System.IO.Directory.GetCurrentDirectory();
name = name.Substring(name.LastIndexOf("" + System.IO.Path.DirectorySeparatorChar) + 1);
name = Regex.Replace(name, "-", m => " ");
name = name.Trim();
this._name = name;
execute("git", "fetch"); // and pray
string branchesCommand = execute("git", "branch -a");
string[] branches = branchesCommand.Split('\n');
for (int i = 0; i < branches.Length; i++)
{
branches[i] = branches[i].Trim();
if (branches[i].StartsWith("*"))
{
branches[i] = branches[i].Substring(1).Trim();
this.currentBranch = branches[i];
}
branches[i] = branches[i].Trim();
if (branches[i].Contains("/"))
{
string b = branches[i];
string r = b.Substring(8);
r = r.Substring(0, r.IndexOf('/'));
b = b.Substring(b.LastIndexOf('/') + 1);
//dialogue(r);
branches[i] = b;
//dialogue(branches[i]);
}
}
this.branches = branches;
mainThreadInvokeQueue += new Invoke(() =>
{
business.Remove(busyLock);
Repaint();
});
}).Start();
}
public override IEnumerable <RegexMatch> SimpleMatchings(StringPointer str, MatingContext context)
{
foreach (var selfMatch in _target.HeadMatches(str, context))
{
var next = str.SubString(selfMatch.Length);
foreach (var nextMatch in SimpleMatchings(next, context))
{
var list = new List <RegexMatch>();
list.Add(selfMatch);
var composite = (CompositeMatch)nextMatch;
list.AddRange(composite.Matches);
yield return(new CompositeMatch(this, str, list.ToArray()));
}
yield return(new CompositeMatch(this, str, selfMatch));
}
}
protected override void OnGameHook()
{
mono.Run(() => {
MonoNestedPointerFactory ptrFactory = new MonoNestedPointerFactory(this, mono);
var game = ptrFactory.Make <IntPtr>("Game", "ins_", out IntPtr gameClass);
globalVar = ptrFactory.Make <IntPtr>(game, mono.GetFieldOffset(gameClass, "<GlobalVar>k__BackingField"));
status = ptrFactory.Make <int>(game, mono.GetFieldOffset(gameClass, "<status>k__BackingField"));
playMgr = ptrFactory.Make <IntPtr>("PlayMgr", "ins", out IntPtr playMgrClass);
uiLock = ptrFactory.Make <int>(playMgr, mono.GetFieldOffset(playMgrClass, "<ui>k__BackingField"), 0x174);
playerTile = ptrFactory.MakeString(playMgr, mono.GetFieldOffset(playMgrClass, "<player>k__BackingField"), 0x38, 0x20, 0x10, 0x100, 0x14);
playerTile.StringType = EStringType.UTF16Sized;
Logger.Log(ptrFactory.ToString());
});
}
private void refreshHistory()
{
new Thread(() =>
{
StringPointer busyLock = new StringPointer("refreshHistory");
business.Add(busyLock);
int commitCount = Math.Min(Int32.Parse(execute("git", "rev-list --count HEAD").Trim()), maxCommits);
string[] syncedCommits = execute("git", "log @{u} -n " + commitCount + " --pretty=format:\"%h;%an;%ar;%s\"").Trim().Split('\n');
string[] localCommits = execute("git", "log @{u}..HEAD -n " + commitCount + " --pretty=format:\"%h;%an;%ar;%s\"").Trim().Split('\n');
history = new Commit[commitCount];
if (localCommits.Length == 1 && localCommits[0] == "")
localCommits = new string[] { };
for (int i = 0; i < localCommits.Length; i++)
{
Commit commit;
// log(localCommits[i]);
string[] parts = localCommits[i].Split(';');
commit.local = true;
commit.hash = parts[0];
commit.author = parts[1];
commit.date = parts[2];
commit.subject = parts[3];
history[i] = commit;
}
for (int i = 0; i < syncedCommits.Length; i++)
{
Commit commit;
// log(syncedCommits[i]);
string[] parts = syncedCommits[i].Split(';');
commit.local = false;
commit.hash = parts[0];
commit.author = parts[1];
commit.date = parts[2];
commit.subject = parts[3];
history[i + localCommits.Length] = commit;
}
mainThreadInvokeQueue += new Invoke(() =>
{
business.Remove(busyLock);
Repaint();
});
}).Start();
}
internal static JNumber zParse(ParseStringRunner parseStringRunner, char firstChr)
{
StringPointer sp = parseStringRunner.getStringPointer();
int start = sp.getCurrentIndex() - 1; // -1 since first character is already read
bool valid = parseCheck(sp, firstChr);
if (!valid)
{
throw ParseException.forInvalidCharacter("Invalid number value \"" + sp.getSubStringStartingFrom(start) + "\"", parseStringRunner);
}
else
{
sp.stepBack();
string validNumber = sp.getSubStringStartingFrom(start);
return(new JNumber(validNumber, parseStringRunner));
}
}
public ArrayMatch(StringPointer str, params RegexMatch[] contents) : base(new Empty(), str)
{
//ArrayMatchは展開する
var list = new List <RegexMatch>();
foreach (var child in contents)
{
var array = child as ArrayMatch;
if (array == null)
{
list.Add(child);
}
else
{
list.AddRange(array.Contents);
}
}
Contents = list.ToArray();
}
public object Convert(object value, Type targetType, object parameter, string language)
{
StringPointer str = (StringPointer)value;
if (str.Length <= 5)
{
return(str);
}
else if (str.Length <= 16)
{
int sep = (str.Length + 1) / 2;
return(string.Format("{0}\n{1}", str.Substring(0, sep), str.Substring(sep)));
}
else
{
int sep = (str.Length + 2) / 3;
return(string.Format("{0}\n{1}\n{2}", str.Substring(0, sep), str.Substring(sep, sep), str.Substring(2 * sep)));
}
}
internal static JString zParse(ParseStringRunner parseStringRunner, bool expectStartOfString)
{
StringPointer sp = parseStringRunner.getStringPointer();
if (expectStartOfString)
{
char chr;
if (!sp.tryGetNextNonWhiteChar(out chr))
{
throw ParseException.forInvalidStart("Parameter string didn't contain any non-white characters", parseStringRunner);
}
if (chr != '"')
{
throw ParseException.forInvalidStart("Invalid character '" + chr + "' when expecting start of string '\"'", parseStringRunner);
}
}
return(new JString(decode(parseStringRunner)));
}
public CompositeMatch(Regex regex, StringPointer str, params RegexMatch[] children) : base(regex, str)
{
//ArrayMatchは展開する
var list = new List <RegexMatch>();
foreach (var child in children)
{
var array = child as ArrayMatch;
if (array == null)
{
list.Add(child);
}
else
{
list.AddRange(array.Contents);
}
}
Matches = list.ToArray();
}
public object Convert(object value, Type targetType, object parameter, string language)
{
StringPointer str = (StringPointer)value;
if (str.Length <= 6)
{
return(48.0);
}
else if (str.Length <= 12)
{
return(40.0);
}
else if (str.Length <= 20)
{
return(32.0);
}
else
{
return(24.0);
}
}
private IEnumerable <RegexMatch> Sm(StringPointer str, MatingContext context, int minCount, int maxCount)
{
if (maxCount == 0)
{
yield return(new PositionMatch(this, str));
yield break;
}
foreach (var selfMatch in _target.HeadMatches(str, context))
{
var next = str.SubString(selfMatch.Length);
foreach (var targetMatch in Sm(next, context, minCount - 1, maxCount - 1))
{
var composite = targetMatch as CompositeMatch;
var list = new List <RegexMatch>();
list.Add(selfMatch);
if (composite != null)
{
list.AddRange(composite.Matches);
}
else
{
break;
}
yield return(new CompositeMatch(this, str, list.ToArray()));
}
if (minCount <= 1)
{
yield return(new CompositeMatch(this, str, selfMatch));
}
}
if (minCount <= 0)
{
yield return(new PositionMatch(this, str));
}
}
private void checkout(string branch)
{
dialogue(branch);
new Thread(() =>
{
StringPointer busyLock = new StringPointer("checkout");
business.Add(busyLock);
ExecuteResponse checkoutResponse = executeWithCode("git", "checkout " + branch);
if (checkoutResponse.exitCode == 0)
{
refreshInformation();
}
else
{
dialogue("Could not checkout", checkoutResponse.message);
}
mainThreadInvokeQueue += new Invoke(() =>
{
business.Remove(busyLock);
Repaint();
});
}).Start();
}
public override IEnumerable <RegexMatch> SimpleMatchings(StringPointer str, MatingContext context)//TODO:fix
{
foreach (var selfMatch in _target.HeadMatches(str, context))
{
var next = str.SubString(selfMatch.Length);
foreach (var targetMatch in SimpleMatchings(next, context))
{
var composite = targetMatch as CompositeMatch;
var list = new List <RegexMatch>();
list.Add(selfMatch);
if (composite != null)
{
list.AddRange(composite.Matches);
}
else
{
break;
}
yield return(new CompositeMatch(this, str, list.ToArray()));
}
yield return(new CompositeMatch(this, str, selfMatch));
}
yield return(new PositionMatch(this, str));
}
public StringPointer(StringPointer p)
{
Index = p.Index;
_data = p._data;
}
public StringPointer Increment(int i, bool withUpdate = true)
{
if (withUpdate)
{
Index += i;
if (Index > _data.Length)
Index = _data.Length;
return this;
}
var sp = new StringPointer(this);
return sp.Increment(i);
}
