public void ParseTest() {
var context = new ParserContext(new Vrml97Tokenizer(new StringReader(@"
USE qwe123
")));
var statement = UseStatement.Parse(context);
Assert.AreEqual("qwe123", statement.NodeName);
}
public void ParseTest() {
var context = new ParserContext(new Vrml97Tokenizer(new StringReader(@"
eventOut SFInt32 click
")));
var statement = ProtoEventOutStatement.Parse(context);
Assert.AreEqual("SFInt32", statement.FieldType);
Assert.AreEqual("click", statement.EventId);
}
public void ParseTest() {
var context = new ParserContext(new Vrml97Tokenizer(new StringReader(@"
field SFInt32 test
")));
var statement = ExternFieldStatement.Parse(context);
Assert.AreEqual("SFInt32", statement.FieldType);
Assert.AreEqual("test", statement.FieldId);
}
public void ParseTest() {
var context = new ParserContext(new Vrml97Tokenizer(new StringReader(@"
exposedField SFInt32 test 2
")));
var statement = ProtoExposedFieldStatement.Parse(context, c => { });
Assert.AreEqual("SFInt32", statement.FieldType);
Assert.AreEqual("test", statement.FieldId);
Assert.AreEqual(2, ((SFInt32)statement.Value).Value);
}
public void ParseTest() {
var context = new ParserContext(new Vrml97Tokenizer(new StringReader(@"
ROUTE nodeOut.eventOut TO nodeIn.eventIn
")));
var statement = RouteStatement.Parse(context);
Assert.AreEqual("nodeOut", statement.NodeOut);
Assert.AreEqual("eventOut", statement.EventOut);
Assert.AreEqual("nodeIn", statement.NodeIn);
Assert.AreEqual("eventIn", statement.EventIn);
}
public void ParseTest() {
var context = new ParserContext(new Vrml97Tokenizer(new StringReader(@"
exposedField SFInt32 test 15
")));
var statement = ExposedFieldStatement.Parse(context, c => { });
Assert.AreEqual("SFInt32", statement.FieldType);
Assert.AreEqual("test", statement.FieldId);
Assert.IsAssignableFrom(typeof(SFInt32), statement.Value);
Assert.AreEqual(15, ((SFInt32)statement.Value).Value);
}
public void ParseEmptyTest() {
var context = new ParserContext(new Vrml97Tokenizer(new StringReader(@"
[
]
")));
var statement = ExternInterfaceDeclarationsStatement.Parse(context);
Assert.AreEqual(0, statement.EventsIn.Count);
Assert.AreEqual(0, statement.EventsOut.Count);
Assert.AreEqual(0, statement.Fields.Count);
Assert.AreEqual(0, statement.ExposedFields.Count);
}
public void Parse(MFNode container) {
var context = new ParserContext(_tokenizer);
try {
_fieldParser = new FieldParser(context, ParseNodeStatement);
context.PushNodeContainer(container);
ParseStatements(context);
context.PopNodeContainer();
} catch (VrmlParseException exc) {
throw new InvalidVRMLSyntaxException(exc.Message + " at Line: " + context.LineIndex + " Column: " + context.ColumnIndex);
}
}
protected virtual void ParseStatement(ParserContext context) {
var token = context.PeekNextToken();
switch (token.Text) {
case "DEF":
case "USE":
ParseNodeStatement(context);
break;
case "PROTO":
case "EXTERNPROTO":
ParseProtoStatement(context);
break;
case "ROUTE":
ParseRouteStatement(context);
break;
default:
if (token.Type == VRML97TokenType.Word) {
ParseNodeStatement(context);
} else {
throw new Exception("Unexpected context");
}
break;
}
}
protected virtual void ParseStatements(ParserContext context) {
bool validToken;
do {
var token = context.PeekNextToken();
switch (token.Text) {
case "DEF":
case "USE":
case "PROTO":
case "EXTERNPROTO":
case "ROUTE":
validToken = true;
ParseStatement(context);
break;
default:
if (token.Type == VRML97TokenType.Word) {
ParseStatement(context);
validToken = true;
} else {
validToken = false;
}
break;
}
} while (validToken);
}
protected virtual void ParseDefNodeStatement(ParserContext context) {
context.ReadNextToken();
context.NodeName = ParseNodeNameId(context);
ParseNode(context);
}
protected virtual void ParseNodeStatement(ParserContext context) {
var token = context.PeekNextToken();
switch (token.Text) {
case "DEF":
ParseDefNodeStatement(context);
break;
case "USE":
var useStatement = UseStatement.Parse(context);
var node = context.FindNode(useStatement.NodeName);
context.AcceptChild(node);
break;
default:
ParseNode(context);
break;
}
}
private string ParseFieldType(ParserContext context) {
return context.ParseFieldType();
}
protected virtual void ParseURLList(ParserContext context) {
MFString urls = new MFString();
urls.AcceptVisitor(_fieldParser);
//TODO: Process Urls.
}
protected virtual void ParseRouteStatement(ParserContext context) {
var statement = RouteStatement.Parse(context);
//TODO: Process route statement.
}
private static string ParseId(ParserContext context) {
return context.ReadNextToken().Text;
}
protected virtual void ParseExternProto(ParserContext context) {
context.ReadKeyword("EXTERNPROTO");
var nodeTypeId = ParseNodeTypeId(context);
ParseExternInterfaceDeclarations(context);
ParseURLList(context);
//TODO: Process extern proto.
}
protected virtual void ParseScriptNode(ParserContext context) {
var keyword = context.ReadNextToken();
if (keyword.Text != "Script") {
throw new InvalidVRMLSyntaxException("Script expected");
}
context.ReadOpenBrace();
ParseScriptBody(context);
context.ReadCloseBrace();
}
protected virtual void ParseNode(ParserContext context) {
var token = context.PeekNextToken();
if (token.Type == VRML97TokenType.EOF) return;
switch (token.Text) {
case "Script":
ParseScriptNode(context);
break;
default:
var nodeTypeId = ParseNodeTypeId(context);
var node = context.CreateNode(nodeTypeId, context.NodeName);
context.NodeName = null;
context.PushFieldContainer(node);
if (context.ReadNextToken().Type != VRML97TokenType.OpenBrace) {
throw new InvalidVRMLSyntaxException("Open brace expected");
}
ParseNodeBody(context);
if (context.ReadNextToken().Type != VRML97TokenType.CloseBrace) {
throw new InvalidVRMLSyntaxException();
}
context.PopFieldContainer();
context.AcceptChild(node);
break;
}
}
private static string ParseNodeNameId(ParserContext context) {
return context.ParseNodeNameId();
}
protected virtual void ParseNodeBodyElement(ParserContext context) {
var node = context.FieldContainer;
if (node == null) {
throw new Exception("Invalid context");
}
var token = context.PeekNextToken();
switch (token.Text) {
case "ROUTE":
ParseRouteStatement(context);
break;
case "PROTO":
ParseProto(context);
break;
}
string fieldId = ParseFieldId(context);
token = context.PeekNextToken();
//TODO: get field type and parse depending on it.
switch (token.Text) {
case "IS":
token = context.ReadNextToken();
string interfaceFieldId = ParseFieldId(context);
//TODO: Process inteface field linking
break;
default:
var field = node.GetExposedField(fieldId);
field.AcceptVisitor(_fieldParser);
break;
}
}
protected virtual void ParseScriptBodyElement(ParserContext context) {
var token = context.PeekNextToken();
VRML97Token tokenIs = null;
string fieldType;
switch (token.Text) {
case "eventIn":
tokenIs = context.PeekNextToken(3);
if (tokenIs.Text == "IS") {
token = context.ReadNextToken();
fieldType = ParseFieldType(context);
string eventInId1 = ParseEventInId(context);
tokenIs = context.ReadNextToken();
string eventInId2 = ParseEventInId(context);
//TODO: process scipt eventIn element
} else {
ParseRestrictedInterfaceDeclaration(context);
}
break;
case "eventOut":
tokenIs = context.PeekNextToken(3);
if (tokenIs.Text == "IS") {
token = context.ReadNextToken();
fieldType = ParseFieldType(context);
string eventOutId1 = ParseEventOutId(context);
tokenIs = context.ReadNextToken();
string eventOutId2 = ParseEventOutId(context);
//TODO: process scipt eventOut element
} else {
ParseRestrictedInterfaceDeclaration(context);
}
break;
case "field":
tokenIs = context.PeekNextToken(3);
if (tokenIs.Text == "IS") {
token = context.ReadNextToken();
fieldType = ParseFieldType(context);
string fieldId1 = ParseFieldId(context);
tokenIs = context.ReadNextToken();
string fieldId2 = ParseFieldId(context);
//TODO: process scipt field element
} else {
ParseRestrictedInterfaceDeclaration(context);
}
break;
default:
if (token.Type == VRML97TokenType.Word) {
ParseNodeBodyElement(context);
} else {
throw new Exception("Unexpected context");
}
break;
}
}
protected virtual void ParseNodeBody(ParserContext context) {
var validToken = true;
do {
var token = context.PeekNextToken();
if (token.Type == VRML97TokenType.Word) {
ParseNodeBodyElement(context);
} else {
validToken = false;
}
} while (validToken);
}
protected virtual void ParseExternInterfaceDeclarations(ParserContext context) {
var statement = ExternInterfaceDeclarationsStatement.Parse(context);
//TODO: process extern interface declarations.
}
private void ParseInterfaceDeclarations(ParserContext context) {
var statement = ProtoInterfaceDeclarationsStatement.Parse(context, ParseNodeStatement);
//todo: process interface declarations
var node = context.FieldContainer as ProtoNode;
if (node == null) throw new Exception("Unexpected context");
foreach (var expFld in statement.Fields) {
var field = expFld.Value;
node.AddField(expFld.FieldId, field);
}
foreach (var expFld in statement.ExposedFields) {
var field = expFld.Value;
node.AddExposedField(expFld.FieldId, field);
}
}
private void ParseRestrictedInterfaceDeclaration(ParserContext context) {
var node = context.FieldContainer as ProtoNode;
if (node == null) throw new Exception("Unexpected context");
var accessType = context.ReadNextToken().Text;
switch (accessType) {
case "eventIn":
var fieldInType = ParseFieldType(context);
var eventInId = ParseEventInId(context);
//TODO: process interface eventIn declaration.
break;
case "eventOut":
var fieldOutType = ParseFieldType(context);
var eventOutId = ParseEventOutId(context);
//TODO: process interface eventOut declaration.
break;
case "field":
var fieldType = ParseFieldType(context);
var fieldId = ParseFieldId(context);
var field = context.CreateField(fieldType);
node.AddField(fieldId, field);
field.AcceptVisitor(_fieldParser);
//TODO: process interface field declaration.
break;
default:
throw new Exception("Unexpected context");
}
}
protected virtual string ParseEventInId(ParserContext context) {
return context.ParseEventInId();
}
private string ParseNodeTypeId(ParserContext context) {
return ParseId(context);
}
private static string ParseEventOutId(ParserContext context) {
return context.ParseEventOutId();
}
public void ParseTest() {
var context = new ParserContext(new Vrml97Tokenizer(new StringReader(@"
[
eventIn SFInt32 eventIn1
eventOut SFInt32 eventOut1
eventIn SFInt32 eventIn2
eventOut SFInt32 eventOut2
field SFInt32 field1 1
exposedField SFInt32 exposedField1 2
field SFInt32 field2 3
exposedField SFInt32 exposedField2 4
]
")));
var statement = ProtoInterfaceDeclarationsStatement.Parse(context, c => { });
Assert.AreEqual(2, statement.EventsIn.Count);
Assert.AreEqual(2, statement.EventsOut.Count);
Assert.AreEqual(2, statement.Fields.Count);
Assert.AreEqual(2, statement.ExposedFields.Count);
var firstEventIn = statement.EventsIn.First();
Assert.AreEqual("SFInt32", firstEventIn.FieldType);
Assert.AreEqual("eventIn1", firstEventIn.EventId);
var secondEventIn = statement.EventsIn.Last();
Assert.AreEqual("SFInt32", secondEventIn.FieldType);
Assert.AreEqual("eventIn2", secondEventIn.EventId);
var firstEventOut = statement.EventsOut.First();
Assert.AreEqual("SFInt32", firstEventOut.FieldType);
Assert.AreEqual("eventOut1", firstEventOut.EventId);
var secondEventOut = statement.EventsOut.Last();
Assert.AreEqual("SFInt32", secondEventOut.FieldType);
Assert.AreEqual("eventOut2", secondEventOut.EventId);
var firstField = statement.Fields.First();
Assert.AreEqual("SFInt32", firstField.FieldType);
Assert.AreEqual("field1", firstField.FieldId);
Assert.AreEqual(1, ((SFInt32)firstField.Value).Value);
var secondField = statement.Fields.Last();
Assert.AreEqual("SFInt32", secondField.FieldType);
Assert.AreEqual("field2", secondField.FieldId);
Assert.AreEqual(3, ((SFInt32)secondField.Value).Value);
var firstExposedField = statement.ExposedFields.First();
Assert.AreEqual("SFInt32", firstExposedField.FieldType);
Assert.AreEqual("exposedField1", firstExposedField.FieldId);
Assert.AreEqual(2, ((SFInt32)firstExposedField.Value).Value);
var secondExposedField = statement.ExposedFields.Last();
Assert.AreEqual("SFInt32", secondExposedField.FieldType);
Assert.AreEqual("exposedField2", secondExposedField.FieldId);
Assert.AreEqual(4, ((SFInt32)secondExposedField.Value).Value);
}
