public void CreateConditional(List <Parser.IfStatement.Clause> clauses, Block block, Dictionary <string, Yarn.Parser.Node> nodes, Dictionary <string, Block> blocks)
{
/**
* NOTES:
* - clause.expression will be null if it's an else statement
* - refer to DialogueRunner for examples of parsing
*/
for (int i = 0; i < clauses.Count; i++)
{
Parser.IfStatement.Clause clause = clauses[i];
//if the expression is null, it is an else statement
if (clause.expression == null)
{
Else elseStatement = currentFlowchartObj.AddComponent <Else>();
block.CommandList.Add(elseStatement);
}
// if the clause is the first entry in clauses, then it is an if statement
else if (i == 0)
{
If ifstatement = currentFlowchartObj.AddComponent <If>();
block.CommandList.Add(ifstatement);
if (clause.expression.function != null)
{
//it is an operator statement
switch (clause.expression.function.name)
{
case "LessThanOrEqualTo":
ifstatement.SetCompareOperator(CompareOperator.LessThanOrEquals);
break;
case "GreaterThanOrEqualTo":
ifstatement.SetCompareOperator(CompareOperator.GreaterThanOrEquals);
break;
case "LessThan":
ifstatement.SetCompareOperator(CompareOperator.LessThan);
break;
case "GreaterThan":
ifstatement.SetCompareOperator(CompareOperator.GreaterThan);
break;
case "EqualTo":
ifstatement.SetCompareOperator(CompareOperator.Equals);
break;
case "NotEqualTo":
ifstatement.SetCompareOperator(CompareOperator.NotEquals);
break;
default:
Debug.LogError("NEW FUNCTION NAME: " + clause.expression.function.name);
break;
}
Flowchart currFlowchart = currentFlowchartObj.GetComponent <Flowchart>();
Parser.Expression secondExpression = clause.expression.parameters[1];
switch (secondExpression.value.value.type)
{
case Value.Type.String:
StringVariable sv = null;
if (currFlowchart.GetVariable <StringVariable>(clause.expression.parameters[0].value.value.GetVariableName()) == null)
{
sv = currentFlowchartObj.AddComponent <StringVariable>();
sv.Scope = VariableScope.Public;
sv.Key = clause.expression.parameters[0].value.value.GetVariableName();
sv.Value = "";
currFlowchart.AddVariable(sv);
currFlowchart.SetStringVariable(sv.Key, "");
}
else
{
sv = currFlowchart.GetVariable <StringVariable>(clause.expression.parameters[0].value.value.GetVariableName());
}
StringDataMulti data = new StringDataMulti();
data.stringVal = secondExpression.value.value.GetStringValue();
ifstatement.SetVariable(sv);
ifstatement.SetStringData(data);
break;
case Value.Type.Number:
FloatVariable fv = null;
if (currFlowchart.GetVariable <FloatVariable>(clause.expression.parameters[0].value.value.GetVariableName()) == null)
{
fv = currentFlowchartObj.AddComponent <FloatVariable>();
fv.Scope = VariableScope.Public;
fv.Key = clause.expression.parameters[0].value.value.GetVariableName();
fv.Value = 0;
currFlowchart.AddVariable(fv);
currFlowchart.SetFloatVariable(fv.Key, 0);
}
else
{
fv = currFlowchart.GetVariable <FloatVariable>(clause.expression.parameters[0].value.value.GetVariableName());
}
FloatData fdata = new FloatData();
fdata.floatVal = secondExpression.value.value.GetNumberValue();
ifstatement.SetVariable(fv);
ifstatement.SetFloatData(fdata);
break;
case Value.Type.Bool:
BooleanVariable bv = null;
if (currFlowchart.GetVariable <BooleanVariable>(clause.expression.parameters[0].value.value.GetVariableName()) == null)
{
bv = currentFlowchartObj.AddComponent <BooleanVariable>();
bv.Scope = VariableScope.Public;
bv.Key = clause.expression.parameters[0].value.value.GetVariableName();
bv.Value = false;
currFlowchart.AddVariable(bv);
currFlowchart.SetBooleanVariable(bv.Key, false);
}
else
{
bv = currFlowchart.GetVariable <BooleanVariable>(clause.expression.parameters[0].value.value.GetVariableName());
}
BooleanData bdata = new BooleanData();
bdata.booleanVal = secondExpression.value.value.GetBoolValue();
ifstatement.SetVariable(bv);
ifstatement.SetBooleanData(bdata);
break;
default:
Debug.LogError("Unknown Parser Value Type");
break;
}
}
}
//otherwise, it's an elseif statement
else
{
ElseIf ifstatement = currentFlowchartObj.AddComponent <ElseIf>();
block.CommandList.Add(ifstatement);
if (clause.expression.function != null)
{
//it is an operator statement
switch (clause.expression.function.name)
{
case "LessThanOrEqualTo":
ifstatement.SetCompareOperator(CompareOperator.LessThanOrEquals);
break;
case "GreaterThanOrEqualTo":
ifstatement.SetCompareOperator(CompareOperator.GreaterThanOrEquals);
break;
case "LessThan":
ifstatement.SetCompareOperator(CompareOperator.LessThan);
break;
case "GreaterThan":
ifstatement.SetCompareOperator(CompareOperator.GreaterThan);
break;
case "EqualTo":
ifstatement.SetCompareOperator(CompareOperator.Equals);
break;
case "NotEqualTo":
ifstatement.SetCompareOperator(CompareOperator.NotEquals);
break;
default:
Debug.LogError("NEW FUNCTION NAME: " + clause.expression.function.name);
break;
}
Flowchart currFlowchart = currentFlowchartObj.GetComponent <Flowchart>();
Parser.Expression secondExpression = clause.expression.parameters[1];
switch (secondExpression.value.value.type)
{
case Value.Type.String:
StringVariable sv = null;
if (currFlowchart.GetVariable <StringVariable>(clause.expression.parameters[0].value.value.GetVariableName()) == null)
{
sv = currentFlowchartObj.AddComponent <StringVariable>();
sv.Scope = VariableScope.Public;
sv.Key = clause.expression.parameters[0].value.value.GetVariableName();
sv.Value = "";
currFlowchart.AddVariable(sv);
currFlowchart.SetStringVariable(sv.Key, "");
}
else
{
sv = currFlowchart.GetVariable <StringVariable>(clause.expression.parameters[0].value.value.GetVariableName());
}
StringDataMulti data = new StringDataMulti();
data.stringVal = secondExpression.value.value.GetStringValue();
ifstatement.SetVariable(sv);
ifstatement.SetStringData(data);
break;
case Value.Type.Number:
FloatVariable fv = null;
if (currFlowchart.GetVariable <FloatVariable>(clause.expression.parameters[0].value.value.GetVariableName()) == null)
{
fv = currentFlowchartObj.AddComponent <FloatVariable>();
fv.Scope = VariableScope.Public;
fv.Key = clause.expression.parameters[0].value.value.GetVariableName();
fv.Value = 0;
currFlowchart.AddVariable(fv);
currFlowchart.SetFloatVariable(fv.Key, 0);
}
else
{
fv = currFlowchart.GetVariable <FloatVariable>(clause.expression.parameters[0].value.value.GetVariableName());
}
FloatData fdata = new FloatData();
fdata.floatVal = secondExpression.value.value.GetNumberValue();
ifstatement.SetVariable(fv);
ifstatement.SetFloatData(fdata);
break;
case Value.Type.Bool:
BooleanVariable bv = null;
if (currFlowchart.GetVariable <BooleanVariable>(clause.expression.parameters[0].value.value.GetVariableName()) == null)
{
bv = currentFlowchartObj.AddComponent <BooleanVariable>();
bv.Scope = VariableScope.Public;
bv.Key = clause.expression.parameters[0].value.value.GetVariableName();
bv.Value = false;
currFlowchart.AddVariable(bv);
currFlowchart.SetBooleanVariable(bv.Key, false);
}
else
{
bv = currFlowchart.GetVariable <BooleanVariable>(clause.expression.parameters[0].value.value.GetVariableName());
}
BooleanData bdata = new BooleanData();
bdata.booleanVal = secondExpression.value.value.GetBoolValue();
ifstatement.SetVariable(bv);
ifstatement.SetBooleanData(bdata);
break;
default:
Debug.LogError("Unknown Parser Value Type");
break;
}
}
}
//Parse the statements once you figure out what kind of if-else to use
ParseNodeHelper(clause.statements, block, nodes, blocks);
}
//Put in an end-if
End end = currentFlowchartObj.AddComponent <End>();
block.CommandList.Add(end);
}
internal override void TryAlt(ref Worker wr, int i, Cont <T> aK, Else aE)
{
Spin:
var state = this.State;
Reconsider:
if (state > Running)
{
goto Completed;
}
if (state < Delayed)
{
goto Spin;
}
var check = state;
state = Interlocked.CompareExchange(ref this.State, state - MakeLocked, state);
if (Delayed == state)
{
goto Delayed;
}
if (state != check)
{
goto Reconsider;
}
WaitQueue.AddTaker(ref this.Readers, i, aE.pk, aK);
this.State = Running;
aE.TryElse(ref wr, i + 1);
return;
Delayed:
var readers = this.Readers;
this.Readers = null;
this.State = Running;
var fulfill = readers as Fulfill;
fulfill.reader = aK;
fulfill.me = i;
fulfill.pk = aE.pk;
Worker.PushNew(ref wr, fulfill);
aE.TryElse(ref wr, i + i);
return;
Completed:
var pkSelf = aE.pk;
TryPick:
var stSelf = Pick.TryPick(pkSelf);
if (stSelf > 0)
{
goto AlreadyPicked;
}
if (stSelf < 0)
{
goto TryPick;
}
Pick.SetNacks(ref wr, i, pkSelf);
if (state == HasValue)
{
Cont.Do(aK, ref wr, this.Value);
}
else
{
aK.DoHandle(ref wr, (this.Readers as Fail <T>).exn);
}
AlreadyPicked:
return;
}
internal override void TryAlt(ref Worker wr, int i, Cont <T> xK, Else xE)
{
var pkSelf = xE.pk;
this.Lock.Enter();
var tail = this.Givers;
if (null == tail)
{
goto TryTaker;
}
Send <T> cache = null;
var cursor = tail.Next;
TryGiver:
var giver = cursor as Giver <T>;
Pick pkOther = null;
if (null != giver)
{
goto Giver;
}
TryPick:
var st = Pick.TryPick(pkSelf);
if (st > 0)
{
goto AlreadyPicked;
}
if (st < 0)
{
goto TryPick;
}
WaitQueue.RemoveRange(ref this.Givers, cursor);
this.Lock.Exit();
Pick.SetNacks(ref wr, i, pkSelf);
Cont.Do(xK, ref wr, cursor.Value);
return;
AlreadyPicked:
WaitQueue.RemoveRangeInclusive(this.Givers, cursor);
this.Lock.Exit();
return;
Giver:
cursor = cursor.Next;
pkOther = giver.Pick;
if (null == pkOther)
{
goto TryPickSelf;
}
if (pkOther == pkSelf)
{
goto OtherIsSelf;
}
TryPickOther:
var stOther = Pick.TryClaim(pkOther);
if (stOther > 0)
{
goto TryNextGiver;
}
if (stOther < 0)
{
goto TryPickOther;
}
TryPickSelf:
var stSelf = Pick.TryPick(pkSelf);
if (stSelf > 0)
{
goto SelfAlreadyPicked;
}
if (stSelf < 0)
{
goto BackOff;
}
//GotGiver:
WaitQueue.RemoveRange(ref this.Givers, giver);
this.Lock.Exit();
if (null != pkOther)
{
Pick.PickClaimedAndSetNacks(ref wr, giver.Me, pkOther);
}
Pick.SetNacks(ref wr, i, pkSelf);
Worker.Push(ref wr, giver.Cont);
Cont.Do(xK, ref wr, giver.Value);
return;
BackOff:
if (null == pkOther)
{
goto TryPickSelf;
}
Pick.Unclaim(pkOther);
goto TryPickOther;
OtherIsSelf:
WaitQueue.Enqueue(ref cache, giver);
if (giver != tail)
{
goto TryGiver;
}
this.Givers = cache;
goto TryTaker;
TryNextGiver:
if (giver != tail)
{
goto TryGiver;
}
this.Givers = cache;
TryTaker:
WaitQueue.AddTaker(ref this.Takers, i, pkSelf, xK);
this.Lock.Exit();
xE.TryElse(ref wr, i + 1);
return;
SelfAlreadyPicked:
if (null != pkOther)
{
Pick.Unclaim(pkOther);
}
WaitQueue.RemoveRangeInclusive(this.Givers, giver);
this.Lock.Exit();
return;
}
internal override void TryAlt(ref Worker wr, int i, Cont <X> xK, Else xE)
{
Handler.DoHandle(xK, ref wr, e);
}
internal WithNackCont(Cont <X> xK, Else xE)
{
this.xK = xK;
this.xE = xE;
}
internal override void TryAlt(ref Worker wr, int i, Cont <X> xK, Else xE)
{
xE.TryElse(ref wr, i);
}
public override Expression CloneExpressionOnly()
{
ConditionExpression result = new ConditionExpression(Condition.CloneExpressionOnly(), Then.CloneExpressionOnly(), Else.CloneExpressionOnly(), null);
return(result);
}
public override Expr UnEx()
{
Temp.Temp r = new Temp.Temp();
Label join = new Label();
Label t = new Label();
Label f = new Label();
return(new ESEQ(new SEQ(Test.UnCx(t, f),
new SEQ(new LABEL(t),
new SEQ(new MOVE(new TEMP(r), Then.UnEx()),
new SEQ(new JUMP(join),
new SEQ(new LABEL(f),
new SEQ(new MOVE(new TEMP(r), Else.UnEx()),
new LABEL(join))))))),
new TEMP(r)));
}
public string Visit(Else node)
{
return(VisitChildren(node));
}
public Node If()
{
var result = new If()
{
AnchorToken = Expect(TokenCategory.IF)
};
result.Add(Expression());
Expect(TokenCategory.THEN);
if (firstOfStatement.Contains(CurrentToken))
{
var statementList = new StatementList();
while (firstOfStatement.Contains(CurrentToken))
{
statementList.Add(Statement());
}
result.Add(statementList);
}
var elseIfList = new ElseIfList();
if (CurrentToken == TokenCategory.ELSEIF)
{
while (CurrentToken == TokenCategory.ELSEIF)
{
var elseIf = new ElseIf()
{
AnchorToken = Expect(TokenCategory.ELSEIF)
};
elseIf.Add(Expression());
Expect(TokenCategory.THEN);
if (firstOfStatement.Contains(CurrentToken))
{
var statementList = new StatementList();
while (firstOfStatement.Contains(CurrentToken))
{
statementList.Add(Statement());
}
elseIf.Add(statementList);
}
elseIfList.Add(elseIf);
}
}
result.Add(elseIfList);
var els = new Else();
if (CurrentToken == TokenCategory.ELSE)
{
els.AnchorToken = Expect(TokenCategory.ELSE);
if (firstOfStatement.Contains(CurrentToken))
{
var statementList = new StatementList();
while (firstOfStatement.Contains(CurrentToken))
{
statementList.Add(Statement());
}
els.Add(statementList);
}
}
result.Add(els);
Expect(TokenCategory.END);
Expect(TokenCategory.SEMICOLON);
return(result);
}
internal PrepareAltCont(int i, Cont <X> xK, Else xE)
{
this.i = i;
this.xK = xK;
this.xE = xE;
}
Stmt stmt()
{
Expr x;
Stmt s, s1, s2;
Stmt savedStmt;
Stmt stmtResult;
switch (look.tag)
{
case ';':
{
move();
//return Stmt.Null;
stmtResult = Stmt.Null;
break;
}
case Tag.IF:
{
match(Tag.IF);
match('(');
x = bool_expr();
match(')');
s1 = stmt();
if (look.tag != Tag.ELSE)
{
return(new If(x, s1, compileRows));
}
match(Tag.ELSE);
s2 = stmt();
//return new Else(x, s1, s2);
stmtResult = new Else(x, s1, s2, compileRows);
break;
}
case Tag.WHILE:
{
While whilenode = new While(compileRows);
savedStmt = Stmt.Enclosing;
Stmt.Enclosing = whilenode;
match(Tag.WHILE);
match('(');
x = bool_expr();
match(')');
s1 = stmt();
whilenode.init(x, s1);
Stmt.Enclosing = savedStmt;
//return whilenode;
stmtResult = whilenode;
break;
}
case Tag.DO:
{
Do donode = new Do(compileRows);
savedStmt = Stmt.Enclosing;
Stmt.Enclosing = donode;
match(Tag.DO);
s1 = stmt();
match(Tag.WHILE);
match('(');
x = bool_expr();
match(')');
match(';');
donode.init(s1, x);
Stmt.Enclosing = savedStmt;
//return donode;
stmtResult = donode;
break;
}
case Tag.BREAK:
{
match(Tag.BREAK);
match(';');
//return new Break();
stmtResult = new Break(compileRows);
break;
}
case '{':
return(block());
default:
//return assign();
stmtResult = assign();
break;
}
/*
* for(int i = 0;i< stmtResult.rows.Count;i++)
* {
* compileRows.Add(stmtResult.rows[i]);
* }
*/
return(stmtResult);
}
internal InsertElseIfBeforeElseCommand(If iif, ElseIf newElseIf, Else existedElse)
{
this.If = iif;
this.InsertedElseIf = newElseIf;
this.ExistedElse = existedElse;
}
public void Visit(Else node)
{
}
public override void Optimize()
{
Expression = Expression.Reduce();
Body.Optimize();
Else.Optimize();
}
/// <summary>
/// Converts an object to a <see cref="JsonValue"/>.
/// </summary>
/// <param name="serializer">The <see cref="JsonSerializer"/> instance to use for additional
/// serialization of values.</param>
/// <returns>The <see cref="JsonValue"/> representation of the object.</returns>
public virtual JsonValue ToJson(JsonSerializer serializer)
{
if (BooleanSchemaDefinition != null)
{
return(BooleanSchemaDefinition);
}
serializer = serializer ?? _schemaSerializer;
var json = new JsonObject();
if (!string.IsNullOrWhiteSpace(Schema))
{
json["$schema"] = Schema;
}
if (Id != null)
{
json["$id"] = Id;
}
if (Comment != null)
{
json["$comment"] = Comment;
}
if (Title != null)
{
json["title"] = Title;
}
if (!string.IsNullOrWhiteSpace(Description))
{
json["description"] = Description;
}
if (Definitions != null)
{
json["definitions"] = Definitions.ToJson(serializer);
}
if (ReadOnly.HasValue)
{
json["readOnly"] = ReadOnly;
}
if (Type != JsonSchemaType.NotDefined)
{
var array = Type.ToJson();
if (array.Type == JsonValueType.Array)
{
array.Array.EqualityStandard = ArrayEquality.ContentsEqual;
}
json["type"] = array;
}
if (Properties != null)
{
json["properties"] = Properties.ToJson(serializer);
}
if (Maximum.HasValue)
{
json["maximum"] = Maximum;
}
if (ExclusiveMaximum.HasValue)
{
json["exclusiveMaximum"] = ExclusiveMaximum;
}
if (Minimum.HasValue)
{
json["minimum"] = Minimum;
}
if (ExclusiveMinimum.HasValue)
{
json["exclusiveMinimum"] = ExclusiveMinimum;
}
if (MultipleOf.HasValue)
{
json["multipleOf"] = MultipleOf;
}
if (MaxLength.HasValue)
{
json["maxLength"] = MaxLength;
}
if (MinLength.HasValue)
{
json["minLength"] = MinLength;
}
if (Pattern != null)
{
json["pattern"] = Pattern;
}
if (AdditionalItems != null)
{
json["additionalItems"] = AdditionalItems.ToJson(serializer);
}
if (Items != null)
{
json["items"] = Items.ToJson(serializer);
}
if (MaxItems.HasValue)
{
json["maxItems"] = MinItems;
}
if (MinItems.HasValue)
{
json["minItems"] = MinItems;
}
if (UniqueItems ?? false)
{
json["uniqueItems"] = UniqueItems;
}
if (Contains != null)
{
json["contains"] = Contains.ToJson(serializer);
}
if (MaxProperties.HasValue)
{
json["maxProperties"] = MaxProperties;
}
if (MinProperties.HasValue)
{
json["minProperties"] = MinProperties;
}
if (Required != null)
{
json["required"] = Required.ToJson();
}
if (AdditionalProperties != null)
{
json["additionalProperties"] = AdditionalProperties.ToJson(serializer);
}
if (PatternProperties != null && PatternProperties.Any())
{
json["patternProperties"] = PatternProperties.ToDictionary(kvp => kvp.Key.ToString(), kvp => kvp.Value).ToJson(serializer);
}
if (Dependencies != null && Dependencies.Any())
{
var jsonDependencies = new JsonObject();
foreach (var dependency in Dependencies)
{
jsonDependencies[dependency.PropertyName] = dependency.GetJsonData();
}
json["dependencies"] = jsonDependencies;
}
if (PropertyNames != null)
{
json["propertyNames"] = PropertyNames.ToJson(serializer);
}
if (Const != null)
{
json["const"] = Const;
}
if (Enum != null)
{
var array = Enum.ToJson(serializer);
array.Array.EqualityStandard = ArrayEquality.ContentsEqual;
json["enum"] = Enum.ToJson(serializer);
}
if (Format != null)
{
json["format"] = Format.Key;
}
if (ContentMediaType != null)
{
json["contentMediaType"] = ContentMediaType;
}
if (ContentEncoding != null)
{
json["contentEncoding"] = serializer.Serialize(ContentEncoding);
}
if (If != null)
{
json["if"] = If.ToJson(serializer);
}
if (Then != null)
{
json["then"] = Then.ToJson(serializer);
}
if (Else != null)
{
json["else"] = Else.ToJson(serializer);
}
if (AllOf != null)
{
var array = AllOf.Select(s => s.ToJson(serializer)).ToJson();
array.EqualityStandard = ArrayEquality.ContentsEqual;
json["allOf"] = array;
}
if (AnyOf != null)
{
var array = AnyOf.Select(s => s.ToJson(serializer)).ToJson();
array.EqualityStandard = ArrayEquality.ContentsEqual;
json["anyOf"] = array;
}
if (OneOf != null)
{
var array = OneOf.Select(s => s.ToJson(serializer)).ToJson();
array.EqualityStandard = ArrayEquality.ContentsEqual;
json["oneOf"] = array;
}
if (Not != null)
{
json["not"] = Not.ToJson(serializer);
}
if (Default != null)
{
json["default"] = Default;
}
if (Examples != null)
{
json["examples"] = Examples;
}
if (ExtraneousDetails != null)
{
foreach (var kvp in ExtraneousDetails.Where(kvp => !_definedProperties.Contains(kvp.Key)))
{
json[kvp.Key] = kvp.Value;
}
}
return(json);
}
public Type Visit(Else node)
{
VisitChildren(node);
return(Type.VOID);
}
public void TestTerminals()
{
AssertSuccess(LBrace.Parse("{"), '{', true);
AssertSuccess(RBrace.Parse("}"), '}', true);
AssertSuccess(LParen.Parse("("), '(', true);
AssertSuccess(RParen.Parse(")"), ')', true);
AssertSuccess(Comma.Parse(","), ',', true);
AssertSuccess(UScore.Parse("_"), '_', true);
AssertSuccess(DQuote.Parse("\""), '"', true);
AssertSuccess(SQuote.Parse("'"), '\'', true);
AssertSuccess(Str.Parse("\"abc\""), "abc", true);
AssertSuccess(Chr.Parse("'a'"), "a", true);
AssertSuccess(ExprParser.Int.Parse("234"), "234", true);
AssertSuccess(Float.Parse("234.0"), "234.0", true);
AssertSuccess(Float.Parse(".0"), ".0", true);
AssertSuccess(Float.Parse("1e2"), "1e2", true);
AssertSuccess(Float.Parse("1E2"), "1E2", true);
AssertSuccess(Float.Parse("1E-2"), "1E-2", true);
AssertSuccess(Float.Parse("1E+2"), "1E+2", true);
AssertSuccess(Float.Parse("1.0E2"), "1.0E2", true);
AssertSuccess(Float.Parse("1.0E-2"), "1.0E-2", true);
AssertSuccess(Float.Parse("1.0E+2"), "1.0E+2", true);
AssertSuccess(IdStart.Parse("_"), '_', true);
AssertSuccess(IdStart.Parse("a"), 'a', true);
AssertSuccess(IdRest.Parse("_"), '_', true);
AssertSuccess(IdRest.Parse("1"), '1', true);
AssertSuccess(IdRest.Parse("_"), '_', true);
AssertSuccess(IdRest.Parse("a"), 'a', true);
AssertSuccess(Id.Parse("_"), "_", true);
AssertSuccess(Id.Parse("A"), "A", true);
AssertSuccess(Id.Parse("z"), "z", true);
AssertSuccess(Id.Parse("abc"), "abc", true);
AssertSuccess(Id.Parse("_abc"), "_abc", true);
AssertSuccess(Id.Parse("_1"), "_1", true);
AssertSuccess(Id.Parse("_1_a_zZ"), "_1_a_zZ", true);
AssertSuccess(Id.Parse("e"), "e", true);
AssertSuccess(Id.Parse("el"), "el", true);
AssertSuccess(Id.Parse("els"), "els", true);
AssertSuccess(Id.Parse("else1"), "else1", true);
AssertSuccess(Id.Parse("i"), "i", true);
AssertSuccess(Id.Parse("if1"), "if1", true);
AssertSuccess(Id.Parse("if_"), "if_", true);
AssertSuccess(Id.Parse("t"), "t", true);
AssertSuccess(Id.Parse("tr"), "tr", true);
AssertSuccess(True.Parse("true"), "true", true);
AssertSuccess(False.Parse("false"), "false", true);
AssertSuccess(If.Parse("if"), "if", true);
AssertSuccess(Else.Parse("else"), "else", true);
AssertSuccess(Then.Parse("then"), "then", true);
AssertSuccess(ExprParser.In.Parse("in"), "in", true);
AssertSuccess(Bool.Parse("true"), "true", true);
AssertSuccess(Bool.Parse("false"), "false", true);
AssertSuccess(Bool.Parse("\"true\""), "true", true);
AssertSuccess(Bool.Parse("\"false\""), "false", true);
AssertSuccess(KeyWords.Parse("else"), "else", true);
AssertSuccess(KeyWords.Parse("then"), "then", true);
AssertSuccess(KeyWords.Parse("if"), "if", true);
AssertSuccess(KeyWords.Parse("in "), "in", true);
}
public override Expression Clone()
{
ConditionExpression result = new ConditionExpression(Condition.Clone(), Then.Clone(), Else.Clone(), instructions);
return(result);
}
protected internal override MAst Transform()
{
return(MAst.Condition(Test.Transform(), Then.Transform(), Else.Transform()));
}
internal abstract void TryAlt(ref Worker wr, int i, Cont <T> xK, Else xE);
public virtual bool Visit(Else elseNode)
{
return(true);
}
internal WithNackElse(Nack nk, Else xE) : base(xE.pk)
{
this.nk = nk;
this.xE = xE;
}
internal override void TryAlt(ref Worker wr, int i, Cont <T> aK, Else aE)
{
var pkSelf = aE.pk;
Spin:
var state = this.State;
if (state > Running)
{
goto Completed;
}
if (state < Delayed)
{
goto Spin;
}
if (state != Interlocked.CompareExchange(ref this.State, ~state, state))
{
goto Spin;
}
if (Delayed == state)
{
goto Delayed;
}
WaitQueue.AddTaker(ref this.Readers, i, pkSelf, aK);
this.State = Running;
aE.TryElse(ref wr, i + 1);
return;
Delayed:
var taker = new Taker <T>();
taker.Cont = aK;
taker.Me = i;
taker.Pick = pkSelf;
taker.Next = taker;
var readers = this.Readers;
this.Readers = taker;
this.State = Running;
var fulfill = readers as Fulfill;
var tJ = fulfill.tP;
fulfill.tP = this;
Worker.PushNew(ref wr, new JobWork <T>(tJ, fulfill));
aE.TryElse(ref wr, i + i);
return;
Completed:
var stSelf = Pick.TryPick(pkSelf);
if (stSelf > 0)
{
goto AlreadyPicked;
}
if (stSelf < 0)
{
goto Completed;
}
Pick.SetNacks(ref wr, i, pkSelf);
if (state == HasValue)
{
Cont.Do(aK, ref wr, this.Value);
}
else
{
aK.DoHandle(ref wr, (this.Readers as Fail <T>).exn);
}
AlreadyPicked:
return;
}
internal override void TryAlt(ref Worker wr, int i, Cont <Y> yK, Else yE)
{
xA.TryAlt(ref wr, i, new ContBind(this, yK), yE);
}
/// <summary>
/// User-friendly representation as string.
/// </summary>
/// <returns></returns>
public override string ToString()
{
return($"{Condition.ToString()} ? {Then.ToString()} : {Else.ToString()}");
}
internal override void TryAlt(ref Worker wr, int i, Cont <Unit> uK, Else uE)
{
var pkSelf = uE.pk;
var ch = this.Ch;
ch.Lock.Enter();
var tail = ch.Takers;
if (null == tail)
{
goto TryGiver;
}
Cont <T> cache = null;
var cursor = tail.Next;
TryTaker:
var taker = cursor as Cont <T>;
cursor = cursor.Next;
int me = 0;
var pkOther = taker.GetPick(ref me);
if (null == pkOther)
{
goto TryPickSelf;
}
if (pkOther == pkSelf)
{
goto OtherIsSelf;
}
TryPickOther:
var stOther = Pick.TryClaim(pkOther);
if (stOther > 0)
{
goto TryNextTaker;
}
if (stOther < 0)
{
goto TryPickOther;
}
TryPickSelf:
var stSelf = Pick.TryPick(pkSelf);
if (stSelf > 0)
{
goto SelfAlreadyPicked;
}
if (stSelf < 0)
{
goto BackOff;
}
WaitQueue.RemoveRange(ref ch.Takers, taker);
ch.Lock.Exit();
if (null != pkOther)
{
Pick.PickClaimedAndSetNacks(ref wr, me, pkOther);
}
Pick.SetNacks(ref wr, i, pkSelf);
taker.Value = this.X;
Worker.Push(ref wr, taker);
Work.Do(uK, ref wr);
return;
BackOff:
if (null == pkOther)
{
goto TryPickSelf;
}
Pick.Unclaim(pkOther);
goto TryPickOther;
OtherIsSelf:
WaitQueue.Enqueue(ref cache, taker);
if (taker != tail)
{
goto TryTaker;
}
ch.Takers = cache;
goto TryGiver;
TryNextTaker:
if (taker != tail)
{
goto TryTaker;
}
ch.Takers = cache;
TryGiver:
WaitQueue.AddGiver(ref ch.Givers, this.X, i, pkSelf, uK);
ch.Lock.Exit();
uE.TryElse(ref wr, i + 1);
return;
SelfAlreadyPicked:
if (null != pkOther)
{
Pick.Unclaim(pkOther);
}
WaitQueue.RemoveRangeInclusive(ch.Takers, taker);
ch.Lock.Exit();
return;
}
public override bool ResolveNames()
{
return(Cond.ResolveNames() && Then.ResolveNames() && Else.ResolveNames());
}
public void Visit(Else node)
{
VisitChildren(node);
}
public Node If()
{
var ifToken = Expect(TokenCategory.IF);
var nodeIf = new If()
{
AnchorToken = ifToken
};
nodeIf.Add(Expression());
Expect(TokenCategory.THEN);
var stmtList = new StatementList();
while (firstOfStatement.Contains(CurrentToken))
{
stmtList.Add(Statement());
}
nodeIf.Add(stmtList);
while (CurrentToken == TokenCategory.ELSEIF)
{
var nodeElseIf = new ElseIf()
{
AnchorToken = Expect(TokenCategory.ELSEIF)
};
nodeElseIf.Add(Expression());
Expect(TokenCategory.THEN);
var stmtListElseIf = new StatementList();
while (firstOfStatement.Contains(CurrentToken))
{
stmtListElseIf.Add(Statement());
}
nodeElseIf.Add(stmtListElseIf);
nodeIf.Add(nodeElseIf);
}
while (CurrentToken == TokenCategory.ELSE)
{
var nodeElse = new Else()
{
AnchorToken = Expect(TokenCategory.ELSE)
};
var stmtListElse = new StatementList();
while (firstOfStatement.Contains(CurrentToken))
{
stmtListElse.Add(Statement());
}
nodeElse.Add(stmtListElse);
nodeIf.Add(nodeElse);
}
Expect(TokenCategory.END);
Expect(TokenCategory.ENDLINE);
return(nodeIf);
// var ifToken = Expect(TokenCategory.IF);
// var exprList = new ExpressionList();
// exprList.Add(Expression());
// var thenNode = new Then() {
// AnchorToken = Expect(TokenCategory.THEN)
// };
// var stmtList = new StatementList();
// while (firstOfStatement.Contains(CurrentToken)) {
// stmtList.Add(Statement());
// }
// if(CurrentToken == TokenCategory.ELSEIF) {
// while (CurrentToken == TokenCategory.ELSEIF) {
// var elseIf = new ElseIf() {
// AnchorToken = Expect(TokenCategory.ELSEIF)
// };
// exprList.Add(Expression());
// Console.WriteLine("Revisa then");
// var thenNodetwo = new Then() {
// AnchorToken = Expect(TokenCategory.THEN)
// };
// while (firstOfStatement.Contains(CurrentToken)) {
// stmtList.Add(Statement());
// }
// }
// }
// if(CurrentToken == TokenCategory.ELSE) {
// Expect(TokenCategory.ELSE);
// while (firstOfStatement.Contains(CurrentToken)) {
// stmtList.Add(Statement());
// }
// }
// Expect(TokenCategory.END);
// Expect(TokenCategory.ENDLINE);
// var result = new If() { exprList, stmtList };
// result.AnchorToken = ifToken;
// return result;
}
