private static void WriteRuleNodes <T>(string prefix, BranchingRule <T> rule, System.IO.TextWriter tw, ISTb <T> stb, bool endcase)
{
BranchingRule <T> rule1 = (rule is SwitchRule <T>?(rule as SwitchRule <T>).ToIteForVisualization() : rule);
UndefRule <T> raise = rule as UndefRule <T>;
if (raise != null)
{
tw.WriteLine("<Node Id=\"{0}\" {1} Category=\"Reject\" />", prefix, DisplayLabel(raise.Exc));
return;
}
BaseRule <T> block = rule as BaseRule <T>;
if (block != null)
{
string lab = Describe(stb, block, endcase);
string cat = (endcase ? "Accept" : "BasicBlock");
tw.WriteLine("<Node Id=\"{0}\" {1} Category=\"{2}\" />", prefix, DisplayLabel(lab), cat);
return;
}
else
{
IteRule <T> ite = (IteRule <T>)rule1;
string lab = stb.PrettyPrint(ite.Condition);
tw.WriteLine("<Node Id=\"{0}\" {1} Category=\"BranchCondition\" />", prefix, DisplayLabel(lab));
WriteRuleNodes(prefix + "." + "T", ite.TrueCase, tw, stb, endcase);
WriteRuleNodes(prefix + "." + "F", ite.FalseCase, tw, stb, endcase);
}
}
public static Rule Parse(string input, int index)
{
int id = int.Parse(input.Substring(0, index));
input = input.Substring(index + 1).Trim();
Rule rule = null;
if (input.StartsWith('\"'))
{
rule = new BaseRule(id, input);
}
else
{
index = input.IndexOf('|');
if (index >= 0)
{
rule = new MultiRule(id, input);
}
else
{
rule = new StandardRule(id, input, -1);
}
}
return(rule);
}
private static void WriteRuleNodes <T>(string source, STbRule <T> rule, System.IO.TextWriter tw, ISTb <T> stb, bool endcase)
{
UndefRule <T> raise = rule as UndefRule <T>;
if (raise != null)
{
tw.WriteLine("{0} [fillcolor = {2}, label =\"{1}\"];", source, ShortenLabel(DisplayLabel(raise.Exc)), excColor);
return;
}
BaseRule <T> block = rule as BaseRule <T>;
if (block != null)
{
string lab = Describe(stb, block, endcase);
if (endcase)
{
tw.WriteLine("{0} [fillcolor={1}, peripheries = 2, label =\"{2}\"];", source, accColor, DisplayLabel(lab));
}
else
{
tw.WriteLine("{0} [label =\"{1}\"];", source, DisplayLabel(lab));
}
return;
}
else
{
IteRule <T> ite = (IteRule <T>)rule;
string lab = stb.PrettyPrint(ite.Condition);
tw.WriteLine("{0} [label =\"{1}\", style=rounded];", source, ShortenLabel(DisplayLabel(lab)));
WriteRuleNodes(source + "T", ite.TrueCase, tw, stb, endcase);
WriteRuleNodes(source + "F", ite.FalseCase, tw, stb, endcase);
}
}
public FromClause(Interval ruleInterval, MySqlParser.FromClauseContext context, string text) : base(ruleInterval, context, text)
{
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(_listener, context);
_text = text;
Rules = _listener.Rules;
_whereRule = new BaseRule(new Interval(0, 0), context, "ERROR");
foreach (var rule in Rules)
{
switch (rule.Text)
{
case "FROM":
rule.Text = rule.Text + Environment.NewLine; break;
case "WHERE": rule.Text = Environment.NewLine + rule.Text + Environment.NewLine;
_whereRule = rule;
_whereInterval = rule.SourceInterval;
break;
case "GROUP": rule.Text = Environment.NewLine + rule.Text;
_groupInterval = rule.SourceInterval;
break;
case "BY": rule.Text += Environment.NewLine; break;
default: break;
}
}
}
public SelectStructure(SelectStructure inSelect)
{
_name = inSelect.Name;
_output = inSelect.Output;
_tableName = inSelect.TableName;
_indexColumnNames = inSelect.IndexColumnNames;
foreach (ColumnStructure column in inSelect.IndexColumns)
{
_indexColumns.Add(new ColumnStructure(column));
}
_createTableColumnNames = inSelect.CreateTableColumnNames;
_sortRule = inSelect.SortRule;
_inputTable = inSelect.InputTable;
_whereList = inSelect._whereList;
_asList = inSelect._asList;
_likeList = inSelect.LikeList;
_betweenList = inSelect._betweenList;
_inStructureList = inSelect.InStructureList;
_outTable = inSelect.OutTable;
List <ColumnStructure> tmpColumns = new List <ColumnStructure>();
foreach (ColumnStructure column in inSelect.OutColumn)
{
tmpColumns.Add(new ColumnStructure(column));
}
_outColumn = tmpColumns.ToArray();
}
public Flow(BaseRule rule, Enum providerType)
{
Time = DateTime.Now;
FlowLogs = new FlowLogs();
Rule = rule;
ProviderType = providerType;
}
public void ParseToken()
{
var t_Rule = new BaseRule();
var t_Expression = t_Rule.Match(CreateState(new Token(TokenType.None, "Foobar")));
t_Expression.HasError().Should().BeTrue();
}
private BaseRule CreateRule(string ruleName)
{
BaseRule baseRule = null;
switch (ruleName)
{
case "DataType":
{
baseRule = new DataTypeRule();
break;
}
case "Required":
{
baseRule = new MandatoryRule();
break;
}
case "DataPattern":
{
baseRule = new DataPatternRule();
break;
}
case "MaxLength":
{
baseRule = new DataLengthRule();
break;
}
case "Reference":
{
baseRule = new ReferenceRule();
break;
}
case "Hierarchy":
{
baseRule = new HierarchyRule();
break;
}
case "DelimitedHierarchy":
{
baseRule = new DelimitedHierarchyRule();
break;
}
case "List":
{
baseRule = new ListConstraintRule();
break;
}
}
return(baseRule);
}
public SelectStructure(string name, TableStructure table, List <WhereStructure> whereList, List <AsStructure> asList, BaseRule sortRule, List <BetweenStructure> betweenList)
{
_name = name;
_tableName = table.Name;
_inputTable = table;
_whereList = whereList;
_asList = asList;
_betweenList = betweenList;
_sortRule = sortRule;
}
/// <summary>
/// 可視化言語をGrass風言語ソースコードに変換
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static string VisualizedToGll(string source, BaseRule rule)
{
var tokens = Visualization.VisualizedLanguage.ToTokens(source);
StringBuilder sb = new StringBuilder();
foreach (var text in rule.TokensToText(tokens))
{
sb.Append(text);
}
return(sb.ToString());
}
private bool ExecuteRule(JObject rowJObject, string columnName, Rule rule)
{
BaseRule baseRule = CreateRule(rule.Name);
baseRule.ExecutionContext = executionContext;
baseRule.RuleData = rule.Value;
var success = baseRule.Execute(rowJObject, columnName);
return(success);
}
/// <summary>
/// 文字列を解釈し、実行する
/// </summary>
/// <param name="input">入力文字列</param>
/// <param name="addingFuncStack">追加プリミティブ関数</param>
/// <param name="rule">文字列からトークンに変換するためのルール</param>
public Runner(string input, BaseRule rule, Stack <GrassFunc> addingFuncStack = null)
{
Input = input;
_Rule = rule;
_FuncStack = new Stack <GrassFunc>();
_FuncStack.PushRange(_PrimitiveFuntions);
if (addingFuncStack != null && addingFuncStack.Count > 0)
{
_FuncStack.PushRange(addingFuncStack);
}
}
/// <summary>
/// 文字列を解釈し、実行する
/// </summary>
/// <param name="input">入力文字列</param>
/// <param name="addingFuncStack">追加プリミティブ関数</param>
/// <param name="rule">文字列からトークンに変換するためのルール</param>
public Runner(string input, BaseRule rule, Stack<GrassFunc> addingFuncStack = null)
{
Input = input;
_Rule = rule;
_FuncStack = new Stack<GrassFunc>();
_FuncStack.PushRange(_PrimitiveFuntions);
if (addingFuncStack != null && addingFuncStack.Count > 0)
{
_FuncStack.PushRange(addingFuncStack);
}
}
/// <summary>
/// ソースファイルを開き、テクストボックスに内容を貼り付ける<para></para>
/// ついでに拡張子からルールを変更する
/// </summary>
/// <param name="fileName"></param>
private void OpenSource(string fileName)
{
var taskReadSource = Task.Factory.StartNew(() =>
{
var fileExt = Path.GetExtension(fileName);
if (_FileExtensionToRule.Any(kvp =>
string.Compare(kvp.Key, fileExt, true) == 0))
{
lock (_SyncObjForm) _Rule = _FileExtensionToRule[fileExt];
}
else
{
lock (_SyncObjForm) _Rule = new RuleGrass();
}
var source = File.ReadAllText(fileName, Encoding.UTF8);//とりあえずUTF8オンリーで
return(source);
});
taskReadSource.ContinueWith(t =>
{
var source = t.Result;
var action = new Action(() =>
{
lock (_SyncObjForm)
{
try
{
_TimerSaveSourceState.Stop();
_TimerSaveVisualizedState.Stop();
textBoxSourceCode.Text = source;
if (_Rule is RuleGrass)
{
grassToolStripMenuItem.CheckState = CheckState.Checked;
}
else if (_Rule is RuleHomuHomu)
{
ほむほむToolStripMenuItem.CheckState = CheckState.Checked;
}
_IsSourceCodeChangedFromSystem = false;
_IsVisualizedLanguageChangedFromSystem = false;
//Undo,Redoの挙動を記録
SaveCursorAndTextOnTextBox(ref _PreviousCursorAndTextVisualized, textBoxVisualizedLanguage);
}
finally
{
_TimerSaveSourceState.Start();
_TimerSaveVisualizedState.Start();
}
}
});
this.BeginInvoke(action);
});
}
public void CreateSpecificExpressionFromBaseRule()
{
var t_Rule = new BaseRule(new List <Token>
{
new Token(TokenType.Keyword, null)
}, (Tokens) => new KeywordExpression {
Keyword = Tokens.First()
});
var t_Expression = t_Rule.Match(CreateState(new Token(TokenType.Keyword, "*")));
t_Expression.HasError().Should().BeFalse();
}
/// <summary>获取上限值</summary>
public BaseRule GetBaseRule(tg_user user, int roleid)
{
var baserule = new BaseRule();
if (roleid == user.role_id)
{
baserule = Variable.BASE_RULE.FirstOrDefault(m => m.id == "7013");
}
else
{
baserule = Variable.BASE_RULE.FirstOrDefault(m => m.id == "7019");
}
return(baserule);
}
/// <summary>
/// Grass風言語ソースコードを可視化言語に変換
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static string GllToVisualized(string source, BaseRule rule)
{
var il = Visualization.VisualizedLanguage.ToVisualizedLanguage(
TokenWithCount.CountContinuousTokens(
rule.TextToTokens(
source)
).ToArray());
StringBuilder sb = new StringBuilder();
foreach (var line in il)
{
sb.AppendLine(line.Line);
}
return sb.ToString();
}
/// <summary>
/// 获取加成值
/// </summary>
/// <param name="att">武将值</param>
/// <param name="value">加成值</param>
/// <param name="base_rule">上限值</param>
private double GetAtt(double att, int value, BaseRule base_rule)
{
att = att + value;
var _att = att - Convert.ToDouble(base_rule.value);
if (!(_att > 0))
{
return(value);
}
var use = value - _att;
return(use < 0 ? 0 : use);
}
void ApplyRule(BaseRule rule)
{
if (rule.Amount < 0)
{
Penalty -= rule.Amount;
AppliedRules.Add(new AppliedRule(rule.GetLocalizedName(M.UI.S), rule.GetLocalizedDescr(M.UI.S), rule.Amount));
}
else
{
Bonus += rule.Amount;
}
Debug.Log(string.Format("Rule '{0}' for ${1} - {2}", rule.Name, rule.Amount, rule.GetLocalizedName(M.UI.S)));
}
/// <summary>
/// Grass風言語ソースコードを可視化言語に変換
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static string GllToVisualized(string source, BaseRule rule)
{
var il = Visualization.VisualizedLanguage.ToVisualizedLanguage(
TokenWithCount.CountContinuousTokens(
rule.TextToTokens(
source)
).ToArray());
StringBuilder sb = new StringBuilder();
foreach (var line in il)
{
sb.AppendLine(line.Line);
}
return(sb.ToString());
}
//private static string Describe<T>(ISTb<T> stb, BaseRule<T> basic, bool endcase)
//{
// List<string> lab = new List<string>();
// for (int i = 0; i < basic.Yields.Length; i++)
// {
// lab.Add("yield " + stb.PrettyPrint(basic.Yields[i]));
// }
// string rhs = stb.PrettyPrint(basic.Register);
// if (!endcase && !(rhs.Equals(STbInfo.__empty_tuple) || rhs.Equals(STbInfo.__register_variable))) //either registers are not used, or the assignment is trivial
// lab.Add(string.Format("{0}:={1}", STbInfo.__register_variable, rhs));
// lab = ShortenWidth(lab);
// int k = 0;
// foreach (string s in lab)
// k = Math.Max(s.Length, k);
// //add spaces to simulate left alignment
// for (int i = 0; i < lab.Count; i++)
// lab[i] = lab[i] + MkSpaces(k - lab[i].Length);
// var labStr = "";
// for (int i = 0; i < lab.Count; i++)
// {
// if (i > 0)
// labStr += "\\n";
// labStr += lab[i];
// }
// return labStr;
//}
private static string Describe <T>(ISTb <T> stb, BaseRule <T> basic, bool endcase)
{
List <string> lab = new List <string>();
string labYield = "[";
for (int i = 0; i < basic.Yields.Length; i++)
{
if (i > 0)
{
labYield += ", ";
}
labYield += stb.PrettyPrint(basic.Yields[i]);
}
labYield += "]";
lab.Add(labYield);
string rhs = stb.PrettyPrint(basic.Register);
if (!endcase && !(rhs.Equals(STbInfo.__empty_tuple) || rhs.Equals(STbInfo.__register_variable))) //either registers are not used, or the assignment is trivial
{
lab.Add(string.Format("{0}:={1}", STbInfo.__register_variable, rhs));
}
lab = ShortenWidth(lab);
int k = 0;
foreach (string s in lab)
{
k = Math.Max(s.Length, k);
}
//add spaces to simulate left alignment
for (int i = 0; i < lab.Count; i++)
{
lab[i] = lab[i] + MkSpaces(k - lab[i].Length);
}
var labStr = "";
for (int i = 0; i < lab.Count; i++)
{
if (i > 0)
{
labStr += "\\n";
}
labStr += lab[i];
}
return(labStr);
}
public static Strategy LoadFromDescription(string desc, IndicatorRepository ir, IMarketWatch mw)
{
int rulesIndex = desc.IndexOf("Rules:");
int instIndex = desc.IndexOf("INST:");
string tfs = desc.Substring(3, instIndex - 3);
string[] tfsList = tfs.Replace("(", "").Replace(")", "").Split(' ');
Strategy result = new Strategy(ir);
result.smallPeriod = int.Parse(tfsList[0]);
result.defaultPeriod = int.Parse(tfsList[1]);
result.largePeriod = int.Parse(tfsList[2]);
string inst = desc.Substring(instIndex + 6, rulesIndex - instIndex - 7);
result.defaultInstrument = mw.FindInstrument(inst);
if (result.defaultInstrument == null)
{
throw new Exception("Cannot find strategy instrument");
}
rulesIndex = desc.IndexOf('{', rulesIndex);
string[] rules = desc.Substring(rulesIndex).Split('{');
foreach (string rule in rules)
{
if (rule.Length == 0)
{
continue;
}
string trule = rule.Substring(0, rule.Length - 1);
BaseRule ruleObject = BaseRule.LoadFromDescription(trule);
//ruleObject.SetPeriods(result.smallPeriod, result.defaultPeriod, result.largePeriod);
result.AddRule(ruleObject);
}
return(result);
}
protected override STbz3 HandleStrLiteral(Frontend.AST.strconst e)
{
//throw new NotImplementedException();
//create an STb that removes the input and just outputs the output string
STbz3 res = new STbz3(this.stb.Solver, "fixed", this.charsort, this.charsort, this.stb.Solver.UnitSort, this.stb.Solver.UnitConst, 0);
var rule = new BaseRule <Expr>(Sequence <Expr> .Empty, this.stb.Solver.UnitConst, 0);
res.AssignRule(0, rule);
List <Expr> elems = new List <Expr>();
foreach (var c in e.val)
{
elems.Add(this.stb.Solver.MkCharExpr(c));
}
var yield = new Sequence <Expr>(elems.ToArray());
var frule = new BaseRule <Expr>(yield, this.stb.Solver.UnitConst, 0);
res.AssignFinalRule(0, frule);
return(res);
}
/// <summary>
/// Sets the rules context menu (add, remove, etc.)
/// </summary>
/// <param name='contextRect'>
/// Context active rectangle for mouse click
/// </param>
/// <param name='rule'>
/// Rule in question
/// </param>
private void SetRulesContextMenu(Rect contextRect, BaseRule rule)
{
var evt = Event.current;
if (evt.type == EventType.ContextClick)
{
var mousePos = evt.mousePosition;
if (contextRect.Contains(mousePos))
{
// Now create the menu, add items and show it
var menu = new GenericMenu();
menu.AddItem(new GUIContent("Reset"), false, ResetRule, rule);
menu.AddItem(new GUIContent("Remove"), false, RemoveRule, rule);
menu.ShowAsContext();
evt.Use();
}
}
}
/// <summary>
/// コマンドプロンプトを立ち上げ、Grass風言語を実行する
/// </summary>
/// <param name="source"></param>
/// <param name="rule"></param>
/// <returns></returns>
private static void GllRun(string source, BaseRule rule)
{
string option;
if (rule is RuleGrass)
{
option = "-g";
}
else if (rule is RuleHomuHomu)
{
option = "-h";
}
else
{
option = "-g";
}
var args = (option + " -e " + source).Split(' ');
Interpreter.Interpreter.Run(args);
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
level = e.Parameter as LevelViewModel;
FieldModel = new FieldSlotViewModel(level.OptionGame);
switch (level.OptionGame.RuleMode)
{
case "RuleAddition":
rule = new RuleAddition(ref FieldModel, "RuleAddition");
break;
case "RuleMultiplication":
rule = new RuleMultiplication(ref FieldModel, "RuleMultiplication");
break;
default:
break;
}
Description.Text = rule.Description;
InitGameAndRun();
}
STb <FuncDecl, Expr, Sort> GenerateToBytes()
{
var ctx = _automataCtx.Z3;
Expr inputVar = _automataCtx.MkVar(0, ctx.BoolSort);
Expr registerVar = _automataCtx.MkVar(1, _automataCtx.MkTupleSort(ctx.MkBitVecSort(8), ctx.MkBitVecSort(32)));
Sort outputSort = ctx.MkBitVecSort(8);
Expr initialRegister = _automataCtx.MkTuple(ctx.MkBV(0, 8), ctx.MkBV(0, 32));
var stb = new STb <FuncDecl, Expr, Sort>(_automataCtx, DeclarationType.Name, inputVar.Sort, outputSort, registerVar.Sort, initialRegister, 0);
BitVecExpr symbolProj = (BitVecExpr)_automataCtx.MkProj(0, registerVar);
BitVecExpr counterProj = (BitVecExpr)_automataCtx.MkProj(1, registerVar);
var withFalse = ctx.MkBVLSHR(symbolProj, ctx.MkBV(1, 8));
var withTrue = ctx.MkBVOR(withFalse, ctx.MkBV(0x80, 8));
var counterIncremented = ctx.MkBVAdd(counterProj, ctx.MkBV(1, 32));
var accumulateTrue = new BaseRule <Expr>(Sequence <Expr> .Empty, _automataCtx.MkTuple(withTrue, counterIncremented), 0);
var accumulateFalse = new BaseRule <Expr>(Sequence <Expr> .Empty, _automataCtx.MkTuple(withFalse, counterIncremented), 0);
var accumulate = new IteRule <Expr>(inputVar, accumulateTrue, accumulateFalse);
var yieldTrueAndReset = new BaseRule <Expr>(new Sequence <Expr>(withTrue), initialRegister, 0);
var yieldFalseAndReset = new BaseRule <Expr>(new Sequence <Expr>(withFalse), initialRegister, 0);
var yieldAndReset = new IteRule <Expr>(inputVar, yieldTrueAndReset, yieldFalseAndReset);
var move = new IteRule <Expr>(ctx.MkBVULT(counterProj, ctx.MkBV(7, 32)), accumulate, yieldAndReset);
stb.AssignRule(0, move);
STbRule <Expr> final = new BaseRule <Expr>(Sequence <Expr> .Empty, registerVar, 0);
for (int i = 1; i <= 7; ++i)
{
var yieldRule = new BaseRule <Expr>(new Sequence <Expr>(ctx.MkBVLSHR(symbolProj, ctx.MkBV(8 - i, 8))), registerVar, 0);
final = new IteRule <Expr>(ctx.MkEq(counterProj, ctx.MkBV(i, 32)), yieldRule, final);
}
stb.AssignFinalRule(0, final);
return(stb);
}
/// <summary>
/// 收集Rule
/// </summary>
/// <param name="enabled">只收集开启的</param>
/// <param name="sorted">收集后排序</param>
public static List <BaseRule> CollectRule(bool enabled = true, bool sorted = true)
{
List <BaseRule> rules = new List <BaseRule>();
string[] ruleGuids = AssetDatabase.FindAssets("t:BaseRule");
for (int iRule = 0; iRule < ruleGuids.Length; iRule++)
{
string iterRuleGuid = ruleGuids[iRule];
string iterRuleAssetPath = AssetDatabase.GUIDToAssetPath(iterRuleGuid);
BaseRule iterRule = AssetDatabase.LoadMainAssetAtPath(iterRuleAssetPath) as BaseRule;
if (iterRule == null)
{
continue;
}
try
{
string[] ruleNameSplits = iterRule.name.Split(RULE_FILENAME_SPLIT);
iterRule._Enable = ruleNameSplits[0] == RULE_ENABLE_SIGN;
iterRule._Order = int.Parse(ruleNameSplits[1]);
iterRule._Name = ruleNameSplits[2];
}
catch (Exception e)
{
MDebug.LogError("AssetBundle"
, $"规则({iterRule.name})不符合的命名规则");
throw e;
}
if ((enabled && iterRule._Enable) ||
!enabled)
{
rules.Add(iterRule);
}
}
rules.Sort(BaseRule.Comparison);
return(rules);
}
private static string Describe <T>(ISTb <T> stb, BaseRule <T> basic, bool endcase)
{
StringBuilder lab = new StringBuilder("yield (");
for (int i = 0; i < basic.Yields.Length; i++)
{
if (i > 0)
{
lab.Append(",");
}
lab.Append(stb.PrettyPrint(basic.Yields[i]));
}
lab.Append(")");
string rhs = stb.PrettyPrint(basic.Register);
if (!endcase && !(rhs.Equals(STbInfo.__empty_tuple) || rhs.Equals(STbInfo.__register_variable))) //either registers are not used, or the assignment is trivial
{
lab.AppendFormat("; {0}:={1}", STbInfo.__register_variable, rhs);
}
var labStr = lab.ToString();
return(labStr);
}
void ApplyRule(BaseRule rule)
{
if(rule.Amount<0)
{
Penalty-=rule.Amount;
AppliedRules.Add(new AppliedRule(rule.GetLocalizedName(M.UI.S),rule.GetLocalizedDescr(M.UI.S), rule.Amount));
}
else
Bonus+=rule.Amount;
Debug.Log(string.Format("Rule '{0}' for ${1} - {2}",rule.Name,rule.Amount,rule.GetLocalizedName(M.UI.S)));
}
/// <summary>
/// 可視化言語をGrass風言語ソースコードに変換
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static string VisualizedToGll(string source, BaseRule rule)
{
var tokens = Visualization.VisualizedLanguage.ToTokens(source);
StringBuilder sb = new StringBuilder();
foreach (var text in rule.TokensToText(tokens))
{
sb.Append(text);
}
return sb.ToString();
}
// This function is called every editor gui update. In here we are diong our magic to show all to the user in a nice way.
public override void OnInspectorGUI()
{
//Setting styles
if (_descBoxStyle == null)
{
_descBoxStyle = new GUIStyle(GUI.skin.FindStyle("Box"));
_descBoxStyle.alignment = TextAnchor.UpperLeft;
_descBoxStyle.normal.textColor = Color.white;
_descBoxStyle.stretchWidth = true;
_bigBoxStyle = new GUIStyle(GUI.skin.FindStyle("Box"));
_bigBoxStyle.alignment = TextAnchor.UpperLeft;
_bigBoxStyle.normal.textColor = Color.white;
_bigBoxStyle.stretchHeight = true;
_bigBoxStyle.normal.background = (Texture2D)Resources.Load("SourceBack");
_popupStyle = new GUIStyle(GUI.skin.FindStyle("Popup"));
_popupStyle.fontStyle = (FontStyle.Normal);
_popupStyle.stretchHeight = true;
}
EditorGUIUtility.LookLikeInspector();
serializedObject.Update(); // update the serialized object since the last time this method was called.
BaseAction myTarget = (BaseAction)target;
myTarget.UpdateInspector();
SerializedProperty script = serializedObject.FindProperty("m_Script");
EditorGUILayout.PropertyField(script, new GUIContent("Script", myTarget.GetActionDescription()));
//Show first public visible fields with the Attribute "ShowAtfirst"
SerializedProperty prop = serializedObject.GetIterator();
prop.NextVisible(true);
do
{
if (ShouldShowFirst(prop))
{
EditorGUILayout.PropertyField(prop, true);
}
} while (prop.NextVisible(false));
//then show Triggers
Rect rect = EditorGUILayout.BeginVertical();
GUI.Box(rect, "", _bigBoxStyle);
if (myTarget.IsSupportCustomTriggers())
{
GUILayout.Space(5);
// Add Trigger row - Combo-box + Add Button
Rect addTriggerRect = EditorGUILayout.BeginHorizontal();
{
if (_triggerToAdd != null)
{
// If user pressed on "Add" button - add the selected trigger to the action's supported triggers
_supportedTriggers.InsertArrayElementAtIndex(0);
_supportedTriggers.GetArrayElementAtIndex(0).objectReferenceValue = myTarget.AddHiddenComponent(_triggerToAdd);
((Trigger)_supportedTriggers.GetArrayElementAtIndex(0).objectReferenceValue).CleanRules();
_triggerToAdd = null;
}
GUILayout.Box("Add Triger", _popupStyle);
var evt = Event.current;
if (evt.type == EventType.mouseDown)
{
//Getting all Triggers
List <System.Type> possibleTriggers = myTarget.GetSupprtedTriggers();
var mousePos = evt.mousePosition;
if (addTriggerRect.Contains(mousePos))
{
// Now create the menu, add items and show it
var menu = new GenericMenu();
for (int i = 0; i < possibleTriggers.Count; i++)
{
string triggerFriendlyName = "";
if (!_friendlyNames.ContainsKey(possibleTriggers[i].FullName))
{
GameObject g = new GameObject("temp");
Trigger triggerTemp = (Trigger)g.AddComponent(possibleTriggers[i]);
_friendlyNames.Add(possibleTriggers[i].FullName, triggerTemp.FriendlyName);
DestroyImmediate(g);
}
triggerFriendlyName = _friendlyNames[possibleTriggers[i].FullName];
menu.AddItem(new GUIContent(triggerFriendlyName), false, AddTrigger, possibleTriggers[i]);
}
menu.ShowAsContext();
evt.Use();
}
}
}
EditorGUILayout.EndHorizontal();
}
// go over all the Action's supported triggers and add them to the inspector.
for (int i = 0; i < _supportedTriggers.arraySize; i++)
{
//Get Trigger and update rules
Trigger trigger = (Trigger)_supportedTriggers.GetArrayElementAtIndex(i).objectReferenceValue;
if (trigger == null)
{
((BaseAction)target).InitializeSupportedTriggers();
EditorGUILayout.EndVertical();
return;
}
// Trigger Row - Foldout + Reset trigger button + Delete trigger
Rect triggerRect = EditorGUILayout.BeginHorizontal();
{
trigger.FoldoutOpen = GUIUtils.Foldout(trigger.FoldoutOpen, trigger.FriendlyName);
if (trigger.FoldoutOpen)
{
List <System.Type> supprtedRules1 = trigger.GetSupportedRules();
Rect rectRuleAddButton = EditorGUILayout.BeginHorizontal();
GUILayout.Box("Add", _popupStyle, GUILayout.Width(50));
EditorGUILayout.EndHorizontal();
GUILayout.FlexibleSpace();
var evt = Event.current;
if (evt.type == EventType.mouseDown)
{
var mousePos = evt.mousePosition;
if (rectRuleAddButton.Contains(mousePos))
{
// Now create the menu, add items and show it
var menu1 = new GenericMenu();
for (int ri = 0; ri < supprtedRules1.Count(); ri++)
{
string ruleFriendlyName = "";
if (!_friendlyNames.ContainsKey(supprtedRules1[ri].FullName))
{
GameObject g = new GameObject("temp");
BaseRule ruleTemp = (BaseRule)g.AddComponent(supprtedRules1[ri]);
_friendlyNames.Add(supprtedRules1[ri].FullName, ruleTemp.FriendlyName);
DestroyImmediate(g);
}
ruleFriendlyName = _friendlyNames[supprtedRules1[ri].FullName];
menu1.AddItem(new GUIContent(ruleFriendlyName), false, AddRule, supprtedRules1[ri]);
}
menu1.ShowAsContext();
evt.Use();
_triggerToAddRuleTo = trigger;
}
}
}
}
EditorGUILayout.EndHorizontal();
SetTriggersContextMenu(triggerRect, myTarget, trigger);
// show trigger's rules if opened
if (trigger.FoldoutOpen)
{
SerializedObject obj = new SerializedObject(_supportedTriggers.GetArrayElementAtIndex(i).objectReferenceValue);
SerializedProperty rules = obj.FindProperty("Rules");
if (true)
{
// Add Trigger row - Combo-box + Add Button
EditorGUILayout.BeginHorizontal();
{
//Adding combo-box control to the inspector with the list of triggers.
if (_triggerToAddRuleTo == trigger && _ruleToAdd != null)
{
// If user pressed on "Add" button - add the selected trigger to the action's supported triggers
rules.InsertArrayElementAtIndex(0);
rules.GetArrayElementAtIndex(0).objectReferenceValue = myTarget.AddHiddenComponent(_ruleToAdd);
// initialize rules
_ruleToAdd = null;
_triggerToAddRuleTo = null;
}
}
EditorGUILayout.EndHorizontal();
GUILayout.Space(5);
}
for (int j = 0; j < rules.arraySize; j++)
{
BaseRule rule = (BaseRule)rules.GetArrayElementAtIndex(j).objectReferenceValue;
DrawRuleInspector(rule);
//Reset Rule
if (_ruleToReset != null && _ruleToReset == rule)
{
rule.ActionOwner = null;
rules.GetArrayElementAtIndex(j).objectReferenceValue = myTarget.AddHiddenComponent(_ruleToReset.GetType());
// Save folded state
((BaseRule)rules.GetArrayElementAtIndex(j).objectReferenceValue).FoldoutOpen = rule.FoldoutOpen;
_ruleToReset = null;
}
//Remove Rule
if (_ruleToRemove != null && _ruleToRemove == rule)
{
// delete the trigger and reorganize the array
var r = rules.GetArrayElementAtIndex(j).objectReferenceValue;
rules.DeleteArrayElementAtIndex(j);
((BaseRule)r).ActionOwner = null;
for (int k = j; k < rules.arraySize - 1; k++)
{
rules.MoveArrayElement(k + 1, k);
}
rules.arraySize--;
_ruleToRemove = null;
}
}
//Save changes to the rule
obj.ApplyModifiedProperties();
}
// Reset Trigger
if (_triggerToReset != null && _triggerToReset == trigger)
{
trigger.ActionOwner = null;
foreach (BaseRule r in trigger.Rules)
{
r.ActionOwner = null;
}
_supportedTriggers.GetArrayElementAtIndex(i).objectReferenceValue = myTarget.AddHiddenComponent(trigger.GetType());
Trigger oldTrigger = trigger;
trigger = (Trigger)_supportedTriggers.GetArrayElementAtIndex(i).objectReferenceValue;
trigger.CleanRules();
//trigger.SetDefaults(myTarget);
myTarget.SetDefaultTriggerValues(i, trigger);
// Save folded state
trigger.FoldoutOpen = oldTrigger.FoldoutOpen;
_triggerToReset = null;
break;
}
// Remove Trigger
if (_triggerToRemove != null && _triggerToRemove == trigger)
{
// delete the trigger and reorganize the array
_supportedTriggers.DeleteArrayElementAtIndex(i);
trigger.ActionOwner = null;
if (trigger.Rules != null)
{
foreach (BaseRule r in trigger.Rules)
{
if (r != null)
{
r.ActionOwner = null;
}
}
}
for (int j = i; j < _supportedTriggers.arraySize - 1; j++)
{
_supportedTriggers.MoveArrayElement(j + 1, j);
}
_supportedTriggers.arraySize--;
break;
}
}
EditorGUILayout.Space();
EditorGUILayout.EndVertical();
// Draw the rest of the control except several predefined fields or the fields which are marked as show first
prop = serializedObject.GetIterator();
prop.NextVisible(true);
do
{
if (prop.name != "m_Script" && !ShouldShowFirst(prop))
{
EditorGUILayout.PropertyField(prop, true);
}
} while (prop.NextVisible(false));
//Save changes to the Action Script
serializedObject.ApplyModifiedProperties();
}
public void TestSTbSimplify()
{
string utf8decode_bek = @"
function fuse(r,c) = ((r << 6) | (c & 0x3F));
function one(c) = ((0 <= c) && (c <= 0x7F));
function C2_DF(c) = ((0xC2 <= c) && (c <= 0xDF));
function E1_EF(c) = ((0xE1 <= c) && (c <= 0xEF));
function A0_BF(c) = ((0xA0 <= c) && (c <= 0xBF));
function x80_BF(c) = ((0x80 <= c) && (c <= 0xBF));
function x80_9F(c) = ((0x80 <= c) && (c <= 0x9F));
program utf8decode(input){
return iter(c in input)[q := 0; r := 0;]
{
case (q == 0):
if (one(c)) {yield (c);}
else if (C2_DF(c)) {q := 2; r := (c & 0x1F);} // ------ 2 bytes --------
else if (c == 0xE0) {q := 4; r := (c & 0x0F);} // ------ 3 bytes --------
else if (c == 0xED) {q := 5; r := (c & 0x0F);} // ------ 3 bytes --------
else if (E1_EF(c)) {q := 3; r := (c & 0x0F);} // ------ 3 bytes --------
else {raise InvalidInput;}
case (q == 2):
if (x80_BF(c)) {q := 0; yield(fuse(r,c)); r := 0;}
else {raise InvalidInput;}
case (q == 3):
if (x80_BF(c)) {q := 2; r := fuse(r,c);}
else {raise InvalidInput;}
case (q == 4):
if (A0_BF(c)) {q := 2; r := fuse(r,c);}
else {raise InvalidInput;}
case (q == 5):
if (x80_9F(c)) {q := 2; r := fuse(r,c);}
else {raise InvalidInput;}
end case (!(q == 0)):
raise InvalidInput;
};
}
";
Z3Provider solver = new Z3Provider(BitWidth.BV16);
var dec = BekConverter.BekToSTb(solver, utf8decode_bek);
var utf8decode = dec.ExploreBools();
Sort bv32 = solver.MkBitVecSort(32);
Sort outSort = solver.MkTupleSort(solver.StringSort, bv32);
var initReg = solver.MkTuple(solver.GetNil(solver.StringSort), solver.MkNumeral(0, bv32));
var regVar = solver.MkVar(1, outSort);
var reg1 = solver.MkProj(1, regVar);
var reg0 = solver.MkProj(0, regVar);
STb <FuncDecl, Expr, Sort> parse = new STbModel(solver, "Parse", solver.CharacterSort, outSort, outSort, initReg, 0);
var letter = solver.MkOr( //solver.MkAnd(solver.MkCharLe(solver.MkCharExpr('\xC0'), solver.CharVar),
// solver.MkCharLe(solver.CharVar, solver.MkCharExpr('\xFF'))),
solver.MkAnd(solver.MkCharLe(solver.MkCharExpr('a'), solver.CharVar),
solver.MkCharLe(solver.CharVar, solver.MkCharExpr('z'))),
solver.MkAnd(solver.MkCharLe(solver.MkCharExpr('A'), solver.CharVar),
solver.MkCharLe(solver.CharVar, solver.MkCharExpr('Z'))));
//var not_letter = solver.MkNot(letter);
var digit = solver.MkAnd(solver.MkCharLe(solver.MkCharExpr('0'), solver.CharVar),
solver.MkCharLe(solver.CharVar, solver.MkCharExpr('9')));
var nl = solver.MkEq(solver.CharVar, solver.MkCharExpr('\n'));
var space = solver.MkEq(solver.CharVar, solver.MkCharExpr(' '));
//var not_nl = solver.MkNot(nl);
var _0 = solver.MkNumeral((int)'0', bv32);
//var z = solver.Z3.MkFreshConst("z", solver.CharacterSort);
//var constr = solver.MkNot(solver.Z3.MkExists(new Expr[] { z }, nl.Substitute(solver.CharVar, z)));
////var constr = nl.Substitute(solver.CharVar, z);
//solver.Z3S.Push();
//solver.Z3S.Assert((BoolExpr)solver.MkNot(constr));
//var status = solver.Check();
//var m = solver.Z3S.Model;
//var zval = m.Evaluate(z, true);
//solver.Z3S.Pop();
var loop_0 = new BaseRule <Expr>(Sequence <Expr> .Empty, regVar, 0);
var brule0_1 = new BaseRule <Expr>(Sequence <Expr> .Empty, solver.MkTuple(solver.MkListCons(solver.CharVar, reg0), reg1), 1);
var rule0 = new IteRule <Expr>(letter, brule0_1, new IteRule <Expr>(space, loop_0, UndefRule <Expr> .Default));
parse.AssignRule(0, rule0);
var brule1_2 = new BaseRule <Expr>(Sequence <Expr> .Empty, solver.MkTuple(solver.MkListCons(solver.CharVar, reg0), reg1), 2);
var brule_4 = new BaseRule <Expr>(Sequence <Expr> .Empty, regVar, 4);
var rule1 = new IteRule <Expr>(letter, brule1_2, new IteRule <Expr>(space, brule_4, UndefRule <Expr> .Default));
parse.AssignRule(1, rule1);
var brule2_3 = new BaseRule <Expr>(Sequence <Expr> .Empty, solver.MkTuple(solver.MkListCons(solver.CharVar, reg0), reg1), 4);
var rule2 = new IteRule <Expr>(letter, brule2_3, new IteRule <Expr>(space, brule_4, UndefRule <Expr> .Default));
parse.AssignRule(2, rule2);
var bv32var = solver.Z3.MkZeroExt(16, (BitVecExpr)solver.CharVar);
var brule4_5 = new BaseRule <Expr>(Sequence <Expr> .Empty, solver.MkTuple(reg0, solver.MkBvAdd(
solver.MkBvMul(solver.MkNumeral(10, bv32), reg1),
solver.MkBvSub(bv32var, _0))), 5);
var rule4 = new IteRule <Expr>(digit, brule4_5, new IteRule <Expr>(space, brule_4, UndefRule <Expr> .Default));
parse.AssignRule(4, rule4);
var brule_0 = new BaseRule <Expr>(Sequence <Expr> .Empty.Append(regVar), initReg, 0);
var brule_7 = new BaseRule <Expr>(Sequence <Expr> .Empty, regVar, 7);
var brule5_6 = new BaseRule <Expr>(Sequence <Expr> .Empty, solver.MkTuple(reg0, solver.MkBvAdd(
solver.MkBvMul(solver.MkNumeral(10, bv32), reg1),
solver.MkBvSub(bv32var, _0))), 6);
var rule5 = new IteRule <Expr>(digit, brule5_6, new IteRule <Expr>(nl, brule_0, new IteRule <Expr>(space, brule_7, UndefRule <Expr> .Default)));
parse.AssignRule(5, rule5);
var brule6_7 = new BaseRule <Expr>(Sequence <Expr> .Empty, solver.MkTuple(reg0, solver.MkBvAdd(
solver.MkBvMul(solver.MkNumeral(10, bv32), reg1),
solver.MkBvSub(bv32var, _0))), 7);
var rule6 = new IteRule <Expr>(digit, brule6_7, new IteRule <Expr>(nl, brule_0, new IteRule <Expr>(space, brule_7, UndefRule <Expr> .Default)));
parse.AssignRule(6, rule6);
var rule7 = new IteRule <Expr>(nl, brule_0, new IteRule <Expr>(space, brule_7, UndefRule <Expr> .Default));
parse.AssignRule(7, rule7);
parse.AssignFinalRule(0, new BaseRule <Expr>(Sequence <Expr> .Empty, initReg, 0));
var comp = utf8decode.Compose(parse);
//utf8decode.ToST().ShowGraph();
//parse.ToST().ShowGraph();
//comp.ToST().ShowGraph();
//var comp1 = new STbSimulator<FuncDecl,Expr,Sort>(comp);
//comp1.Explore();
//Console.WriteLine(comp1.exploredSteps);
//var rules = Array.ConvertAll(comp1.UncoveredMoves.ToArray(), r => new Tuple<int, int>(r.Item3.SourceState, r.Item3.TargetState));
var simpl = comp.Simplify();
Assert.AreEqual <int>(35, comp.StateCount);
Assert.AreEqual <int>(7, simpl.StateCount);
//simpl.ShowGraph();
}
public void TestSTbSimplify()
{
string utf8decode_bek = @"
function fuse(r,c) = ((r << 6) | (c & 0x3F));
function one(c) = ((0 <= c) && (c <= 0x7F));
function C2_DF(c) = ((0xC2 <= c) && (c <= 0xDF));
function E1_EF(c) = ((0xE1 <= c) && (c <= 0xEF));
function A0_BF(c) = ((0xA0 <= c) && (c <= 0xBF));
function x80_BF(c) = ((0x80 <= c) && (c <= 0xBF));
function x80_9F(c) = ((0x80 <= c) && (c <= 0x9F));
program utf8decode(input){
return iter(c in input)[q := 0; r := 0;]
{
case (q == 0):
if (one(c)) {yield (c);}
else if (C2_DF(c)) {q := 2; r := (c & 0x1F);} // ------ 2 bytes --------
else if (c == 0xE0) {q := 4; r := (c & 0x0F);} // ------ 3 bytes --------
else if (c == 0xED) {q := 5; r := (c & 0x0F);} // ------ 3 bytes --------
else if (E1_EF(c)) {q := 3; r := (c & 0x0F);} // ------ 3 bytes --------
else {raise InvalidInput;}
case (q == 2):
if (x80_BF(c)) {q := 0; yield(fuse(r,c)); r := 0;}
else {raise InvalidInput;}
case (q == 3):
if (x80_BF(c)) {q := 2; r := fuse(r,c);}
else {raise InvalidInput;}
case (q == 4):
if (A0_BF(c)) {q := 2; r := fuse(r,c);}
else {raise InvalidInput;}
case (q == 5):
if (x80_9F(c)) {q := 2; r := fuse(r,c);}
else {raise InvalidInput;}
end case (!(q == 0)):
raise InvalidInput;
};
}
";
Z3Provider solver = new Z3Provider(BitWidth.BV16);
var dec = BekConverter.BekToSTb(solver, utf8decode_bek);
var utf8decode = dec.ExploreBools();
Sort bv32 = solver.MkBitVecSort(32);
Sort outSort = solver.MkTupleSort(solver.StringSort, bv32);
var initReg = solver.MkTuple(solver.GetNil(solver.StringSort), solver.MkNumeral(0,bv32));
var regVar = solver.MkVar(1,outSort);
var reg1 = solver.MkProj(1, regVar);
var reg0 = solver.MkProj(0, regVar);
STb<FuncDecl, Expr, Sort> parse = new STbModel(solver, "Parse", solver.CharacterSort, outSort, outSort, initReg, 0);
var letter = solver.MkOr(//solver.MkAnd(solver.MkCharLe(solver.MkCharExpr('\xC0'), solver.CharVar),
// solver.MkCharLe(solver.CharVar, solver.MkCharExpr('\xFF'))),
solver.MkAnd(solver.MkCharLe(solver.MkCharExpr('a'), solver.CharVar),
solver.MkCharLe(solver.CharVar, solver.MkCharExpr('z'))),
solver.MkAnd(solver.MkCharLe(solver.MkCharExpr('A'), solver.CharVar),
solver.MkCharLe(solver.CharVar, solver.MkCharExpr('Z'))));
//var not_letter = solver.MkNot(letter);
var digit = solver.MkAnd(solver.MkCharLe(solver.MkCharExpr('0'), solver.CharVar),
solver.MkCharLe(solver.CharVar, solver.MkCharExpr('9')));
var nl = solver.MkEq(solver.CharVar, solver.MkCharExpr('\n'));
var space = solver.MkEq(solver.CharVar, solver.MkCharExpr(' '));
//var not_nl = solver.MkNot(nl);
var _0 = solver.MkNumeral((int)'0', bv32);
//var z = solver.Z3.MkFreshConst("z", solver.CharacterSort);
//var constr = solver.MkNot(solver.Z3.MkExists(new Expr[] { z }, nl.Substitute(solver.CharVar, z)));
////var constr = nl.Substitute(solver.CharVar, z);
//solver.Z3S.Push();
//solver.Z3S.Assert((BoolExpr)solver.MkNot(constr));
//var status = solver.Check();
//var m = solver.Z3S.Model;
//var zval = m.Evaluate(z, true);
//solver.Z3S.Pop();
var loop_0 = new BaseRule<Expr>(Sequence<Expr>.Empty, regVar, 0);
var brule0_1 = new BaseRule<Expr>(Sequence<Expr>.Empty, solver.MkTuple(solver.MkListCons(solver.CharVar, reg0), reg1), 1);
var rule0 = new IteRule<Expr>(letter, brule0_1, new IteRule<Expr>(space, loop_0, UndefRule<Expr>.Default));
parse.AssignRule(0, rule0);
var brule1_2 = new BaseRule<Expr>(Sequence<Expr>.Empty, solver.MkTuple(solver.MkListCons(solver.CharVar, reg0), reg1), 2);
var brule_4 = new BaseRule<Expr>(Sequence<Expr>.Empty, regVar, 4);
var rule1 = new IteRule<Expr>(letter, brule1_2, new IteRule<Expr>(space, brule_4, UndefRule<Expr>.Default));
parse.AssignRule(1, rule1);
var brule2_3 = new BaseRule<Expr>(Sequence<Expr>.Empty, solver.MkTuple(solver.MkListCons(solver.CharVar, reg0), reg1), 4);
var rule2 = new IteRule<Expr>(letter, brule2_3, new IteRule<Expr>(space, brule_4, UndefRule<Expr>.Default));
parse.AssignRule(2, rule2);
var bv32var = solver.Z3.MkZeroExt(16, (BitVecExpr)solver.CharVar);
var brule4_5 = new BaseRule<Expr>(Sequence<Expr>.Empty, solver.MkTuple(reg0, solver.MkBvAdd(
solver.MkBvMul(solver.MkNumeral(10,bv32),reg1),
solver.MkBvSub(bv32var,_0))),5);
var rule4 = new IteRule<Expr>(digit, brule4_5, new IteRule<Expr>(space, brule_4, UndefRule<Expr>.Default));
parse.AssignRule(4, rule4);
var brule_0 = new BaseRule<Expr>(Sequence<Expr>.Empty.Append(regVar), initReg, 0);
var brule_7 = new BaseRule<Expr>(Sequence<Expr>.Empty, regVar, 7);
var brule5_6 = new BaseRule<Expr>(Sequence<Expr>.Empty, solver.MkTuple(reg0, solver.MkBvAdd(
solver.MkBvMul(solver.MkNumeral(10, bv32), reg1),
solver.MkBvSub(bv32var, _0))), 6);
var rule5 = new IteRule<Expr>(digit, brule5_6, new IteRule<Expr>(nl, brule_0, new IteRule<Expr>(space, brule_7, UndefRule<Expr>.Default)));
parse.AssignRule(5, rule5);
var brule6_7 = new BaseRule<Expr>(Sequence<Expr>.Empty, solver.MkTuple(reg0, solver.MkBvAdd(
solver.MkBvMul(solver.MkNumeral(10, bv32), reg1),
solver.MkBvSub(bv32var, _0))), 7);
var rule6 = new IteRule<Expr>(digit, brule6_7, new IteRule<Expr>(nl, brule_0, new IteRule<Expr>(space, brule_7, UndefRule<Expr>.Default)));
parse.AssignRule(6, rule6);
var rule7 = new IteRule<Expr>(nl, brule_0, new IteRule<Expr>(space, brule_7, UndefRule<Expr>.Default));
parse.AssignRule(7, rule7);
parse.AssignFinalRule(0, new BaseRule<Expr>(Sequence<Expr>.Empty, initReg, 0));
var comp = utf8decode.Compose(parse);
//utf8decode.ToST().ShowGraph();
//parse.ToST().ShowGraph();
//comp.ToST().ShowGraph();
//var comp1 = new STbSimulator<FuncDecl,Expr,Sort>(comp);
//comp1.Explore();
//Console.WriteLine(comp1.exploredSteps);
//var rules = Array.ConvertAll(comp1.UncoveredMoves.ToArray(), r => new Tuple<int, int>(r.Item3.SourceState, r.Item3.TargetState));
var simpl = comp.Simplify();
Assert.AreEqual<int>(35, comp.StateCount);
Assert.AreEqual<int>(7, simpl.StateCount);
//simpl.ShowGraph();
}
// This function is called every editor gui update. In here we are diong our magic to show all to the user in a nice way.
public override void OnInspectorGUI()
{
//Setting styles
if ( _descBoxStyle == null)
{
_descBoxStyle = new GUIStyle(GUI.skin.FindStyle("Box"));
_descBoxStyle.alignment = TextAnchor.UpperLeft;
_descBoxStyle.normal.textColor = Color.white;
_descBoxStyle.stretchWidth = true;
_bigBoxStyle = new GUIStyle(GUI.skin.FindStyle("Box"));
_bigBoxStyle.alignment = TextAnchor.UpperLeft;
_bigBoxStyle.normal.textColor = Color.white;
_bigBoxStyle.stretchHeight = true;
_bigBoxStyle.normal.background = (Texture2D) Resources.Load("SourceBack");
_popupStyle = new GUIStyle(GUI.skin.FindStyle("Popup"));
_popupStyle.fontStyle = (FontStyle.Normal);
_popupStyle.stretchHeight = true;
}
EditorGUIUtility.LookLikeInspector();
serializedObject.Update(); // update the serialized object since the last time this method was called.
BaseAction myTarget = (BaseAction)target;
myTarget.UpdateInspector();
SerializedProperty script = serializedObject.FindProperty("m_Script");
EditorGUILayout.PropertyField(script, new GUIContent("Script",myTarget.GetActionDescription()));
//Show first public visible fields with the Attribute "ShowAtfirst"
SerializedProperty prop = serializedObject.GetIterator();
prop.NextVisible(true );
do
{
if (ShouldShowFirst(prop))
{
EditorGUILayout.PropertyField(prop,true);
}
} while (prop.NextVisible(false ));
//then show Triggers
Rect rect = EditorGUILayout.BeginVertical();
GUI.Box (rect,"",_bigBoxStyle);
if (myTarget.IsSupportCustomTriggers())
{
GUILayout.Space(5);
// Add Trigger row - Combo-box + Add Button
Rect addTriggerRect = EditorGUILayout.BeginHorizontal();
{
if (_triggerToAdd != null)
{
// If user pressed on "Add" button - add the selected trigger to the action's supported triggers
_supportedTriggers.InsertArrayElementAtIndex(0);
_supportedTriggers.GetArrayElementAtIndex(0).objectReferenceValue = myTarget.AddHiddenComponent(_triggerToAdd);
((Trigger)_supportedTriggers.GetArrayElementAtIndex(0).objectReferenceValue).CleanRules();
_triggerToAdd = null;
}
GUILayout.Box("Add Triger", _popupStyle );
var evt = Event.current;
if (evt.type == EventType.mouseDown)
{
//Getting all Triggers
List<System.Type> possibleTriggers = myTarget.GetSupprtedTriggers();
var mousePos = evt.mousePosition;
if (addTriggerRect.Contains (mousePos))
{
// Now create the menu, add items and show it
var menu = new GenericMenu ();
for (int i = 0; i < possibleTriggers.Count; i++)
{
string triggerFriendlyName = "";
if (!_friendlyNames.ContainsKey(possibleTriggers[i].FullName))
{
GameObject g = new GameObject("temp");
Trigger triggerTemp = (Trigger) g.AddComponent(possibleTriggers[i]);
_friendlyNames.Add(possibleTriggers[i].FullName, triggerTemp.FriendlyName);
DestroyImmediate(g);
}
triggerFriendlyName = _friendlyNames[possibleTriggers[i].FullName];
menu.AddItem(new GUIContent(triggerFriendlyName), false, AddTrigger, possibleTriggers[i]);
}
menu.ShowAsContext ();
evt.Use();
}
}
}
EditorGUILayout.EndHorizontal();
}
// go over all the Action's supported triggers and add them to the inspector.
for (int i =0; i < _supportedTriggers.arraySize; i++)
{
//Get Trigger and update rules
Trigger trigger = (Trigger)_supportedTriggers.GetArrayElementAtIndex(i).objectReferenceValue;
if (trigger == null)
{
((BaseAction)target).InitializeSupportedTriggers();
EditorGUILayout.EndVertical();
return;
}
// Trigger Row - Foldout + Reset trigger button + Delete trigger
Rect triggerRect = EditorGUILayout.BeginHorizontal();
{
trigger.FoldoutOpen = GUIUtils.Foldout(trigger.FoldoutOpen, trigger.FriendlyName);
if (trigger.FoldoutOpen)
{
List<System.Type> supprtedRules1 = trigger.GetSupportedRules();
Rect rectRuleAddButton = EditorGUILayout.BeginHorizontal();
GUILayout.Box("Add", _popupStyle, GUILayout.Width(50) );
EditorGUILayout.EndHorizontal();
GUILayout.FlexibleSpace();
var evt = Event.current;
if (evt.type == EventType.mouseDown)
{
var mousePos = evt.mousePosition;
if (rectRuleAddButton.Contains (mousePos))
{
// Now create the menu, add items and show it
var menu1 = new GenericMenu ();
for (int ri = 0; ri < supprtedRules1.Count(); ri++)
{
string ruleFriendlyName = "";
if (!_friendlyNames.ContainsKey(supprtedRules1[ri].FullName))
{
GameObject g = new GameObject("temp");
BaseRule ruleTemp = (BaseRule)g.AddComponent(supprtedRules1[ri]);
_friendlyNames.Add(supprtedRules1[ri].FullName, ruleTemp.FriendlyName);
DestroyImmediate(g);
}
ruleFriendlyName = _friendlyNames[supprtedRules1[ri].FullName];
menu1.AddItem (new GUIContent (ruleFriendlyName), false, AddRule, supprtedRules1[ri]);
}
menu1.ShowAsContext ();
evt.Use();
_triggerToAddRuleTo = trigger;
}
}
}
}
EditorGUILayout.EndHorizontal();
SetTriggersContextMenu(triggerRect, myTarget, trigger);
// show trigger's rules if opened
if (trigger.FoldoutOpen)
{
SerializedObject obj = new SerializedObject(_supportedTriggers.GetArrayElementAtIndex(i).objectReferenceValue);
SerializedProperty rules = obj.FindProperty("Rules");
if (true)
{
// Add Trigger row - Combo-box + Add Button
EditorGUILayout.BeginHorizontal();
{
//Adding combo-box control to the inspector with the list of triggers.
if ( _triggerToAddRuleTo == trigger && _ruleToAdd != null)
{
// If user pressed on "Add" button - add the selected trigger to the action's supported triggers
rules.InsertArrayElementAtIndex(0);
rules.GetArrayElementAtIndex(0).objectReferenceValue = myTarget.AddHiddenComponent(_ruleToAdd);
// initialize rules
_ruleToAdd = null;
_triggerToAddRuleTo = null;
}
}
EditorGUILayout.EndHorizontal();
GUILayout.Space(5);
}
for (int j = 0; j < rules.arraySize; j++)
{
BaseRule rule = (BaseRule)rules.GetArrayElementAtIndex(j).objectReferenceValue;
DrawRuleInspector(rule);
//Reset Rule
if (_ruleToReset != null && _ruleToReset == rule)
{
rule.ActionOwner = null;
rules.GetArrayElementAtIndex(j).objectReferenceValue = myTarget.AddHiddenComponent(_ruleToReset.GetType());
// Save folded state
((BaseRule)rules.GetArrayElementAtIndex(j).objectReferenceValue).FoldoutOpen = rule.FoldoutOpen;
_ruleToReset = null;
}
//Remove Rule
if (_ruleToRemove != null && _ruleToRemove == rule)
{
// delete the trigger and reorganize the array
var r = rules.GetArrayElementAtIndex(j).objectReferenceValue;
rules.DeleteArrayElementAtIndex(j);
((BaseRule)r).ActionOwner = null;
for (int k = j; k < rules.arraySize - 1; k++)
{
rules.MoveArrayElement(k+1, k);
}
rules.arraySize--;
_ruleToRemove = null;
}
}
//Save changes to the rule
obj.ApplyModifiedProperties();
}
// Reset Trigger
if (_triggerToReset != null && _triggerToReset == trigger)
{
trigger.ActionOwner = null;
foreach (BaseRule r in trigger.Rules)
{
r.ActionOwner = null;
}
_supportedTriggers.GetArrayElementAtIndex(i).objectReferenceValue = myTarget.AddHiddenComponent(trigger.GetType());
Trigger oldTrigger = trigger;
trigger = (Trigger)_supportedTriggers.GetArrayElementAtIndex(i).objectReferenceValue;
trigger.CleanRules();
//trigger.SetDefaults(myTarget);
myTarget.SetDefaultTriggerValues(i, trigger);
// Save folded state
trigger.FoldoutOpen = oldTrigger.FoldoutOpen;
_triggerToReset = null;
break;
}
// Remove Trigger
if (_triggerToRemove != null && _triggerToRemove == trigger)
{
// delete the trigger and reorganize the array
_supportedTriggers.DeleteArrayElementAtIndex(i);
trigger.ActionOwner = null;
if (trigger.Rules != null)
{
foreach (BaseRule r in trigger.Rules)
{
if (r != null)
{
r.ActionOwner = null;
}
}
}
for (int j = i; j < _supportedTriggers.arraySize - 1; j++)
{
_supportedTriggers.MoveArrayElement(j+1, j);
}
_supportedTriggers.arraySize--;
break;
}
}
EditorGUILayout.Space();
EditorGUILayout.EndVertical();
// Draw the rest of the control except several predefined fields or the fields which are marked as show first
prop = serializedObject.GetIterator();
prop.NextVisible(true );
do
{
if (prop.name != "m_Script" && !ShouldShowFirst(prop))
{
EditorGUILayout.PropertyField(prop,true);
}
} while (prop.NextVisible(false ));
//Save changes to the Action Script
serializedObject.ApplyModifiedProperties ();
}
/// <summary>
/// Sets the rules context menu (add, remove, etc.)
/// </summary>
/// <param name='contextRect'>
/// Context active rectangle for mouse click
/// </param>
/// <param name='rule'>
/// Rule in question
/// </param>
private void SetRulesContextMenu(Rect contextRect, BaseRule rule)
{
var evt = Event.current;
if (evt.type == EventType.ContextClick)
{
var mousePos = evt.mousePosition;
if (contextRect.Contains (mousePos))
{
// Now create the menu, add items and show it
var menu = new GenericMenu ();
menu.AddItem (new GUIContent ("Reset"), false, ResetRule, rule);
menu.AddItem (new GUIContent ("Remove"), false, RemoveRule, rule);
menu.ShowAsContext ();
evt.Use();
}
}
}
/// <summary>
/// Set the Rule to reset.
/// </summary>
/// <param name='obj'>
/// Object - rule to reset. Must derive from BaseRule.
/// </param>
private void ResetRule(object obj)
{
_ruleToReset = (BaseRule)obj;
}
STModel ConvertReplace(replace repl)
{
//create a disjunction of all the regexes
//each case terminated by the identifier
int K = 0; //max pattern length
//HashSet<int> finalReplacers = new HashSet<int>();
//for efficieny keep lookup tables of character predicates to sets
Dictionary <Expr, BDD> predLookup = new Dictionary <Expr, BDD>();
Automaton <BDD> previouspatterns = Automaton <BDD> .MkEmpty(css);
Automaton <BV2> N = Automaton <BV2> .MkFull(css2);
var hasNoEndAnchor = new HashSet <int>();
for (int i = 0; i < repl.CaseCount; i++)
{
replacecase rcase = repl.GetCase(i);
var pat = "^" + rcase.Pattern.val;
var M = css.Convert("^" + rcase.Pattern.val, System.Text.RegularExpressions.RegexOptions.Singleline).Determinize().Minimize();
#region check that the pattern is a feasible nonempty sequence
if (M.IsEmpty)
{
throw new BekParseException(string.Format("Semantic error: pattern {0} is infeasible.", rcase.Pattern.ToString()));
}
int _K;
if (!M.CheckIfSequence(out _K))
{
throw new BekParseException(string.Format("Semantic error: pattern {0} is not a sequence.", rcase.Pattern.ToString()));
}
if (_K == 0)
{
throw new BekParseException(string.Format("Semantic error: empty pattern {0} is not allowed.", rcase.Pattern.ToString()));
}
K = Math.Max(_K, K);
#endregion
var liftedMoves = new List <Move <BV2> >();
var st = M.InitialState;
var newFinalState = M.MaxState + 1;
var endAnchor = css.MkCharConstraint((char)i);
//lift the moves to BV2 moves, adding end-markers
while (!M.IsFinalState(st))
{
var mv = M.GetMoveFrom(st);
var pair_cond = new BV2(mv.Label, css.False);
var liftedMove = new Move <BV2>(mv.SourceState, mv.TargetState, pair_cond);
liftedMoves.Add(liftedMove);
if (M.IsFinalState(mv.TargetState))
{
var end_cond = new BV2(css.False, endAnchor);
if (M.IsLoopState(mv.TargetState))
{
hasNoEndAnchor.Add(i);
//var loop_cond = css2.MkNot(end_cond);
//var loopMove = new Move<BV2>(mv.TargetState, mv.TargetState, loop_cond);
//liftedMoves.Add(loopMove);
}
var endMove = new Move <BV2>(mv.TargetState, newFinalState, end_cond);
liftedMoves.Add(endMove);
}
st = mv.TargetState;
}
var N_i = Automaton <BV2> .Create(css2, M.InitialState, new int[] { newFinalState }, liftedMoves);
//Microsoft.Automata.Visualizer.ToDot(N_i, "N" + i , "C:\\Automata\\Docs\\Papers\\Bex\\N" + i +".dot", x => "(" + css.PrettyPrint(x.First) + "," + css.PrettyPrint(x.Second) + ")");
N = N.Intersect(N_i.Complement());
#region other approach: disallow overlapping patterns
//Visualizer.ShowGraph(M2.Complement(css2), "M2", lab => { return "<" + css.PrettyPrint(lab.First) + "," + css.PrettyPrint(lab.Second) + ">"; });
//note: keep here the original pattern, add only the start anchor to synchronize prefixes
//var thispattern = css.Convert("^" + rcase.Pattern.val, System.Text.RegularExpressions.RegexOptions.Singleline).Determinize(css).Minimize(css);
//var thispattern1 = thispattern.Minus(previouspatterns, css);
//Visualizer.ShowGraph(thispattern1, "test", css.PrettyPrint);
//#region check that thispattern does not overlap with any previous pattern
//var common = thispattern.Intersect(previouspatterns, css);
//if (!(common.IsEmpty))
//{
// int j = 0;
// while ((j < i) && css.Convert("^" + repl.GetCase(j).Pattern.val,
// System.Text.RegularExpressions.RegexOptions.Singleline).Determinize(css).Intersect(thispattern, css).IsEmpty)
// j++;
// throw new BekParseException(rcase.id.line, rcase.id.pos, string.Format("Semantic error: pattern {0} overlaps pattern {1}.",
// rcase.Pattern.ToString(), repl.GetCase(j).Pattern.ToString()));
//}
//previouspatterns = previouspatterns.Union(thispattern).RemoveEpsilons(css.MkOr); //TBD: better union
//#endregion
#endregion
}
N = N.Complement().Minimize();
//Microsoft.Automata.Visualizer.ShowGraph(N, "N", x => "<" + css.PrettyPrint(x.First) + "," + css.PrettyPrint(x.Second) + ">");
//Microsoft.Automata.Visualizer.ToDot(N, "N","C:\\Automata\\Docs\\Papers\\Bex\\N.dot", x => "(" + css.PrettyPrint(x.First) + "," + css.PrettyPrint(x.Second) + ")");
var D = new Dictionary <int, int>();
var G = new Dictionary <int, BDD>();
#region compute distance from initial state and compute guard unions
var S = new Stack <int>();
D[N.InitialState] = 0;
G[N.InitialState] = css.False;
S.Push(N.InitialState);
while (S.Count > 0)
{
var q = S.Pop();
foreach (var move in N.GetMovesFrom(q))
{
G[q] = css.MkOr(G[q], move.Label.Item1);
var p = move.TargetState;
var d = D[q] + 1;
if (!(N.IsFinalState(p)) && !D.ContainsKey(p))
{
D[p] = d;
G[p] = css.False;
S.Push(p);
}
if (!(N.IsFinalState(p)) && D[p] != d)
{
throw new BekException(string.Format("Unexpected error, inconsitent distances {0} and {1} to state {2}", D[p], d, p));
}
}
}
#endregion
#region check that outputs do not have out of bound variables
foreach (var fs in N.GetFinalStates())
{
foreach (var move in N.GetMovesTo(fs))
{
if (move.Label.Item2.IsEmpty)
{
throw new BekException("Internal error: missing end anchor");
}
//if (!css.IsSingleton(move.Condition.Second))
//{
// var one = (int)css.GetMin(move.Condition.Second);
// var two = (int)css.GetMax(move.Condition.Second);
// throw new BekParseException(repl.GetCase(two).id.line, repl.GetCase(two).id.pos, string.Format("Ambiguous replacement patterns {0} and {1}.", repl.GetCase(one).Pattern, repl.GetCase(two).Pattern));
//}
//pick the minimum case identifer when there are several, essentially pick the earliest case
int id = (int)css.GetMin(move.Label.Item2);
int distFromRoot = D[move.SourceState];
var e = repl.GetCase(id).Output;
HashSet <int> vars = new HashSet <int>();
foreach (var v in e.GetBoundVars())
{
if (v.GetVarId() >= distFromRoot)
{
throw new BekParseException(v.line, v.pos, string.Format("Syntax error: pattern variable '{0}' is out ouf bounds, valid range is from '#0' to '#{1}']", v.name, distFromRoot - 1));
}
}
}
}
#endregion
int finalState = N.FinalState;
K = K - 1; //this many registers are needed
var zeroChar = stb.Solver.MkCharExpr('\0');
var STmoves = new List <Move <Rule <Expr> > >();
var STstates = new HashSet <int>();
var STdelta = new Dictionary <int, List <Move <Rule <Expr> > > >();
var STdeltaInv = new Dictionary <int, List <Move <Rule <Expr> > > >();
var FinalSTstates = new HashSet <int>();
var STdeletedMoves = new HashSet <Move <Rule <Expr> > >();
Action <Move <Rule <Expr> > > STmovesAdd = r =>
{
var p = r.SourceState;
var q = r.TargetState;
STmoves.Add(r);
if (STstates.Add(p))
{
STdelta[p] = new List <Move <Rule <Expr> > >();
STdeltaInv[p] = new List <Move <Rule <Expr> > >();
}
if (STstates.Add(q))
{
STdelta[q] = new List <Move <Rule <Expr> > >();
STdeltaInv[q] = new List <Move <Rule <Expr> > >();
}
if (r.Label.IsFinal)
{
FinalSTstates.Add(p);
}
STdelta[p].Add(r);
STdeltaInv[q].Add(r);
};
var regsorts = new Sort[K];
for (int j = 0; j < K; j++)
{
regsorts[j] = stb.Solver.CharSort;
}
var regsort = stb.Solver.MkTupleSort(regsorts);
var regvar = stb.MkRegister(regsort);
var initialRegisterValues = new Expr[K];
for (int j = 0; j < K; j++)
{
initialRegisterValues[j] = zeroChar;
}
var initialRegister = stb.Solver.MkTuple(initialRegisterValues);
Predicate <int> IsCaseEndState = s => { return(N.OutDegree(s) == 1 && N.GetMoveFrom(s).Label.Item1.IsEmpty); };
#region compute the forward moves and the completion moves
var V = new HashSet <int>();
S.Push(N.InitialState);
while (S.Count > 0)
{
var p = S.Pop();
#region forward moves
foreach (var move in N.GetMovesFrom(p))
{
var q = move.TargetState;
//this move occurs if p has both an end-move and a non-end-move
//note that if p is an case-end-state then it is never pushed to S
if (N.IsFinalState(q))
{
continue;
}
var distance = D[p];
Expr chExpr;
Expr chPred;
MkExprPred(move.Label.Item1, out chExpr, out chPred);
predLookup[chPred] = move.Label.Item1;
Expr[] regUpds = new Expr[K];
for (int i = 0; i < K; i++)
{
if (i == distance)
{
regUpds[i] = chExpr;
}
else //if (i < distance)
{
regUpds[i] = stb.Solver.MkProj(i, regvar);
}
//else
// regUpds[i] = zeroChar;
}
Expr regExpr = stb.Solver.MkTuple(regUpds);
var moveST = stb.MkRule(p, q, chPred, regExpr); //there are no yields
STmovesAdd(moveST);
if (V.Add(q) && !IsCaseEndState(q))
{
S.Push(q);
}
}
#endregion
#region completion is only enabled if there exists an else case
if (repl.HasElseCase)
{
var guards = G[p];
var guards0 = G[N.InitialState];
#region nonmatching cases to the initial state
var nomatch = css.MkNot(css.MkOr(guards, guards0));
if (!nomatch.IsEmpty)
{
Expr chExpr;
Expr nomatchPred;
MkExprPred(nomatch, out chExpr, out nomatchPred);
predLookup[nomatchPred] = nomatch;
var else_yields_list = new List <Expr>();
for (int i = 0; i < D[p]; i++)
{
else_yields_list.AddRange(GetElseYieldInstance(repl.ElseOutput, stb.Solver.MkProj(i, regvar)));
}
else_yields_list.AddRange(GetElseYieldInstance(repl.ElseOutput, stb.MkInputVariable(stb.Solver.CharSort)));
var else_yields = else_yields_list.ToArray();
var resetMove = stb.MkRule(p, N.InitialState, nomatchPred, initialRegister, else_yields);
STmovesAdd(resetMove);
}
#endregion
#region matching cases via the initial state
foreach (var move0 in N.GetMovesFrom(N.InitialState))
{
var g0 = move0.Label.Item1;
var match = css.MkAnd(css.MkNot(guards), g0);
if (!match.IsEmpty)
{
Expr chExpr;
Expr matchPred;
MkExprPred(match, out chExpr, out matchPred);
predLookup[matchPred] = match;
var resetYieldsList = new List <Expr>();
//for all unprocessed inputs produce the output yield according to the else case
for (int i = 0; i < D[p]; i++)
{
resetYieldsList.AddRange(GetElseYieldInstance(repl.ElseOutput, stb.Solver.MkProj(i, regvar)));
}
var resetYields = resetYieldsList.ToArray();
Expr[] regupd = new Expr[K];
regupd[0] = chExpr;
for (int j = 1; j < K; j++)
{
regupd[j] = zeroChar;
}
var regupdExpr = stb.Solver.MkTuple(regupd);
var resetMove = stb.MkRule(p, move0.TargetState, matchPred, regupdExpr, resetYields);
STmovesAdd(resetMove);
}
}
#endregion
}
#endregion
}
#endregion
foreach (var last_move in N.GetMovesTo(N.FinalState))
{
//i is the case identifier
int i = (int)css.GetMin(last_move.Label.Item2);
if (hasNoEndAnchor.Contains(i))
{
#region this corresponds to looping back to the initial state on the given input
//the final outputs produced after a successful pattern match
#region compute the output terms
int distFromRoot = D[last_move.SourceState];
Func <ident, Expr> registerMap = id =>
{
// --- already checked I think ---
if (!id.IsVar || id.GetVarId() >= distFromRoot)
{
throw new BekParseException(id.Line, id.Pos, string.Format("illeagal variable '{0}' in output", id.name));
}
if (id.GetVarId() == distFromRoot - 1) //the last reg update refers to the current variable
{
return(stb.MkInputVariable(stb.Solver.CharSort));
}
else
{
return(stb.Solver.MkProj(id.GetVarId(), regvar));
}
};
Expr[] yields;
var outp = repl.GetCase(i).Output;
if (outp is strconst)
{
var s = ((strconst)outp).val;
yields = Array.ConvertAll(s.ToCharArray(),
c => this.str_handler.iter_handler.expr_handler.Convert(new charconst("'" + StringUtility.Escape(c) + "'"), registerMap));
}
else //must be an explicit list construct
{
if (!(outp is functioncall) || !((functioncall)outp).id.name.Equals("string"))
{
throw new BekParseException("Invalid pattern output.");
}
var s = ((functioncall)outp).args;
yields = Array.ConvertAll(s.ToArray(),
e => this.str_handler.iter_handler.expr_handler.Convert(e, registerMap));
}
#endregion
//shortcut all the incoming transitions to the initial state
foreach (var move in STdeltaInv[last_move.SourceState])
{
//go to the initial state, i.e. the matching raps around
int p = move.SourceState;
int q0 = N.InitialState;
List <Expr> yields1 = new List <Expr>(move.Label.Yields); //incoming yields are
yields1.AddRange(yields);
var rule = stb.MkRule(p, q0, move.Label.Guard, initialRegister, yields1.ToArray());
STmovesAdd(rule);
//STdeletedMoves.Add(move);
STmoves.Remove(move); //the move has been replaced
}
#endregion
}
else
{
#region this is the end of the input stream case
#region compute the output terms
int distFromRoot = D[last_move.SourceState];
Func <ident, Expr> registerMap = id =>
{
if (!id.IsVar || id.GetVarId() >= distFromRoot)
{
throw new BekParseException(id.Line, id.Pos, string.Format("illeagal variable '{0}' in output", id.name));
}
return(stb.Solver.MkProj(id.GetVarId(), regvar));
};
Expr[] yields;
var outp = repl.GetCase(i).Output;
if (outp is strconst)
{
var s = ((strconst)outp).val;
yields = Array.ConvertAll(s.ToCharArray(),
c => this.str_handler.iter_handler.expr_handler.Convert(new charconst("'" + c.ToString() + "'"), registerMap));
}
else //must be an explicit list construct
{
if (!(outp is functioncall) || !((functioncall)outp).id.name.Equals("string"))
{
throw new BekParseException("Invalid pattern output.");
}
var s = ((functioncall)outp).args;
yields = Array.ConvertAll(s.ToArray(),
e => this.str_handler.iter_handler.expr_handler.Convert(e, registerMap));
}
#endregion
int p = last_move.SourceState;
var rule = stb.MkFinalOutput(p, stb.Solver.True, yields);
STmovesAdd(rule);
#endregion
}
}
if (repl.HasElseCase)
{
#region final completion (upon end of input) for all non-final states
foreach (var p in STstates)
{
if (!FinalSTstates.Contains(p) && !IsCaseEndState(p)) //there is no final rule for p, so add the default one
{
Expr[] finalYields;
finalYields = new Expr[D[p]];
for (int i = 0; i < finalYields.Length; i++)
{
finalYields[i] = stb.Solver.MkProj(i, regvar);
}
var p_finalMove = stb.MkFinalOutput(p, stb.Solver.True, finalYields);
STmovesAdd(p_finalMove);
}
}
#endregion
}
else
{
//in this case there is a final rule from the initial state
var q0_finalMove = stb.MkFinalOutput(N.InitialState, stb.Solver.True);
STmovesAdd(q0_finalMove);
}
var resST = stb.MkST(name, initialRegister, stb.Solver.CharSort, stb.Solver.CharSort, regsort, N.InitialState, STmoves);
var resSTb = new STModel(stb.Solver, name, stb.Solver.CharSort, stb.Solver.CharSort, regsort, initialRegister, N.InitialState);
//create STb from the moves, we use here the knowledge that the ST is deterministic
//we also use the lookuptable of conditions to eliminate dead code
//resST.ShowGraph();
//resST.ToDot("C:\\Automata\\Docs\\Papers\\Bex\\B.dot");
#region compute the rules of the resulting STb
//V.Clear();
//S.Push(resST.InitialState);
//V.Add(resST.InitialState);
foreach (var st in resST.GetStates())
{
var condUnion = css.False;
var st_moves = new List <Move <Rule <Expr> > >();
foreach (var move in resST.GetNonFinalMovesFrom(st))
{
condUnion = css.MkOr(condUnion, predLookup[move.Label.Guard]);
st_moves.Add(move);
}
BranchingRule <Expr> st_rule;
if (st_moves.Count > 0)
{
//collect all rules with singleton guards and put them into a switch statement
var st_rules1 = new List <KeyValuePair <Expr, BranchingRule <Expr> > >();
var st_moves2 = new List <Move <Rule <Expr> > >();
foreach (var move in st_moves)
{
if (css.ComputeDomainSize(predLookup[move.Label.Guard]) == 1)
{
var v = stb.Solver.MkNumeral(css.Choose(predLookup[move.Label.Guard]), stb.Solver.CharSort);
var r = new BaseRule <Expr>(new Sequence <Expr>(move.Label.Yields),
move.Label.Update, move.TargetState);
st_rules1.Add(new KeyValuePair <Expr, BranchingRule <Expr> >(v, r));
}
else
{
st_moves2.Add(move);
}
}
BranchingRule <Expr> defaultcase = new UndefRule <Expr>("reject");
//make st_moves2 into an ite rule
if (st_moves2.Count > 0)
{
for (int j = st_moves2.Count - 1; j >= 0; j--)
{
var r = new BaseRule <Expr>(new Sequence <Expr>(st_moves2[j].Label.Yields),
st_moves2[j].Label.Update, st_moves2[j].TargetState);
if (j == (st_moves2.Count - 1) && condUnion.IsFull)
{
defaultcase = r;
}
else
{
defaultcase = new IteRule <Expr>(st_moves2[j].Label.Guard, r, defaultcase);
}
}
}
else if (condUnion.IsFull)
{
defaultcase = st_rules1[st_rules1.Count - 1].Value;
st_rules1.RemoveAt(st_rules1.Count - 1);
}
if (st_rules1.Count == 0)
{
st_rule = defaultcase;
}
else
{
st_rule = new SwitchRule <Expr>(stb.MkInputVariable(stb.Solver.CharSort), defaultcase, st_rules1.ToArray());
}
}
else
{
st_rule = new UndefRule <Expr>("reject");
}
resSTb.AssignRule(st, st_rule);
var st_finalrules = new List <Rule <Expr> >(resST.GetFinalRules(st));
if (st_finalrules.Count > 1)
{
throw new BekException("Unexpected error: multiple final rules per state.");
}
if (st_finalrules.Count > 0)
{
resSTb.AssignFinalRule(st, new BaseRule <Expr>(new Sequence <Expr>(st_finalrules[0].Yields), initialRegister, st));
}
}
resSTb.ST = resST;
resST.STb = resSTb;
#endregion
return(resSTb);
}
/// <summary>
/// Set the rule to remove
/// </summary>
/// <param name='obj'>
/// Object - rule to remove. Must derive from BaseRule.
/// </param>
private void RemoveRule(object obj)
{
_ruleToRemove = (BaseRule)obj;
}
