public NodeFactory()
{
builtin["Anchor"] = new AnchorNode();
builtin["Appearance"] = new AppearanceNode();
builtin["Background"] = new BackgroundNode();
builtin["Box"] = new BoxNode();
builtin["Color"] = new ColorNode();
builtin["Cone"] = new ConeNode();
builtin["Coordinate"] = new CoordinateNode();
builtin["CoordinateInterpolator"] = new CoordinateInterpolatorNode();
builtin["Cylinder"] = new CylinderNode();
builtin["DirectionalLight"] = new DirectionalLightNode();
builtin["Extrusion"] = new ExtrusionNode();
builtin["Group"] = new GroupNode();
builtin["Collision"] = new CollisionNode();
builtin["Switch"] = new SwitchNode();
builtin["IndexedFaceSet"] = new IndexedFaceSetNode();
builtin["IndexedLineSet"] = new IndexedLineSetNode();
builtin["Material"] = new MaterialNode();
builtin["NavigationInfo"] = new NavigationInfoNode();
builtin["OrientationInterpolator"] = new OrientationInterpolatorNode();
builtin["Normal"] = new NormalNode();
builtin["PixelTexture"] = new PixelTextureNode();
builtin["PointLight"] = new PointLightNode();
builtin["PositionInterpolator"] = new PositionInterpolatorNode();
builtin["ScalarInterpolator"] = new ScalarInterpolationNode();
builtin["Shape"] = new ShapeNode();
builtin["Sphere"] = new SphereNode();
builtin["TextureCoordinate"] = new TextureCoordinateNode();
builtin["TimeSensor"] = new TimeSensorNode();
builtin["Transform"] = new TransformNode();
builtin["Viewpoint"] = new ViewpointNode();
builtin["WorldInfo"] = new WorldInfoNode();
}
public SwitchNode Switch()
{
var @switch = new SwitchNode();
this.Add(@switch);
return(@switch);
}
public static TreeNode GetAllTypeNode()
{
TypesB1Node nodeType = new TypesB1Node();
nodeType.Text = nodeType.KNXMainNumber + "." + nodeType.KNXSubNumber + " " + nodeType.Name;
nodeType.Nodes.Add(SwitchNode.GetTypeNode());
nodeType.Nodes.Add(BoolNode.GetTypeNoe());
nodeType.Nodes.Add(EnableNode.GetTypeNode());
nodeType.Nodes.Add(RampNode.GetTypeNode());
nodeType.Nodes.Add(AlarmNode.GetTypeNode());
nodeType.Nodes.Add(BinaryValueNode.GetTypeNode());
nodeType.Nodes.Add(StepNode.GetTypeNode());
nodeType.Nodes.Add(UpDownNode.GetTypeNode());
nodeType.Nodes.Add(OpenCloseNode.GetTypeNode());
nodeType.Nodes.Add(StartNode.GetTypeNode());
nodeType.Nodes.Add(StateNode.GetTypeNode());
nodeType.Nodes.Add(InvertNode.GetTypeNode());
nodeType.Nodes.Add(DimSendStyleNode.GetTypeNode());
nodeType.Nodes.Add(InputSourceNode.GetTypeNode());
nodeType.Nodes.Add(ResetNode.GetTypeNode());
nodeType.Nodes.Add(AckNode.GetTypeNode());
nodeType.Nodes.Add(TriggerNode.GetTypeNode());
nodeType.Nodes.Add(OccupancyNode.GetTypeNode());
nodeType.Nodes.Add(WindowDoorNode.GetTypeNode());
nodeType.Nodes.Add(LogicalFunctionNode.GetTypeNode());
nodeType.Nodes.Add(SceneABNode.GetTypeNode());
nodeType.Nodes.Add(ShutterBlindsModeNode.GetTypeNode());
nodeType.Nodes.Add(HeatCoolNode.GetTypeNode());
return(nodeType);
}
void GeneratePipes(SwitchNode switchNode)
{
switchNode.childs.ForEach((Node child) =>
{
float xdiff = Mathf.Abs(switchNode.coordinates.x - child.coordinates.x);
float ydiff = Mathf.Abs(switchNode.coordinates.y - child.coordinates.y);
int xcoeff = switchNode.coordinates.x - child.coordinates.x > 0 ? -1 : 1;
int ycoeff = switchNode.coordinates.y - child.coordinates.y > 0 ? -1 : 1;
for (int i = 1; i < xdiff; i++)
{
var horizontalPipe = Instantiate(pipeHorizontal) as GameObject;
horizontalPipe.transform.position = new Vector2(switchNode.coordinates.x + i * xcoeff, child.coordinates.y);
}
for (int i = 1; i < ydiff; i++)
{
var horizontalPipe = Instantiate(pipeVertical) as GameObject;
horizontalPipe.transform.position = new Vector2(child.coordinates.x, switchNode.coordinates.y + i * ycoeff);
}
if (child.GetType() == typeof(SwitchNode))
{
GeneratePipes((SwitchNode)child);
}
});
}
public void Accept(SwitchNode node)
{
table.EnterScope();
var endLabel = nextLabel();
node.Value.Visit(this);
for (int i = 0; i < node.Cases.Count; i++)
{
emit(node.Value.SourceLocation, InstructionType.Duplicate);
}
foreach (var case_ in node.Cases)
{
var falseLabel = nextLabel();
case_.C.Visit(this);
emit(case_.C.SourceLocation, InstructionType.BinaryOperation, (int)case_.BinaryOperation);
emit(case_.C.SourceLocation, InstructionType.JumpIfFalse, falseLabel);
case_.Stmt.Visit(this);
emit(node.Value.SourceLocation, InstructionType.Jump, endLabel);
emitLabel(case_.Stmt.SourceLocation, falseLabel);
}
node.Default.Visit(this);
emitLabel(node.SourceLocation, endLabel);
table.LeaveScope();
}
/// <summary>
/// Gets the switch node instance with given node name.
/// </summary>
/// <param name="name">The name of switch node.</param>
/// <returns>The switch node instance</returns>
/// <feature>http://tizen.org/feature/machine_learning.inference</feature>
/// <exception cref="NotSupportedException">Thrown when the feature is not supported.</exception>
/// <exception cref="ArgumentException">Thrown when the method failed due to an invalid parameter.</exception>
/// <since_tizen> 8 </since_tizen>
public SwitchNode GetSwitch(string name)
{
NNStreamer.CheckNNStreamerSupport();
/* Check the parameter */
if (string.IsNullOrEmpty(name))
{
throw NNStreamerExceptionFactory.CreateException(NNStreamerError.InvalidParameter, "Node name is invalid");
}
SwitchNode node;
if (_nodeList.ContainsKey(name))
{
if (_nodeList[name].Type != NodeType.Switch)
{
throw NNStreamerExceptionFactory.CreateException(NNStreamerError.InvalidParameter, name + " is not a switch node");
}
node = (SwitchNode)_nodeList[name];
}
else
{
node = new SwitchNode(name, this);
_nodeList.Add(name, node);
}
return(node);
}
public SwitchBuilder(SwitchNode switchnode)
{
node = switchnode;
DotDefinition = new List <IDotElement>();
CreateNode();
CreateEndNode();
CreateEdgeToFirstChildren();
CreateEdgeToNextSibling();
}
public static TreeNode GetAllActionNode()
{
TypesB1Node nodeAction = new TypesB1Node();
nodeAction.Text = nodeAction.KNXMainNumber + "." + nodeAction.KNXSubNumber + " " + nodeAction.Name;
nodeAction.Nodes.Add(SwitchNode.GetActionNode());
return(nodeAction);
}
protected override void VisitSwitch <TChoice>(SwitchNode <TChoice> switchNode)
{
AddNode(switchNode);
AddLink(switchNode, switchNode.DefaultCase, "Default");
foreach (var valueNodePair in switchNode.Cases)
{
AddLink(switchNode, valueNodePair.Value, Categories.NormalFlowEdge, valueNodePair.Key?.ToString() ?? "");
}
}
public override IDriverNode CreateDriverNode(IDriverContext ctx)
{
IDriverNode driverNode = null;
switch (ctx.NodeInstance.This2NodeTemplateNavigation.Key)
{
case "light-bulb-switch":
driverNode = new SwitchNode(ctx,
Accessory.Services[1].Characteristics.Single(a => a.Type == CharacteristicBase.OnType), Driver);
break;
case "light-bulb-brightness":
var brigthness = Accessory.CreateBrightness();
driverNode = new LightSwitch(ctx, Driver, brigthness);
break;
case "light-bulb-hue":
var hue = Accessory.CreateHue();
driverNode = new LightSwitch(ctx, Driver, hue);
break;
case "power-outlet-switch":
driverNode = new SwitchNode(ctx,
Accessory.Services[1].Characteristics.Single(a => a.Type == CharacteristicBase.OnType), Driver);
break;
case "contact-sensor":
driverNode = new BaseNode(ctx,
Accessory.Services[1].Characteristics
.Single(a => a.Type == CharacteristicBase.ContactSensorStateType), Driver);
break;
case "switch":
driverNode = new SwitchNode(ctx,
Accessory.Services[1].Characteristics.Single(a => a.Type == CharacteristicBase.OnType), Driver);
break;
case "temperature-sensor":
driverNode = new BaseNode(ctx,
Accessory.Services[1].Characteristics
.Single(a => a.Type == CharacteristicBase.CurrentTemperatureType), Driver);
break;
case "switch-status":
case "power-outlet-status":
case "light-bulb-status":
driverNode = new StateNode(ctx,
Accessory.Services[1].Characteristics.Single(a => a.Type == CharacteristicBase.OnType), Driver);
break;
}
return(driverNode);
}
private void __ProcessSwitchNode(IDNodeBase _node)
{
SwitchNode node = (SwitchNode)_node;
if (m_scenario.CheckSwitch(node.SwitchName))
{
m_scenario.AdvanceByNode(node.GetTrueNext());
}
else
{
m_scenario.AdvanceByNode(node.GetFalseNext());
}
}
private Statement ProcessSwitchStatement(SwitchNode node)
{
Expression condition = expressionBuilder.BuildExpression(node.Condition);
if (condition is MemberExpression)
{
condition = expressionBuilder.TransformMemberExpression((MemberExpression)condition);
}
SwitchStatement statement = new SwitchStatement(condition);
foreach (SwitchSectionNode switchSectionNode in node.Cases)
{
SwitchGroup group = new SwitchGroup();
foreach (StatementNode caseNode in switchSectionNode.Labels)
{
if (caseNode is CaseLabelNode)
{
CaseLabelNode labelNode = (CaseLabelNode)caseNode;
Expression labelValue = expressionBuilder.BuildExpression(labelNode.Value);
if (labelValue is MemberExpression)
{
labelValue = expressionBuilder.TransformMemberExpression((MemberExpression)labelValue);
}
group.AddCase(labelValue);
}
else
{
Debug.Assert(caseNode is DefaultLabelNode);
group.AddDefaultCase();
}
}
foreach (StatementNode statementNode in switchSectionNode.Statements)
{
Statement childStatement = BuildStatement(statementNode);
if (childStatement != null)
{
group.AddStatement(childStatement);
}
}
statement.AddSwitchGroup(group);
}
return(statement);
}
// Update is called once per frame
void Update()
{
if (!GameManager.IsGameRunning())
{
return;
}
if (this.IsOutOfCameraBounds())
{
DestroyAndNotify();
return;
}
if (nodeToVisit == null)
{
nodeToVisit = lastVisitedSwitchNode.GetNextNode();
}
if (nodeToVisit != null && (new Vector2(transform.position.x, transform.position.y) - nodeToVisit.coordinates).sqrMagnitude <= 0.1)
{
// check where to go
this.transform.position = nodeToVisit.coordinates;
if (nodeToVisit.GetType() == typeof(SwitchNode))
{
direction = ((SwitchNode)nodeToVisit).GetDirectionVector();
lastVisitedSwitchNode = (SwitchNode)nodeToVisit;
nodeToVisit = null;
}
else
{
BeerTag beerTag = TagResolver.GetTagByName(gameObject.tag);
GameObject houseSpriteObj = GameObject.Find("HouseNode#" + nodeToVisit.nodeId);
HouseHandler houseHandler = houseSpriteObj.GetComponent <HouseHandler>() as HouseHandler;
BeerTag houseBeerTag = houseHandler.getBeerTag();
if (beerTag == houseBeerTag)
{
houseHandler.addLiter();
houseHandler.CheckAndReset();
GameManager.UpdateScore(1);
}
DestroyAndNotify();
}
}
Vector2 translation = Time.deltaTime * beerSpeed * direction;
this.transform.Translate(translation);
}
private void AddNodeSwitch(ViewNode pNode)
{
if (null != pNode)
{
if ((MyConst.View.KnxPageType == pNode.Name) || (MyConst.Controls.KnxGroupBoxType == pNode.Name))
{
SwitchNode node = new SwitchNode();
//pNode.Nodes.Add(node);
this.cqpo.ExecuteCommand(new TreeNodeAdd(this.tvPage, pNode, node, -1));
NodeAddEventArgs arg = new NodeAddEventArgs();
arg.mPageNode = this.CurPageNode;
arg.mParentNode = pNode;
arg.mNode = node;
AddNodeNotify(node, arg);
}
}
}
public void Visit(SwitchNode switchNode)
{
switchNode.Value.Parent = switchNode;
switchNode.Value.Accept(this);
var loop = _currentLoop;
_currentLoop = LoopType.Case;
foreach (var switchCase in switchNode.Cases)
{
switchCase.Expression.Parent = switchNode;
switchCase.Expression.Accept(this);
switchCase.Expression.Parent = switchNode;
switchCase.Body.Accept(this);
}
if (switchNode.DefaultCase != null)
{
switchNode.DefaultCase.Parent = switchNode;
switchNode.DefaultCase.Accept(this);
}
_currentLoop = loop;
}
public void Switch(SwitchNode switcher)
{
//RotateVector
transform.position = switcher.GoalPos;
switch (switcher.VectorType)
{
case VectorType.Finish: Finish(); break;
case VectorType.SwitchScreen: switcher.SwitchCam(); UpdateGoal(switcher);
currentVectorType = VectorType.Forward;
break;
case VectorType.Backward:
case VectorType.Forward:
case VectorType.Left:
case VectorType.Right:
currentVectorType = switcher.VectorType;
UpdateGoal(switcher);
break;
}
}
void GenerateSprites(BeerTree bt)
{
SwitchNode startNode = bt.start;
GenerateSprite(startNode);
}
BeerTree MapGenerator(int numberOfSwitches)
{
SwitchNode parentSwitch = new SwitchNode(new Vector2(0.0f, 0.0f), "SWITCH_ROOT", new Switch(), true);
BeerTree bT = new BeerTree(parentSwitch);
int numOfSwitches = numberOfSwitches;
float y = 0.0f;
int idSwitchCounter = 1;
int numOfHouses = 0;
int idHouseCounter = 1;
for (int i = 0; i < numOfSwitches; i++)
{
y = y - 3;
SwitchNode newSwitch = new SwitchNode(new Vector2(0.0f, y), "SWITCH_" + idSwitchCounter++, new Switch(), false);
if (i == numOfSwitches - 1)
{
lastSwitchYcoordinate = y;
}
numOfHouses = RandomUtils.GetRandomNumber(1, 4);
if (i == 0)
{
bT.AddSwitch(newSwitch, "SWITCH_ROOT");
}
else
{
bT.AddSwitch(newSwitch, parentSwitch.nodeId);
}
parentSwitch = newSwitch;
switch (numOfHouses)
{
case 1:
{
HouseNode leftHouse = new HouseNode(new House(), new Vector2(-5.0f, newSwitch.coordinates.y), "HOUSE_" + idHouseCounter++);
bT.AddHouse(leftHouse, newSwitch.nodeId);
break;
}
case 2:
{
HouseNode rightHouse = new HouseNode(new House(), new Vector2(5.0f, newSwitch.coordinates.y), "HOUSE_" + idHouseCounter++);
bT.AddHouse(rightHouse, newSwitch.nodeId);
break;
}
default:
{
HouseNode leftHouse = new HouseNode(new House(), new Vector2(-5.0f, newSwitch.coordinates.y), "HOUSE_" + idHouseCounter++);
bT.AddHouse(leftHouse, newSwitch.nodeId);
HouseNode rightHouse = new HouseNode(new House(), new Vector2(5.0f, newSwitch.coordinates.y), "HOUSE_" + idHouseCounter++);
bT.AddHouse(rightHouse, newSwitch.nodeId);
break;
}
}
}
return(bT);
}
/// <summary>
/// 按 KNX 控件类型，给树上添加控件节点
/// </summary>
/// <param name="parentNode"></param>
/// <param name="knxControl"></param>
private static void AddControlNode(ContainerNode parentNode, KNXControlBase knxControl /*, UIEditor.Entity.ViewNode.PropertiesChangedDelegate proChangedDelegate*/)
{
switch (knxControl.GetType().Name)
{
case MyConst.Controls.KnxBlindsType:
var blindsNode = new BlindsNode(knxControl as KNXBlinds);
//blindsNode.PropertiesChangedEvent += proChangedDelegate;
parentNode.Nodes.Add(blindsNode);
break;
case MyConst.Controls.KnxLabelType:
var labelNode = new LabelNode(knxControl as KNXLabel);
//labelNode.PropertiesChangedEvent += proChangedDelegate;
parentNode.Nodes.Add(labelNode);
break;
case MyConst.Controls.KnxSceneButtonType:
var sceneButtonNode = new SceneButtonNode(knxControl as KNXSceneButton);
//sceneButtonNode.PropertiesChangedEvent += proChangedDelegate;
parentNode.Nodes.Add(sceneButtonNode);
break;
case MyConst.Controls.KnxSliderSwitchType:
var sliderSwitchNode = new SliderSwitchNode(knxControl as KNXSliderSwitch);
//sliderSwitchNode.PropertiesChangedEvent += proChangedDelegate;
parentNode.Nodes.Add(sliderSwitchNode);
break;
case MyConst.Controls.KnxSwitchType:
var switchNode = new SwitchNode(knxControl as KNXSwitch);
//switchNode.PropertiesChangedEvent += proChangedDelegate;
parentNode.Nodes.Add(switchNode);
break;
case MyConst.Controls.KnxValueDisplayType:
var valueDisplayNode = new ValueDisplayNode(knxControl as KNXValueDisplay);
//valueDisplayNode.PropertiesChangedEvent += proChangedDelegate;
parentNode.Nodes.Add(valueDisplayNode);
break;
case MyConst.Controls.KnxTimerButtonType:
var timerButton = new TimerButtonNode(knxControl as KNXTimerButton);
//timerButton.PropertiesChangedEvent += proChangedDelegate;
parentNode.Nodes.Add(timerButton);
break;
case MyConst.Controls.KnxDigitalAdjustment:
var digitalAdjustment = new DigitalAdjustmentNode(knxControl as KNXDigitalAdjustment);
//digitalAdjustment.PropertiesChangedEvent += proChangedDelegate;
parentNode.Nodes.Add(digitalAdjustment);
break;
case MyConst.Controls.KnxGroupBoxType:
var groupBox = new GroupBoxNode(knxControl as KNXGroupBox);
//groupBox.PropertiesChangedEvent += proChangedDelegate;
parentNode.Nodes.Add(groupBox);
KNXGroupBox knxGroupBox = knxControl as KNXGroupBox;
if (knxGroupBox.Controls != null && knxGroupBox.Controls.Count > 0)
{
foreach (var item in knxGroupBox.Controls)
{
AddControlNode(groupBox, item /*, proChangedDelegate*/);
}
}
break;
default:
MessageBox.Show(ResourceMng.GetString("Message39") + knxControl.GetType().Name, ResourceMng.GetString("Message6"), MessageBoxButtons.OK, MessageBoxIcon.Error);
break;
}
}
void GeneratePipes(BeerTree bt)
{
SwitchNode startNode = bt.start;
GeneratePipes(startNode);
}
// Use this for initialization
void Start()
{
beerTree = LevelLoader.getInstance().GetBeerTree();
direction = new Vector2(0.0f, -1.0f);
lastVisitedSwitchNode = beerTree.getRootNode();
}
public void Add(SwitchNode switchNode)
{
this.parts.Add(switchNode);
}
public SwitchCompiler(SwitchNode node)
{
this.node = node;
}
private static ViewNode ImportControlNode(BackgroundWorker worker, ContainerNode parentNode, KNXControlBase knx, string ResImgDir)
{
ViewNode node = null;
switch (knx.GetType().Name)
{
case MyConst.Controls.KnxBlindsType:
node = new BlindsNode(knx as KNXBlinds, worker, ResImgDir);
break;
case MyConst.Controls.KnxLabelType:
node = new LabelNode(knx as KNXLabel, worker, ResImgDir);
break;
case MyConst.Controls.KnxSceneButtonType:
node = new SceneButtonNode(knx as KNXSceneButton, worker, ResImgDir);
break;
case MyConst.Controls.KnxSliderSwitchType:
node = new SliderSwitchNode(knx as KNXSliderSwitch, worker, ResImgDir);
break;
case MyConst.Controls.KnxSwitchType:
node = new SwitchNode(knx as KNXSwitch, worker, ResImgDir);
break;
case MyConst.Controls.KnxValueDisplayType:
node = new ValueDisplayNode(knx as KNXValueDisplay, worker, ResImgDir);
break;
case MyConst.Controls.KnxTimerButtonType:
node = new TimerButtonNode(knx as KNXTimerButton, worker, ResImgDir);
break;
case MyConst.Controls.KnxDigitalAdjustmentType:
node = new DigitalAdjustmentNode(knx as KNXDigitalAdjustment, worker, ResImgDir);
break;
case MyConst.Controls.KnxImageButtonType:
node = new ImageButtonNode(knx as KNXImageButton, worker, ResImgDir);
break;
case MyConst.Controls.KnxShutterType:
node = new ShutterNode(knx as KNXShutter, worker, ResImgDir);
break;
case MyConst.Controls.KnxDimmerType:
node = new DimmerNode(knx as KNXDimmer, worker, ResImgDir);
break;
case MyConst.Controls.KnxWebCamViewerType:
node = new WebCamerNode(knx as KNXWebCamer, worker, ResImgDir);
break;
case MyConst.Controls.KnxMediaButtonType:
node = new MediaButtonNode(knx as KNXMediaButton, worker, ResImgDir);
break;
case MyConst.Controls.KnxAirConditionType:
node = new AirConditionNode(knx as KNXAirCondition, worker, ResImgDir);
break;
case MyConst.Controls.KnxHVACType:
node = new HVACNode(knx as KNXHVAC, worker, ResImgDir);
break;
case MyConst.Controls.KnxGroupBoxType:
node = new GroupBoxNode(knx as KNXGroupBox, worker, ResImgDir);
KNXGroupBox knxGroupBox = knx as KNXGroupBox;
if (knxGroupBox.Controls != null && knxGroupBox.Controls.Count > 0)
{
foreach (var item in knxGroupBox.Controls)
{
ImportControlNode(worker, node as ContainerNode, item, ResImgDir);
}
}
break;
default:
MessageBox.Show(UIResMang.GetString("Message39") + knx.GetType().Name, UIResMang.GetString("Message6"), MessageBoxButtons.OK, MessageBoxIcon.Error);
break;
}
if (null != parentNode)
{
parentNode.Nodes.Add(node);
}
return(node);
}
private SyntaxNode Node(SyntaxType parent, int start, int end, List <Token> tokens, List <Error> compileErrors)
{
switch (parent)
{
case SyntaxType.Program:
{
SyntaxNode node = new ProgramNode();
for (var i = start; i < end; i++)
{
switch (tokens[i].Type)
{
case TokenType.ClassDeclaration:
{
var newStart = i + 1;
var left = 1;
var right = 0;
while (left != right)
{
i++;
if (i >= end)
{
compileErrors.Add(new Error("Missing end of class declaration"));
return(null);
}
switch (tokens[i].Type)
{
case TokenType.ClassDeclaration:
case TokenType.InterfaceDeclaration:
left++;
break;
case TokenType.ClassEndDeclaration:
right++;
break;
}
}
var childNode = Node(SyntaxType.Class, newStart, i, tokens, compileErrors);
if (childNode == null)
{
return(null);
}
node.Nodes.Add(childNode);
break;
}
case TokenType.InterfaceDeclaration:
{
var newStart = i + 1;
var left = 1;
var right = 0;
while (left != right)
{
i++;
if (i >= end)
{
compileErrors.Add(new Error("Missing end of interface declaration"));
return(null);
}
switch (tokens[i].Type)
{
case TokenType.ClassDeclaration:
case TokenType.InterfaceDeclaration:
left++;
break;
case TokenType.ClassEndDeclaration:
right++;
break;
}
}
var childNode = Node(SyntaxType.Interface, newStart, i, tokens, compileErrors);
if (childNode == null)
{
return(null);
}
node.Nodes.Add(childNode);
break;
}
default:
{
if (IsTokenWhiteSpace(tokens[i]))
{
continue;
}
compileErrors.Add(new Error("Unexpected expression in program body"));
return(null);
}
}
}
return(node);
}
case SyntaxType.Class:
{
SyntaxNode node = new ClassNode(tokens[start - 1], tokens[end]);
for (var i = start; i < end; i++)
{
switch (tokens[i].Type)
{
case TokenType.MethodDeclaration:
{
var newStart = i + 1;
var left = 1;
var right = 0;
while (left != right)
{
i++;
if (i >= end)
{
compileErrors.Add(new Error("Missing end of method declaration"));
return(null);
}
switch (tokens[i].Type)
{
case TokenType.MethodDeclaration:
case TokenType.MainMethodDeclaration:
left++;
break;
case TokenType.MethodEndDeclaration:
right++;
break;
}
}
var childNode = Node(SyntaxType.MethodDeclaring, newStart, i, tokens, compileErrors);
if (childNode == null)
{
return(null);
}
node.Nodes.Add(childNode);
break;
}
case TokenType.MainMethodDeclaration:
{
var newStart = i + 1;
var left = 1;
var right = 0;
while (left != right)
{
i++;
if (i >= end)
{
compileErrors.Add(new Error("Missing end of main method declaration"));
return(null);
}
switch (tokens[i].Type)
{
case TokenType.MethodDeclaration:
case TokenType.MainMethodDeclaration:
left++;
break;
case TokenType.MethodEndDeclaration:
right++;
break;
}
}
var childNode = Node(SyntaxType.MainMethodDeclaring, newStart, i, tokens, compileErrors);
if (childNode == null)
{
return(null);
}
node.Nodes.Add(childNode);
break;
}
default:
{
if (IsTokenWhiteSpace(tokens[i]))
{
continue;
}
compileErrors.Add(new Error("Unexpected expression in class body"));
return(null);
}
}
}
return(node);
}
case SyntaxType.Interface:
{
SyntaxNode node = new InterfaceNode(tokens[start - 1], tokens[end]);
for (var i = start; i < end; i++)
{
if (tokens[i].Type == TokenType.MethodDeclaration)
{
node.Nodes.Add(new InterfaceMethodNode(tokens[i]));
}
else if (IsTokenWhiteSpace(tokens[i]))
{
}
else
{
compileErrors.Add(new Error("Unexpected expression in interface body"));
return(null);
}
}
return(node);
}
case SyntaxType.MethodDeclaring:
case SyntaxType.MainMethodDeclaring:
{
SyntaxNode node = new MethodNode(tokens[start - 1], tokens[end], parent == SyntaxType.MainMethodDeclaring);
Node(parent, start, end, tokens, compileErrors, node, "method");
return(node);
}
case SyntaxType.Switch:
{
SyntaxNode node = new SwitchNode(tokens[start - 1], tokens[end]);
Node(parent, start, end, tokens, compileErrors, node, "switch");
return(node);
}
case SyntaxType.SwitchCase:
{
SyntaxNode node = new SwitchCase(tokens[start - 1], tokens[start - 1].Type == TokenType.SwitchDefaultCase);
Node(parent, start, end, tokens, compileErrors, node, "switch case");
return(node);
}
case SyntaxType.IfTruePart:
{
SyntaxNode node = new IfTrueNode(tokens[start - 1].Childs[0]);
Node(parent, start, end, tokens, compileErrors, node, "if");
return(node);
}
case SyntaxType.IfFalsePart:
{
SyntaxNode node = new IfElseNode();
Node(parent, start, end, tokens, compileErrors, node, "else");
return(node);
}
case SyntaxType.ElifPart:
{
SyntaxNode node = new ElifNode(tokens[start - 1].Childs[0]);
Node(parent, start, end, tokens, compileErrors, node, "else-if");
return(node);
}
case SyntaxType.For:
{
SyntaxNode node = new ForNode(tokens[start - 1], tokens[end]);
Node(parent, start, end, tokens, compileErrors, node, "for");
return(node);
}
case SyntaxType.Foreach:
{
SyntaxNode node = new ForeachNode(tokens[start - 1], tokens[end]);
Node(parent, start, end, tokens, compileErrors, node, "foreach");
return(node);
}
case SyntaxType.While:
{
SyntaxNode node = new WhileNode(tokens[start - 1].Childs[0]);
Node(parent, start, end, tokens, compileErrors, node, "while");
return(node);
}
case SyntaxType.DoWhile:
{
SyntaxNode node = new DoWhileNode(tokens[end].Childs[0]);
Node(parent, start, end, tokens, compileErrors, node, "do-while");
return(node);
}
default:
{
compileErrors.Add(new Error("Not implemented parser behaviour"));
return(null);
}
}
}
public object Process(Parser parser, SortedDictionary <string, object> parameters)
{
if (parser.CurrenToken.Type == TokenType.PmSemicolon)
{
parser.NextToken();
return(null);
}
else if (parser.CurrenToken.Type == TokenType.KwIf)
{
parser.NextToken();
if (parser.CurrenToken.Type == TokenType.PmLeftParent)
{
parser.NextToken();
var _evaluation = (ExpressionNode) new AssignmentExpression().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmRightParent)
{
parser.NextToken();
var _ifCode = (List <StatementNode>) new Statementp().Process(parser, parameters);
var _ifNotCode = (ElseNode) new IfNot().Process(parser, parameters);
var _if = new IfNode {
EvaluationNode = _evaluation, IfCode = _ifCode, IfNotCode = _ifNotCode
};
return(_if);
}
else
{
throw new ParserException("This was expected ) Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else
{
throw new ParserException("This was expected ( Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwWhile)
{
parser.NextToken();
if (parser.CurrenToken.Type == TokenType.PmLeftParent)
{
parser.NextToken();
var _evaluation = (ExpressionNode) new AssignmentExpression().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmRightParent)
{
parser.NextToken();
var _whileCode = (List <StatementNode>) new Statementp().Process(parser, parameters);
var _while = new WhileNode {
EvaluationNode = _evaluation, CodeNode = _whileCode
};
return(_while);
}
else
{
throw new ParserException("This was expected ) Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else
{
throw new ParserException("This was expected ( Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwFor)
{
parser.NextToken();
if (parser.CurrenToken.Type == TokenType.PmLeftParent)
{
parser.NextToken();
var _for = (ForNode) new ForConditions().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmRightParent)
{
parser.NextToken();
var _forCode = (List <StatementNode>) new Statementp().Process(parser, parameters);
_for.CodeNode = _forCode;
return(_for);
}
else
{
throw new ParserException("This was expected ) Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else
{
throw new ParserException("This was expected ( Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwBreak)
{
parser.NextToken();
if (parser.CurrenToken.Type == TokenType.PmSemicolon)
{
parser.NextToken();
return(new BreakNode());
}
else
{
throw new ParserException("This was expected ; Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwContinue)
{
parser.NextToken();
if (parser.CurrenToken.Type == TokenType.PmSemicolon)
{
parser.NextToken();
return(new ContinueNode());
}
else
{
throw new ParserException("This was expected ; Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwThrow)
{
var _throw = new ThrowStatement().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmSemicolon)
{
parser.NextToken();
return(_throw);
}
else
{
throw new ParserException("This was expected ; Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwSwitch)
{
parser.NextToken();
if (parser.CurrenToken.Type == TokenType.PmLeftParent)
{
parser.NextToken();
var _evaluation = (ExpressionNode) new AssignmentExpression().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmRightParent)
{
parser.NextToken();
if (parser.CurrenToken.Type == TokenType.PmLeftCurlyBracket)
{
parser.NextToken();
var _caseBlock = (BaseCaseNode) new CaseBlock().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmRightCurlyBracket)
{
parser.NextToken();
var _switch = new SwitchNode {
EvaluationNode = _evaluation, CaseBlockNode = _caseBlock
};
return(_switch);
}
else
{
throw new ParserException("This was expected } Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else
{
throw new ParserException("This was expected { Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else
{
throw new ParserException("This was expected ) Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else
{
throw new ParserException("This was expected ( Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwDo)
{
parser.NextToken();
var _doWhileCode = (List <StatementNode>) new Statementp().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.KwWhile)
{
parser.NextToken();
if (parser.CurrenToken.Type == TokenType.PmLeftParent)
{
parser.NextToken();
var _evaluation = (ExpressionNode) new AssignmentExpression().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmRightParent)
{
parser.NextToken();
var _doWhile = new DoWhileNode {
EvaluationNode = _evaluation, CodeNode = _doWhileCode
};
return(_doWhile);
}
else
{
throw new ParserException("This was expected ) Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else
{
throw new ParserException("This was expected ( Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else
{
throw new ParserException("This was expected the token: while, Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwReturn)
{
parser.NextToken();
var _returnEp = (List <ExpressionNode>) new ExpressionOpt().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmSemicolon)
{
parser.NextToken();
var _return = new ReturnNode {
ReturnExpressionNode = _returnEp
};
return(_return);
}
else
{
throw new ParserException("This was expected ; Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwTry)
{
parser.NextToken();
var _tryCode = (List <StatementNode>) new CompoundStatement().Process(parser, parameters);
var _try = (TryNode) new CatchBlock().Process(parser, parameters);
var _finally = (FinallyNode) new FinallyBlock().Process(parser, parameters);
_try.FinallyCode = _finally;
_try.TryCode = _tryCode;
return(_try);
}
else
{
var _varEp = new VariablesOrExpression().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmSemicolon)
{
parser.NextToken();
return(_varEp);
}
else
{
throw new ParserException("This was expected ; Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
}
private void UpdateGoal(SwitchNode rotate)
{
currentMoveVector = (rotate.NextGoal.GoalPos - rotate.GoalPos).normalized;
currentGoal = rotate.NextGoal;
}
public SwitchNode Switch()
{
var @switch = new SwitchNode();
this.Add(@switch);
return @switch;
}
// Start is called before the first frame update
void Start()
{
socketClient = new SocketClient();
socketServer = GameObject.FindObjectOfType <SocketServer>();
maker = GameObject.FindObjectOfType <SpeechBubbleMaker>();
uniwinc = GameObject.FindObjectOfType <UniWindowController>();
Node root = new MenuNode();
Node setting = new Node("せってい", 1);
root.AddChild(setting);
var setTransparent = new SwitchNode("背景透過中だよ", "背景透過してないよ", 1, uniwinc.isTransparent);
setting.AddCallback(() =>
{
setTransparent.ON = uniwinc.isTransparent;
});
setTransparent.AddCallback(() =>
{
uniwinc.isTransparent = setTransparent.ON;
});
setting.AddChild(setTransparent);
var setTopmost = new SwitchNode("最前面固定するよ", "最前面固定しないよ", 1, uniwinc.isTopmost);
setting.AddCallback(() =>
{
setTopmost.ON = uniwinc.isTopmost;
});
setTopmost.AddCallback(() =>
{
uniwinc.isTopmost = setTopmost.ON;
});
setting.AddChild(setTopmost);
var setTranslucent = new SwitchNode("半透明だよ", "半透明じゃないよ", 1, false);
setTranslucent.AddCallback(() =>
{
canvasGroup.alpha = setTranslucent.ON ? 0.5f : 1.0f;
});
setting.AddChild(setTranslucent);
var setRandspeak = new SwitchNode("話すよー", "黙ってるよ...", +1);
setRandspeak.AddCallback(() =>
{
if (setRandspeak.ON)
{
maker.StopSpeak();
}
else
{
maker.StartSpeak();
}
});
setting.AddChild(setRandspeak);
Node remocon = new Node("リモコン", 1);
// root.AddChild(remocon);
Node right_off = new Node("明かりを消す?", 1);
right_off.AddCallback(() =>
{
HttpCommunicator hc = new HttpCommunicator();
var url = "https://api.switch-bot.com/v1.0/devices/01-202101071744-43895891/commands";
// hc.GetHttpAsync()
});
Node sensor = new Node("Sensor", 1);
// root.AddChild(sensor);
PythonExecutor pyexe = GameObject.FindObjectOfType <PythonExecutor>();
socketServer.AddCommand("speak", mes =>
{
maker.GenerateFromThread(1, mes, 3, 1);
});
socketServer.AddCommand("long_speak", mes =>
{
maker.GenerateFromThread(1, mes, -1, 1);
});
socketServer.AddCommand("echo", mes =>
{
pyexe.SendCmd("nothing");
});
Node sensor_mes = new Node("Lauching...");
sensor.AddChild(sensor_mes);
pyexe.AddCommand("log", (mes) =>
{
Debug.Log("[python][log] " + mes);
});
sensor.AddCallback(() =>
{
sensor_mes.Text = "Lauching...";
pyexe.ExecuteOnThread(); //実行
Observable.Interval(TimeSpan.FromSeconds(1)).Subscribe(_ =>
{
pyexe.p_WriteInputData("echo Message from C#");
});
});
Node clock = new Node("Clock", 1);
root.AddChild(clock);
Node clock_display = new Node("--:--", 1);
clock.AddChild(clock_display);
IDisposable clock_update = null;
clock.AddCallback(() =>
{
clock_update = Observable.Interval(TimeSpan.FromSeconds(0.1)).Subscribe(_ =>
{
if (clock_display.speechBubble == null)
{
clock_update.Dispose();
return;
}
//clock_display.Text = DateTime.Now.ToShortTimeString();
clock_display.Text = DateTime.Now.ToLongTimeString();
}).AddTo(this);
});
Node tool = new Node("Tool", 1);
root.AddChild(tool);
//Node bluetooth = new Node("Bluetooth\n ON");
//tool.AddChild(bluetooth);
Node pyexecutor_interface = new Node("pyexecutor");
tool.AddChild(pyexecutor_interface);
Node gui_start = new Node("GUIStart");
pyexecutor_interface.AddChild(gui_start);
pyexe.AddCommand("launched", (mes) =>
{
gui_start.Text = "GUI Launched";
});
gui_start.AddCallback(() =>
{
gui_start.Text = "GUI Started";
pyexe.SendCmd("gui_start");
});
Node socketClientTest = new Node("SocketClient\nTest");
socketClientTest.AddCallback(() =>
{
Task.Run(socketClient.ConnentionTest);
});
tool.AddChild(socketClientTest);
Node shutdown = new Node("Shutdown");
shutdown.AddCallback(() =>
{
#if UNITY_EDITOR
UnityEditor.EditorApplication.isPlaying = false;
#elif UNITY_STANDALONE
UnityEngine.Application.Quit();
#endif
});
tool.AddChild(shutdown);
Node speaktest = new Node("speaktest");
tool.AddChild(speaktest);
Node title1 = new Node("精密計測工学2\n レポート");
speaktest.AddChild(title1);
// Node title2 = new Node("精密計測工学2");
// speaktest.AddChild(title2);
root.GenerateBubble(2);
}
public void Add(SwitchNode switchNode)
{
this.parts.Add(switchNode);
}
public Word Visit(SwitchNode switchNode)
{
ControlStack.Push(ControlType.Switch);//Push into control stack
var result = switchNode.Flag.Accept(this);
if (IsError(result))
{
ControlStack.Pop();
return(result);
}
PyObj pyObjFlag;
if (IsMemoryBlock(result))//comentar ese if else si se hace la desereferencia en atomic expr.
{
pyObjFlag = ((MemoryBlock)result).Value;
}
else
{
pyObjFlag = (PyObj)result;
}
//pyObj = (PyObj)result;//Descomentar esta linea si se hace la desereferencia en atomic expr.
var switchElements = new AstNode[switchNode.SwitchElements.Count];
switchNode.SwitchElements.CopyTo(switchElements);
//Caso que dio true a pyObjFlag cuando se comparar con ==
int? trueCaseIndex = null;
int? defaultIndex = null;
SwitchLabel switchLabel;
PyObj pyObjCase;
MyBoolean caseEvaluationResult;
for (int i = 0; i < switchElements.Length; i++)
{
//Quitar comentario si se desea que no puedan venir declaraciones dentro del if
//if (switchElements[i].GetNodeType() == NodeType.Declaration)
//{
// ControlStack.Pop();
// return ErrorFactory.DeclarationInSwitch(switchElements[i]);
//}
if (switchElements[i].GetNodeType() != NodeType.SwitchLabel)
{
continue;
}
result = switchElements[i].Accept(this);
if (IsError(result))
{
ControlStack.Pop();
return(result);
}
switchLabel = (SwitchLabel)result;
if (switchLabel.GetLabelType() == LabelType.Default)
{
if (defaultIndex != null)
{
ControlStack.Pop();
return(ErrorFactory.MultipleDefaultInSwitch(switchElements[i]));
}
else
{
defaultIndex = i;
}
}
else
{
pyObjCase = switchLabel.Value;
result = pyObjFlag.BinaryOperation(BinaryOperator.PyEquals, pyObjCase);
if (IsError(result))
{
ControlStack.Pop();
return(ErrorFactory.Create(switchElements[i], (MyError)result));
}
if (((PyObj)result).GetMyType() != TypeConstants.BOOLEAN)
{
ControlStack.Pop();
return(ErrorFactory.NotValidOperationInSwitch(switchElements[i]));
}
caseEvaluationResult = (MyBoolean)result;
if (caseEvaluationResult.Bool)
{
if (trueCaseIndex != null)
{
ControlStack.Pop();
return(ErrorFactory.MultipleTrueCasesInSwitch(switchElements[i]));
}
else
{
trueCaseIndex = i;
}
}
}
}
int startIndex = switchElements.Length;
if (trueCaseIndex != null)
{
startIndex = (int)trueCaseIndex;
}
else if (defaultIndex != null)
{
startIndex = (int)defaultIndex;
}
for (int i = startIndex; i < switchElements.Length; i++)
{
if (switchElements[i].GetNodeType() == NodeType.SwitchLabel)
{
continue;
}
result = switchElements[i].Accept(this);
if (IsJumper(result))
{
var jumper = (Jumper)result;
if (jumper.CanJump(ControlType.Switch))
{
if (!jumper.WasPopped())//Chapuz alto en el caso que retorne un jumper que no este metido dentro de ningun scope
{
ControlStack.Pop();
}
return(null);
}
if (jumper.WasPopped())//Chapuz Alto para que no haga pop until mas de una vez cuando hay bloques adentro de bloques
{
return(jumper);
}
if (ControlStack.PopUntil(jumper))
{
return(jumper);
}
else
{
ErrorFactory.NotValidJumper(switchElements[i], jumper);
}
}
}
return(null);
}
protected StatementNode ParseStatement(List <Token> tokens, ref int index, CompilerNode owner)
{
BlockNode block = null;
do
{
if (index >= tokens.Count)
{
throw new ParserException(tokens.Last(), ParserException.Kind.EndOfStream);
}
var token = tokens[index];
StatementNode statement = null;
var type = GetTypeFromToken(owner, token.text);
if (type != null)
{
var decl = new DeclarationNode(block);
decl.type = type;
index++;
decl.identifier = ExpectIdentifier(tokens, ref index, false);
if (ExpectOptional(tokens, ref index, "="))
{
var node = new AssignmentNode(owner);
node.identifier = decl.identifier;
node.expr = ParseExpression(tokens, ref index, block);
statement = node;
}
ExpectDelimiter(tokens, ref index, ";");
}
else
{
switch (token.text)
{
case "{":
{
index++;
block = new BlockNode(owner);
owner = block;
break;
}
case "return":
{
index++;
var node = new ReturnNode(owner);
node.expr = ParseExpression(tokens, ref index, node);
ExpectDelimiter(tokens, ref index, ";");
statement = node;
break;
}
case "if":
{
index++;
ExpectDelimiter(tokens, ref index, "(");
BlockNode parent = (block != null) ? block : owner as BlockNode;
if (parent == null)
{
throw new ParserException(token, ParserException.Kind.UnexpectedToken);
}
var node = new IfNode(parent);
node.expr = ParseExpression(tokens, ref index, parent);
ExpectDelimiter(tokens, ref index, ")");
node.trueBranch = ParseStatement(tokens, ref index, parent);
if (ExpectOptional(tokens, ref index, "else"))
{
node.falseBranch = ParseStatement(tokens, ref index, parent);
}
statement = node;
break;
}
case "switch":
{
index++;
var node = new SwitchNode(block);
statement = node;
ExpectDelimiter(tokens, ref index, "(");
node.expr = ParseExpression(tokens, ref index, node);
ExpectDelimiter(tokens, ref index, ")");
ExpectDelimiter(tokens, ref index, "{");
var keys = new HashSet <string>();
do
{
if (tokens[index].text == "}")
{
break;
}
if (ExpectOptional(tokens, ref index, "default"))
{
ExpectDelimiter(tokens, ref index, ":");
var st = ParseStatement(tokens, ref index, node);
node.defaultBranch = st;
}
else
{
ExpectKeyword(tokens, ref index, "case");
LiteralKind litKind;
var val = ExpectLiteral(tokens, ref index, out litKind);
var key = val.ToString();
if (keys.Contains(key))
{
throw new ParserException(tokens[index], ParserException.Kind.DuplicatedLabel);
}
var lit = new LiteralExpressionNode(node);
lit.kind = litKind;
lit.value = val;
ExpectDelimiter(tokens, ref index, ":");
var st = ParseStatement(tokens, ref index, node);
node.cases[lit] = st;
keys.Add(key);
}
}while (true);
ExpectDelimiter(tokens, ref index, "}");
break;
}
default:
{
throw new ParserException(tokens[index], ParserException.Kind.UnexpectedToken);
}
}
}
if (block == null)
{
return(statement);
}
else
if (statement != null)
{
block.statements.Add(statement);
}
} while (tokens[index].text != "}");
index++;
return(block);
}
