private string GetIgnoreEvents(FsmModel model, VarNames varNames)
{
// Build state switch
var sb = new System.Text.StringBuilder();
int count = 0;
foreach (var state in model.states)
{
if (state.ignoreEvents.Count == 0)
{
continue;
}
count++;
sb.Append(ignoreEventsStateCaseTemplate
.Replace("{{name}}", varNames.stateNameToEnum[state.name])
.Replace("{{ignoreevents}}", GetStateIgnoreEvents(model, state, varNames))
.Replace("{{defaultbreak}}", ""));
}
if (count == 0)
{
return(PostIndent(ignoreEventsNoneTemplate, options.padding));
}
return(PostIndent(ignoreEventsTemplate
.Replace("{{states}}", sb.ToString()),
options.padding));
}
public void Unpack(BinaryReader reader)
{
Id = reader.ReadUInt32();
var num_varnames = reader.ReadUInt16();
for (uint i = 0; i < num_varnames; i++)
{
VarNames.Add(reader.ReadUnicodeString());
}
var num_vars = reader.ReadUInt16();
for (uint i = 0; i < num_vars; i++)
{
Vars.Add(reader.ReadUnicodeString());
}
var num_strings = reader.ReadUInt32();
for (uint i = 0; i < num_strings; i++)
{
Strings.Add(reader.ReadUnicodeString());
}
var num_comments = reader.ReadUInt32();
for (uint i = 0; i < num_comments; i++)
{
Comments.Add(reader.ReadUInt32());
}
Unknown = reader.ReadByte();
}
/// <summary>
/// VarDecl -> Type IdentifierList ; VarDecl |
/// FinalT Type IdT = NumT ; VarDecl |
/// ε
/// </summary>
private void VarDecl()
{
if (Token == Tokens.FinalT)
{
Match(Tokens.FinalT);
Type();
TableEntry entry = symbolTable.CreateTableEntry();
VarNames.Add(Lexeme);
Match(Tokens.IdT);
Match(Tokens.AssignOpT);
BpOffsetName = $"_bp-{Offset}";
symbolTable.ConvertEntryToConstant(entry);
Match(Tokens.NumT);
LocalVarsSize += Size;
Offset += Size;
Match(Tokens.SemiT);
VarDecl();
}
else if (Types.Contains(Token))
{
Type();
IdentifierList();
Match(Tokens.SemiT);
VarDecl();
}
}
private string GetImplementInterfaces(FsmModel model, VarNames varNames)
{
// This is gross, should add a list of interfaces and make it cleaner
var sb = new System.Text.StringBuilder();
bool addedPrefix = false;
if (options.enableIntrospectionSupport)
{
addedPrefix = true;
sb.Append(",\n");
PreIndent(sb, options.padding);
sb.Append("UnityFSMCodeGenerator.IFsmIntrospectionSupport");
}
if (options.enableDebugSupport)
{
if (!addedPrefix)
{
sb.Append(",\n");
}
if (options.enableIntrospectionSupport)
{
sb.Append(",\n");
}
PreIndent(sb, options.padding);
sb.Append("UnityFSMCodeGenerator.IFsmDebugSupport");
}
return(sb.ToString());
}
private string MakeMethodCall(FsmDelegateMethod _delegate, VarNames varNames)
{
var sb = new System.Text.StringBuilder();
sb.Append("context.");
sb.Append(varNames.interfaceContextCall[_delegate._interface]);
sb.Append(".");
sb.Append(varNames.methodInvoke[_delegate.method]);
return(sb.ToString());
}
private string GetIntrospectionSupport(FsmModel model, VarNames varNames)
{
if (!options.enableIntrospectionSupport)
{
return("");
}
var sb = new System.Text.StringBuilder();
var sb2 = new System.Text.StringBuilder();
// Make two dictionary initializer entries for introspection lookup
// { "Hung Up", "HungUp" },
// { "Hung Up", (object)State.HungUp},
//
for (int i = 0; i < model.states.Count; i++)
{
var state = model.states[i];
// { "Hung Up", "HungUp" },
PreIndent(sb, options.padding);
sb.Append("{ State.");
sb.Append(varNames.stateNameToEnum[state.name]);
sb.Append(", \"");
sb.Append(state.name);
sb.Append("\" },\n");
// { "Hung Up", (object)State.HungUp},
PreIndent(sb2, options.padding);
sb2.Append("{ \"");
sb2.Append(state.name);
sb2.Append("\", ");
sb2.Append("State.");
sb2.Append(varNames.stateNameToEnum[state.name]);
sb2.Append(" },\n");
}
var stateLookups = sb.ToString();
var stringToEnumState = sb2.ToString();
// Make list initializer of state names
sb = new System.Text.StringBuilder();
for (int i = 0; i < model.states.Count; i++)
{
var state = model.states[i];
PreIndent(sb, options.padding);
sb.Append("\"");
sb.Append(state.name);
sb.Append("\",\n");
}
return(PostIndent(introspectionSupportTemplate
.Replace("{{statelookups}}", stateLookups)
.Replace("{{stateenumlookup}}", stringToEnumState)
.Replace("{{statelist}}", sb.ToString()),
options.padding));
}
private string GetStartState(FsmModel model, VarNames varNames)
{
foreach (var state in model.states)
{
if (state.isStart)
{
return("public const State START_STATE = State." + varNames.stateNameToEnum[state.name]);
}
}
return("");
}
private string GetDebugSupport(FsmModel model, VarNames varNames)
{
if (!options.enableDebugSupport)
{
return("");
}
return(PostIndent(debugSupportTemplate,
//.Replace("{{statelookups}}", stateLookups)
options.padding));
}
private string GetDefaultContextInterfaces(FsmModel model, VarNames varNames)
{
var sb = new System.Text.StringBuilder();
foreach (var kvp in varNames.interfaceArgs)
{
sb.Append("public ");
sb.Append(kvp.Key.FullName);
sb.Append(" ");
sb.Append(varNames.interfaceContextCall[kvp.Key]);
sb.Append(" { get; set; }\n");
}
return(PostIndent(sb.ToString(), options.padding * 2, false));
}
private string GetStateIgnoreEvents(FsmModel model, FsmStateModel state, VarNames varNames)
{
var sb = new System.Text.StringBuilder();
int count = 0;
foreach (var ignore in state.ignoreEvents)
{
count++;
sb.Append(PostIndent(ignoreEventTrue
.Replace("{{event}}", varNames.eventNameToEnum[ignore.name]),
options.padding * 2, false));
}
return(sb.ToString());
}
private string GetDispatchOnExit(FsmModel model, VarNames varNames)
{
// Build state switch
var sb = new System.Text.StringBuilder();
foreach (var state in model.states)
{
sb.Append(dispatchStateCaseTemplate
.Replace("{{name}}", varNames.stateNameToEnum[state.name])
.Replace("{{methodcalls}}", GetDispatchMethodCalls(model, state, varNames, state.onExit)));
}
return(PostIndent(dispatchOnExitTemplate
.Replace("{{states}}", sb.ToString()),
options.padding));
}
private string GetStateInternalActions(FsmModel model, FsmStateModel state, VarNames varNames)
{
var sb = new System.Text.StringBuilder();
int count = 0;
foreach (var action in state.internalActions)
{
count++;
sb.Append(PostIndent(internalActionsEventTemplate
.Replace("{{event}}", varNames.eventNameToEnum[action.evt.name])
.Replace("{{methodcall}}", MakeMethodCall(action._delegate, varNames)),
options.padding * 2, false));
}
return(sb.ToString());
}
/// <summary>
/// IdentifierList -> IdT IdentifierListTail
/// </summary>
private void IdentifierList()
{
if (Token == Tokens.IdT)
{
TableEntry entry = symbolTable.CreateTableEntry();
BpOffsetName = $"_bp-{Offset}";
symbolTable.ConvertEntryToVariable(entry);
VarNames.Add(Lexeme);
LocalVarsSize += Size;
Offset += Size;
Match(Tokens.IdT);
IdentifierListTail();
}
else
{
ErrorHandler.LogError($"expected an identifier, found \"{Lexeme}\"");
}
}
private string GetSingleInternalSendEvent(FsmModel model, VarNames varNames)
{
// Build state switch
var sb = new System.Text.StringBuilder();
foreach (var state in model.states)
{
bool needDefaultBreak = false;
sb.Append(sendInternalEventStateCaseTemplate
.Replace("{{name}}", varNames.stateNameToEnum[state.name])
.Replace("{{transitions}}", GetTransitions(model, state, varNames, out needDefaultBreak))
.Replace("{{defaultbreak}}", needDefaultBreak ? PostIndent(defaultBreakEventHandlerTemplate, options.padding * 2, false) : ""));
}
return(PostIndent(sendInternalEventBaseTemplate
.Replace("{{states}}", sb.ToString()),
options.padding));
}
private string GetTransitions(FsmModel model, FsmStateModel state, VarNames varNames, out bool needDefaultBreak)
{
var sb = new System.Text.StringBuilder();
int count = 0;
foreach (var transition in state.transitions)
{
count++;
sb.Append(PostIndent(stateTransitionTemplate
.Replace("{{event}}", varNames.eventNameToEnum[transition.evt.name])
.Replace("{{tostate}}", varNames.stateNameToEnum[transition.to.name]),
options.padding * 2, false));
}
needDefaultBreak = count != model.events.Count;
return(sb.ToString());
}
/// <summary>
/// IdentifierListTail -> , IdT IdentifierListTail | ε
/// </summary>
private void IdentifierListTail()
{
if (Token == Tokens.CommaT)
{
Match(Tokens.CommaT);
TableEntry entry = symbolTable.CreateTableEntry();
BpOffsetName = $"_bp-{Offset}";
symbolTable.ConvertEntryToVariable(entry);
VarNames.Add(Lexeme);
LocalVarsSize += Size;
Offset += Size;
Match(Tokens.IdT);
if (Token == Tokens.IdT)
{
ErrorHandler.LogError("expected \",\" before next identifier");
}
IdentifierListTail();
}
}
private string GetNewDefaultContext(FsmModel model, VarNames varNames)
{
var sb = new System.Text.StringBuilder();
int count = 0;
foreach (var kvp in varNames.interfaceArgs)
{
PreIndent(sb, options.padding);
sb.Append(kvp.Key.FullName);
sb.Append(" ");
sb.Append(kvp.Value);
if (count != varNames.interfaceArgs.Count - 1)
{
sb.Append(",\n");
}
else
{
sb.Append(",");
}
count++;
}
var _params = sb.ToString();
sb = new System.Text.StringBuilder();
foreach (var kvp in varNames.interfaceArgs)
{
sb.Append(varNames.interfaceContextCall[kvp.Key]);
sb.Append(" = ");
sb.Append(kvp.Value);
sb.Append(", ");
}
var args = sb.ToString();
return(PostIndent(newDefaultContextTemplate
.Replace("{{params}}", _params)
.Replace("{{args}}", args),
options.padding));
}
private string GetIContext(FsmModel model, VarNames varNames)
{
var sb = new System.Text.StringBuilder();
for (int i = 0; i < model.context.requiredInterfaces.Count; i++)
{
var iface = model.context.requiredInterfaces[i];
PreIndent(sb, options.padding * 2);
sb.Append(iface.FullName);
sb.Append(" ");
sb.Append(varNames.interfaceContextCall[iface]);
sb.Append(" { get; }");
if (i + 1 != model.context.requiredInterfaces.Count)
{
sb.Append("\n");
}
}
return(sb.ToString());
}
private string GetHandleInternalActions(FsmModel model, VarNames varNames)
{
bool haveActions = false;
foreach (var state in model.states)
{
if (state.internalActions.Count > 0)
{
haveActions = true;
break;
}
}
if (!haveActions)
{
return(PostIndent(noInternalActionsTemplate, options.padding));
}
// Build state switch
var sb = new System.Text.StringBuilder();
foreach (var state in model.states)
{
if (state.internalActions.Count == 0)
{
continue;
}
sb.Append(internalActionsStateCaseTemplate
.Replace("{{name}}", varNames.stateNameToEnum[state.name])
.Replace("{{internalactions}}", GetStateInternalActions(model, state, varNames))
.Replace("{{defaultbreak}}", ""));
}
return(PostIndent(internalActionsTemplate
.Replace("{{states}}", sb.ToString()),
options.padding));
}
private string GetDispatchMethodCalls(FsmModel model, FsmStateModel state, VarNames varNames, List <FsmOnEnterExitModel> calls)
{
var sb = new System.Text.StringBuilder();
if (calls.Count > 0)
{
sb.Append("\n");
}
for (int i = 0; i < calls.Count; i++)
{
var call = calls[i];
PreIndent(sb, options.padding * 2);
sb.Append("context.");
sb.Append(varNames.interfaceContextCall[call._delegate._interface]);
sb.Append(".");
sb.Append(varNames.methodInvoke[call._delegate.method]);
sb.Append(";");
if (i != calls.Count - 1)
{
sb.Append("\n");
}
}
return(sb.ToString());
}
