/// <inheritdoc/> public override int GetHashCode() { return(HashCodeHelper.Combine(NameId.GetHashCode(), Value.GetHashCode())); }
private void OnTriggerEnter(Collider other) { otherIdObj = other.GetComponent <BehaviorID>().nameIDObj; CheckId(); }
public void ChangeId(NameId id) { nameIdObj = id; }
public NameId(NameId nameIdObj) { throw new System.NotImplementedException(); }
public CsGrammar() { instance = this; EOF = new Id("EOF"); IDENTIFIER = new Id("IDENTIFIER"); LITERAL = new Id("LITERAL"); NAME = new NameId(); // NAME = new Id("IDENTIFIER"); // tokenName = TokenToId("NAME"); // NAME.lookahead.Add(new TokenSet(tokenName)); var externAliasDirective = new Id("externAliasDirective"); var usingDirective = new Id("usingDirective"); //var globalAttribute = new Id("globalAttribute"); var namespaceMemberDeclaration = new Id("namespaceMemberDeclaration"); var namespaceDeclaration = new Id("namespaceDeclaration"); var qualifiedIdentifier = new Id("qualifiedIdentifier"); var namespaceBody = new Id("namespaceBody"); //var typeDeclaration = new Id("typeDeclaration"); var attributes = new Id("attributes"); var modifiers = new Id("modifiers"); var typeParameterList = new Id("typeParameterList"); var typeParameter = new Id("typeParameter"); var classBase = new Id("classBase"); var typeParameterConstraintsClauses = new Id("typeParameterConstraintsClauses"); var typeParameterConstraintsClause = new Id("typeParameterConstraintsClause"); var classBody = new Id("classBody"); var classMemberDeclaration = new Id("classMemberDeclaration"); var attribute = new Id("attribute"); var typeName = new Id("typeName"); var argumentList = new Id("argumentList"); var attributeArgumentList = new Id("attributeArgumentList"); var expression = new Id("expression"); var constantExpression = new Id("constantExpression"); var primaryExpression = new Id("primaryExpression"); var arrayCreationExpression = new Id("arrayCreationExpression"); var implicitArrayCreationExpression = new Id("implicitArrayCreationExpression"); var constantDeclaration = new Id("constantDeclaration"); var fieldDeclaration = new Id("fieldDeclaration"); var methodDeclaration = new Id("methodDeclaration"); var propertyDeclaration = new Id("propertyDeclaration"); var eventDeclaration = new Id("eventDeclaration"); var indexerDeclaration = new Id("indexerDeclaration"); var operatorDeclaration = new Id("operatorDeclaration"); var constructorDeclaration = new Id("constructorDeclaration"); var destructorDeclaration = new Id("destructorDeclaration"); //var staticConstructorDeclaration = new Id("staticConstructorDeclaration"); var constantDeclarators = new Id("constantDeclarators"); var constantDeclarator = new Id("constantDeclarator"); var type = new Id("type"); var type2 = new Id("type2"); var predefinedType = new Id("predefinedType"); var variableDeclarators = new Id("variableDeclarators"); var variableDeclarator = new Id("variableDeclarator"); var arrayInitializer = new Id("arrayInitializer"); var variableInitializer = new Id("variableInitializer"); var variableInitializerList = new Id("variableInitializerList"); var simpleType = new Id("simpleType"); var exceptionClassType = new Id("exceptionClassType"); //var arrayType = new Id("arrayType"); var nonArrayType = new Id("nonArrayType"); var rankSpecifier = new Id("rankSpecifier"); var numericType = new Id("numericType"); var integralType = new Id("integralType"); var floatingPointType = new Id("floatingPointType"); r_compilationUnit = new Rule("compilationUnit", new Many(externAliasDirective) - new Many(usingDirective) //new Many(globalAttribute), - new Many(namespaceMemberDeclaration) - EOF ) { semantics = SemanticFlags.CompilationUnitScope }; parser = new Parser(r_compilationUnit, this); //NAME = new Id("NAME"); //parser.Add(new Rule("NAME", // IDENTIFIER // )); parser.Add(new Rule("externAliasDirective", new Seq( "extern", "alias", IDENTIFIER, ";" ) ) { semantics = SemanticFlags.ExternAlias }); var usingNamespaceDirective = new Id("usingNamespaceDirective"); var usingAliasDirective = new Id("usingAliasDirective"); var globalNamespace = new Id("globalNamespace"); var namespaceName = new Id("namespaceName"); var namespaceOrTypeName = new Id("namespaceOrTypeName"); var PARTIAL = new Id("PARTIAL"); parser.Add(new Rule("usingDirective", "using" - (new If(IDENTIFIER - "=", usingAliasDirective) | usingNamespaceDirective) - ";" )); parser.Add(new Rule("PARTIAL", new If(s => s.Current.text == "partial", IDENTIFIER) | "partial" ) { contextualKeyword = true }); parser.Add(new Rule("namespaceMemberDeclaration", namespaceDeclaration | (attributes - modifiers - new Alt( new Seq( new Opt(PARTIAL), new Id("classDeclaration") | new Id("structDeclaration") | new Id("interfaceDeclaration")), new Id("enumDeclaration"), new Id("delegateDeclaration")) ) | ".NAMESPACEBODY" )); parser.Add(new Rule("namespaceDeclaration", "namespace" - qualifiedIdentifier - namespaceBody - new Opt(";") ) { semantics = SemanticFlags.NamespaceDeclaration }); parser.Add(new Rule("qualifiedIdentifier", NAME - new Many(new Lit(".") - NAME) )); parser.Add(new Rule("namespaceBody", "{" - new Many(externAliasDirective) - new Many(usingDirective) - new Many(namespaceMemberDeclaration) - "}" ) { semantics = SemanticFlags.NamespaceBodyScope }); //parser.Add(new Rule("typeDeclaration", // new Alt( // new Seq( // new Opt("partial"), // new Id("classDeclaration") | new Id("structDeclaration") | new Id("interfaceDeclaration")), // new Id("enumDeclaration"), // new Id("delegateDeclaration")) // )); // parser = new Parser(r_compilationUnit, this); parser.Add(new Rule("usingNamespaceDirective", namespaceName ) { semantics = SemanticFlags.UsingNamespace }); parser.Add(new Rule("namespaceName", namespaceOrTypeName )); parser.Add(new Rule("usingAliasDirective", IDENTIFIER - "=" - namespaceOrTypeName ) { semantics = SemanticFlags.UsingAlias }); parser.Add(new Rule("classDeclaration", new Seq( "class", NAME, new Opt(typeParameterList), new Opt(classBase), new Opt(typeParameterConstraintsClauses), classBody, new Opt(";")) ) { semantics = SemanticFlags.ClassDeclaration | SemanticFlags.TypeDeclarationScope }); parser.Add(new Rule("typeParameterList", "<" - attributes - typeParameter - new Many("," - attributes - typeParameter) - ">" )); parser.Add(new Rule("typeParameter", NAME ) { semantics = SemanticFlags.TypeParameterDeclaration }); var interfaceTypeList = new Id("interfaceTypeList"); parser.Add(new Rule("classBase", ":" - interfaceTypeList ) { semantics = SemanticFlags.ClassBaseScope }); parser.Add(new Rule("interfaceTypeList", (typeName | "object") - new Many("," - typeName) ) { semantics = SemanticFlags.BaseListDeclaration }); parser.Add(new Rule("classBody", "{" - new Many(classMemberDeclaration) - "}" ) { semantics = SemanticFlags.ClassBodyScope }); var interfaceDeclaration = new Id("interfaceDeclaration"); var classDeclaration = new Id("classDeclaration"); var structDeclaration = new Id("structDeclaration"); var memberName = new Id("memberName"); var qid = new Id("qid"); var enumDeclaration = new Id("enumDeclaration"); //var enumDeclarator = new Id("enumDeclarator"); var delegateDeclaration = new Id("delegateDeclaration"); var conversionOperatorDeclaration = new Id("conversionOperatorDeclaration"); parser.Add(new Rule("memberName", qid )); parser.Add(new Rule("classMemberDeclaration", new Seq( attributes, modifiers, constantDeclaration | "void" - methodDeclaration | new If(PARTIAL, PARTIAL - ("void" - methodDeclaration | classDeclaration | structDeclaration | interfaceDeclaration)) | new If(IDENTIFIER - "(", constructorDeclaration) | new Seq( type, new If(memberName - "(", methodDeclaration) | new If(memberName - "{", propertyDeclaration) | new If(typeName - "." - "this", typeName - "." - indexerDeclaration) | new If(predefinedType - "." - "this", predefinedType - "." - indexerDeclaration) | indexerDeclaration | fieldDeclaration | operatorDeclaration) | classDeclaration | structDeclaration | interfaceDeclaration | enumDeclaration | delegateDeclaration | eventDeclaration | conversionOperatorDeclaration) | destructorDeclaration | ".CLASSBODY" ) /*{ semantics = SemanticFlags.MemberDeclarationScope }*/); var constructorDeclarator = new Id("constructorDeclarator"); var constructorBody = new Id("constructorBody"); var constructorInitializer = new Id("constructorInitializer"); var destructorDeclarator = new Id("destructorDeclarator"); var destructorBody = new Id("destructorBody"); var arguments = new Id("arguments"); var attributeArguments = new Id("attributeArguments"); var formalParameterList = new Id("formalParameterList"); var block = new Id("block"); var statementList = new Id("statementList"); parser.Add(new Rule("constructorDeclaration", constructorDeclarator - constructorBody ) { semantics = SemanticFlags.MethodDeclarationScope | SemanticFlags.ConstructorDeclarator }); parser.Add(new Rule("constructorDeclarator", IDENTIFIER - "(" - new Opt(formalParameterList) - ")" - new Opt(constructorInitializer) )); parser.Add(new Rule("constructorInitializer", ":" - (new Lit("base") | "this") - arguments ) { semantics = SemanticFlags.ConstructorInitializerScope }); parser.Add(new Rule("constructorBody", "{" - statementList - "}" | ";" ) { semantics = SemanticFlags.MethodBodyScope }); parser.Add(new Rule("destructorDeclaration", destructorDeclarator - destructorBody ) { semantics = SemanticFlags.MethodDeclarationScope | SemanticFlags.DestructorDeclarator }); parser.Add(new Rule("destructorDeclarator", "~" - new Opt("extern") - IDENTIFIER - "(" - ")" )); parser.Add(new Rule("destructorBody", "{" - statementList - "}" | ";" ) { semantics = SemanticFlags.MethodBodyScope }); parser.Add(new Rule("constantDeclaration", "const" - type - constantDeclarators - ";" )); parser.Add(new Rule("constantDeclarators", constantDeclarator - new Many("," - constantDeclarator) )); parser.Add(new Rule("constantDeclarator", NAME - "=" - constantExpression ) { semantics = SemanticFlags.ConstantDeclarator }); parser.Add(new Rule("constantExpression", expression | ".EXPECTEDTYPE" )); var methodHeader = new Id("methodHeader"); var methodBody = new Id("methodBody"); var formalParameter = new Id("formalParameter"); var fixedParameter = new Id("fixedParameter"); var parameterModifier = new Id("parameterModifier"); var defaultArgument = new Id("defaultArgument"); var parameterArray = new Id("parameterArray"); var statement = new Id("statement"); var typeVariableName = new Id("typeVariableName"); var typeParameterConstraintList = new Id("typeParameterConstraintList"); var secondaryConstraintList = new Id("secondaryConstraintList"); var secondaryConstraint = new Id("secondaryConstraint"); var constructorConstraint = new Id("constructorConstraint"); var WHERE = new Id("WHERE"); parser.Add(new Rule("methodDeclaration", methodHeader - methodBody ) { semantics = SemanticFlags.MethodDeclarationScope | SemanticFlags.MethodDeclarator }); parser.Add(new Rule("methodHeader", memberName - "(" - new Opt(formalParameterList) - ")" - new Opt(typeParameterConstraintsClauses) )); parser.Add(new Rule("typeParameterConstraintsClauses", typeParameterConstraintsClause - new Many(typeParameterConstraintsClause) ) );//{ semantics = SemanticFlags.TypeParameterConstraintsScope }); parser.Add(new Rule("WHERE", new If(s => s.Current.text == "where", IDENTIFIER) | "where" ) { contextualKeyword = true }); parser.Add(new Rule("typeParameterConstraintsClause", WHERE - typeVariableName - ":" - typeParameterConstraintList ) );//{ semantics = SemanticFlags.TypeParameterConstraint }); parser.Add(new Rule("typeParameterConstraintList", (new Lit("class") | "struct") - new Opt("," - secondaryConstraintList) | secondaryConstraintList )); parser.Add(new Rule("secondaryConstraintList", secondaryConstraint - new Opt("," - new Id("secondaryConstraintList")) | constructorConstraint )); parser.Add(new Rule("secondaryConstraint", typeName // | typeVariableName )); parser.Add(new Rule("typeVariableName", IDENTIFIER )); parser.Add(new Rule("constructorConstraint", new Lit("new") - "(" - ")" )); //primary_constraint: // class_type // | 'class' // | 'struct' ; parser.Add(new Rule("methodBody", "{" - statementList - "}" | ";" ) { semantics = SemanticFlags.MethodBodyScope }); parser.Add(new Rule("block", "{" - statementList - "}" | ";" ) { semantics = SemanticFlags.CodeBlockScope }); parser.Add(new Rule("statementList", new Many(new IfNot(new Seq( "default", ":" ), statement)) )); // var declarationStatement = new Id("declarationStatement"); var labeledStatement = new Id("labeledStatement"); var embeddedStatement = new Id("embeddedStatement"); var selectionStatement = new Id("selectionStatement"); var iterationStatement = new Id("iterationStatement"); var jumpStatement = new Id("jumpStatement"); var tryStatement = new Id("tryStatement"); var lockStatement = new Id("lockStatement"); var usingStatement = new Id("usingStatement"); var yieldStatement = new Id("yieldStatement"); var expressionStatement = new Id("expressionStatement"); var breakStatement = new Id("breakStatement"); var continueStatement = new Id("continueStatement"); var gotoStatement = new Id("gotoStatement"); var returnStatement = new Id("returnStatement"); var throwStatement = new Id("throwStatement"); var checkedStatement = new Id("checkedStatement"); var uncheckedStatement = new Id("uncheckedStatement"); var localVariableDeclaration = new Id("localVariableDeclaration"); var localVariableType = new Id("localVariableType"); var localVariableDeclarators = new Id("localVariableDeclarators"); var localVariableDeclarator = new Id("localVariableDeclarator"); var localVariableInitializer = new Id("localVariableInitializer"); //var stackallocInitializer = new Id("stackallocInitializer"); var localConstantDeclaration = new Id("localConstantDeclaration"); //var unmanagedType = new Id("unmanagedType"); var resourceAcquisition = new Id("resourceAcquisition"); var VAR = new Id("VAR"); parser.Add(new Rule("VAR", //new If(s => s.Current.text == "var", IDENTIFIER) IDENTIFIER | "var" ) { contextualKeyword = true }); parser.Add(new Rule("statement", new If((type | "var") - IDENTIFIER - (new Lit(";") | "=" | "[" | ","), localVariableDeclaration - ";") | new If(IDENTIFIER - ":", labeledStatement) | localConstantDeclaration | embeddedStatement )); // parser.Add(new Rule("declarationStatement", // new Seq( localVariableDeclaration | localConstantDeclaration, ";" ) // )); parser.Add(new Rule("localVariableDeclaration", localVariableType - localVariableDeclarators )); parser.Add(new Rule("localVariableType", new If(s => s.Current.text == "var", VAR) | type )); parser.Add(new Rule("localVariableDeclarators", localVariableDeclarator - new Many("," - localVariableDeclarator) )); parser.Add(new Rule("localVariableDeclarator", NAME - new Opt("=" - localVariableInitializer) ) { semantics = SemanticFlags.LocalVariableDeclarator }); parser.Add(new Rule("localVariableInitializer", expression | arrayInitializer //| stackallocInitializer | ".EXPECTEDTYPE" ) { semantics = SemanticFlags.LocalVariableInitializerScope }); //parser.Add(new Rule("stackallocInitializer", // new Seq( "stackalloc", unmanagedType, "[", expression, "]" ) // )); parser.Add(new Rule("localConstantDeclaration", "const" - type - constantDeclarators - ";" )); //parser.Add(new Rule("unmanagedType", // type // )); parser.Add(new Rule("labeledStatement", IDENTIFIER - ":" - statement ) { semantics = SemanticFlags.LabeledStatement }); var YIELD = new Id("YIELD"); parser.Add(new Rule("YIELD", //new If(s => s.Current.text == "yield", IDENTIFIER) IDENTIFIER | "yield" ){ contextualKeyword = true }); parser.Add(new Rule("embeddedStatement", block | selectionStatement // if, switch | iterationStatement // while, do, for, foreach | jumpStatement // break, continue, goto, return, throw | tryStatement | lockStatement | usingStatement | new If( s => { if (s.Current.text != "yield") return false; string next = s.Lookahead(1).text; return next == "return" || next == "break"; }, yieldStatement) | "yield return" | "yield break;" // auto-completion hint only, while the actual code will be handled by the previous line | new If(new Lit("checked") - "{", checkedStatement) | new If(new Lit("unchecked") - "{", uncheckedStatement) | expressionStatement // expression! | ".STATEMENT" ) { semantics = SemanticFlags.CodeBlockScope }); parser.Add(new Rule("lockStatement", new Seq( "lock", "(", expression, ")", embeddedStatement ) )); parser.Add(new Rule("checkedStatement", new Seq( "checked", block ) )); parser.Add(new Rule("uncheckedStatement", new Seq( "unchecked", block ) )); parser.Add(new Rule("usingStatement", new Seq( "using", "(", resourceAcquisition, ")", embeddedStatement ) ) { semantics = SemanticFlags.UsingStatementScope }); parser.Add(new Rule("resourceAcquisition", new If(localVariableType - IDENTIFIER, localVariableDeclaration) | expression )); parser.Add(new Rule("yieldStatement", YIELD - (( "return" - expression - ";" ) | ( new Lit("break") - ";" )) )); var ifStatement = new Id("ifStatement"); var elseStatement = new Id("elseStatement"); var switchStatement = new Id("switchStatement"); var booleanExpression = new Id("booleanExpression"); var switchBlock = new Id("switchBlock"); var switchSection = new Id("switchSection"); var switchLabel = new Id("switchLabel"); var statementExpression = new Id("statementExpression"); parser.Add(new Rule("selectionStatement", ifStatement | switchStatement )); parser.Add(new Rule("ifStatement", new Lit("if") - "(" - booleanExpression - ")" - embeddedStatement - new Opt(elseStatement) )); parser.Add(new Rule("elseStatement", "else" - embeddedStatement )); parser.Add(new Rule("switchStatement", new Lit("switch") - "(" - expression - ")" - switchBlock )); parser.Add(new Rule("switchBlock", "{" - new Many(switchSection) - "}" ) { semantics = SemanticFlags.SwitchBlockScope }); parser.Add(new Rule("switchSection", new Many(switchLabel) - statement - statementList )); parser.Add(new Rule("switchLabel", "case" - constantExpression - ":" | new Seq( "default", ":" ) )); parser.Add(new Rule("expressionStatement", statementExpression - ";" )); parser.Add(new Rule("jumpStatement", breakStatement | continueStatement | gotoStatement | returnStatement | throwStatement )); parser.Add(new Rule("breakStatement", new Seq( "break", ";" ) )); parser.Add(new Rule("continueStatement", new Seq( "continue", ";" ) )); parser.Add(new Rule("gotoStatement", "goto" - ( IDENTIFIER | "case" - constantExpression | "default") - ";" )); parser.Add(new Rule("returnStatement", "return" - new Opt(expression) - ";" )); parser.Add(new Rule("throwStatement", "throw" - new Opt(expression) - ";" )); var catchClauses = new Id("catchClauses"); var finallyClause = new Id("finallyClause"); var specificCatchClauses = new Id("specificCatchClauses"); var specificCatchClause = new Id("specificCatchClause"); var catchExceptionIdentifier = new Id("catchExceptionIdentifier"); var generalCatchClause = new Id("generalCatchClause"); parser.Add(new Rule("tryStatement", "try" - block - (catchClauses - new Opt(finallyClause) | finallyClause) )); parser.Add(new Rule("catchClauses", new If(new Seq( "catch", "(" ), specificCatchClauses - new Opt(generalCatchClause)) | generalCatchClause )); parser.Add(new Rule("specificCatchClauses", specificCatchClause - new Many(new If(new Seq( "catch", "(" ), specificCatchClause )) )); parser.Add(new Rule("specificCatchClause", new Lit("catch") - "(" - exceptionClassType - new Opt(catchExceptionIdentifier) - ")" - block ) { semantics = SemanticFlags.SpecificCatchScope }); parser.Add(new Rule("catchExceptionIdentifier", NAME ) { semantics = SemanticFlags.CatchExceptionParameterDeclaration }); parser.Add(new Rule("generalCatchClause", "catch" - block )); parser.Add(new Rule("finallyClause", "finally" - block )); parser.Add(new Rule("formalParameterList", formalParameter - new Many("," - formalParameter) ) { semantics = SemanticFlags.FormalParameterListScope }); parser.Add(new Rule("formalParameter", attributes - (fixedParameter | parameterArray) // | "__arglist" )); parser.Add(new Rule("fixedParameter", new Opt(parameterModifier) - type - NAME - new Opt(defaultArgument) ) { semantics = SemanticFlags.FixedParameterDeclaration }); parser.Add(new Rule("parameterModifier", new Lit("ref") | "out" | "this" )); parser.Add(new Rule("defaultArgument", "=" - (expression | ".EXPECTEDTYPE") )); parser.Add(new Rule("parameterArray", "params" - type - NAME ) { semantics = SemanticFlags.ParameterArrayDeclaration }); var whileStatement = new Id("whileStatement"); var doStatement = new Id("doStatement"); var forStatement = new Id("forStatement"); var foreachStatement = new Id("foreachStatement"); var forInitializer = new Id("forInitializer"); //var forCondition = new Id("forCondition"); var forIterator = new Id("forIterator"); var statementExpressionList = new Id("statementExpressionList"); parser.Add(new Rule("iterationStatement", whileStatement | doStatement | forStatement | foreachStatement )); parser.Add(new Rule("whileStatement", new Seq("while", "(", booleanExpression, ")", embeddedStatement) )); parser.Add(new Rule("doStatement", "do" - embeddedStatement - "while" - "(" - booleanExpression - ")" - ";" )); parser.Add(new Rule("forStatement", new Seq("for", "(", new Opt(forInitializer), ";", new Opt(booleanExpression), ";", new Opt(forIterator), ")", embeddedStatement) ) { semantics = SemanticFlags.ForStatementScope }); parser.Add(new Rule("forInitializer", new If(localVariableType - IDENTIFIER, localVariableDeclaration) | statementExpressionList )); parser.Add(new Rule("forIterator", statementExpressionList )); parser.Add(new Rule("foreachStatement", new Lit("foreach") - "(" - localVariableType - NAME - "in" - expression - ")" - embeddedStatement ) { semantics = SemanticFlags.ForStatementScope | SemanticFlags.ForEachVariableDeclaration }); parser.Add(new Rule("statementExpressionList", new Seq( statementExpression, new Many(new Seq( ",", statementExpression )) ) )); // TODO: should be assignment, call, increment, decrement, and new object expressions parser.Add(new Rule("statementExpression", expression )); var accessorDeclarations = new Id("accessorDeclarations"); var getAccessorDeclaration = new Id("getAccessorDeclaration"); var setAccessorDeclaration = new Id("setAccessorDeclaration"); var accessorModifiers = new Id("accessorModifiers"); var accessorBody = new Id("accessorBody"); parser.Add(new Rule("indexerDeclaration", new Lit("this") - "[" - formalParameterList - "]" - "{" - accessorDeclarations - "}" ) { semantics = SemanticFlags.IndexerDeclaration | SemanticFlags.AccessorsListScope }); parser.Add(new Rule("propertyDeclaration", memberName - "{" - accessorDeclarations - "}" ) { semantics = SemanticFlags.PropertyDeclaration | SemanticFlags.AccessorsListScope }); parser.Add(new Rule("accessorModifiers", "internal" - new Opt("protected") | "protected" - new Opt("internal") | "public" | "private" )); var GET = new Id("GET"); var SET = new Id("SET"); parser.Add(new Rule("GET", IDENTIFIER | "get" ){ contextualKeyword = true } ); parser.Add(new Rule("SET", IDENTIFIER | "set" ){ contextualKeyword = true } ); parser.Add(new Rule("accessorDeclarations", attributes - new Opt(accessorModifiers) - (new If(s => s.Current.text == "get", getAccessorDeclaration - new Opt(attributes - new Opt(accessorModifiers) - setAccessorDeclaration)) | setAccessorDeclaration - new Opt(attributes - new Opt(accessorModifiers) - getAccessorDeclaration)) )); parser.Add(new Rule("getAccessorDeclaration", GET - accessorBody ) { semantics = SemanticFlags.GetAccessorDeclaration }); parser.Add(new Rule("setAccessorDeclaration", SET - accessorBody ) { semantics = SemanticFlags.SetAccessorDeclaration }); parser.Add(new Rule("accessorBody", "{" - statementList - "}" | ";" ) { semantics = SemanticFlags.AccessorBodyScope }); var eventDeclarators = new Id("eventDeclarators"); var eventDeclarator = new Id("eventDeclarator"); var eventWithAccessorsDeclaration = new Id("eventWithAccessorsDeclaration"); var eventAccessorDeclarations = new Id("eventAccessorDeclarations"); var addAccessorDeclaration = new Id("addAccessorDeclaration"); var removeAccessorDeclaration = new Id("removeAccessorDeclaration"); parser.Add(new Rule("eventDeclaration", "event" - typeName - ( new If(memberName - "{", eventWithAccessorsDeclaration) | eventDeclarators - ";" ) )); parser.Add(new Rule("eventWithAccessorsDeclaration", memberName - "{" - eventAccessorDeclarations - "}" ) { semantics = SemanticFlags.EventWithAccessorsDeclaration | SemanticFlags.AccessorsListScope }); parser.Add(new Rule("eventDeclarators", eventDeclarator - new Many("," - eventDeclarator) )); parser.Add(new Rule("eventDeclarator", NAME - new Opt("=" - variableInitializer) ) { semantics = SemanticFlags.EventDeclarator }); parser.Add(new Rule("eventAccessorDeclarations", attributes - ( new If(s => s.Current.text == "add", addAccessorDeclaration - attributes - removeAccessorDeclaration) | removeAccessorDeclaration - attributes - addAccessorDeclaration ) )); var ADD = new Id("ADD"); var REMOVE = new Id("REMOVE"); parser.Add(new Rule("ADD", IDENTIFIER | "add" ) { contextualKeyword = true }); parser.Add(new Rule("REMOVE", IDENTIFIER | "remove" ) { contextualKeyword = true }); parser.Add(new Rule("addAccessorDeclaration", ADD - accessorBody ) {semantics = SemanticFlags.AddAccessorDeclaration }); parser.Add(new Rule("removeAccessorDeclaration", REMOVE - accessorBody ) {semantics = SemanticFlags.RemoveAccessorDeclaration }); parser.Add(new Rule("fieldDeclaration", variableDeclarators - ";" )); parser.Add(new Rule("variableDeclarators", new Seq( variableDeclarator, new Many(new Seq( ",", variableDeclarator )) ) )); parser.Add(new Rule("variableDeclarator", NAME - new Opt("=" - variableInitializer) ) { semantics = SemanticFlags.VariableDeclarator }); parser.Add(new Rule("variableInitializer", expression | arrayInitializer | ".EXPECTEDTYPE" )); //parser.Add(new Rule("arrayInitializer", // new Seq( "{", new Opt(variableInitializerList), "}" ) // )); parser.Add(new Rule("modifiers", new Many( new Lit("new") | "public" | "protected" | "internal" | "private" | "abstract" | "sealed" | "static" | "readonly" | "volatile" | "virtual" | "override" | "extern" ) )); var operatorDeclarator = new Id("operatorDeclarator"); var operatorBody = new Id("operatorBody"); var operatorParameter = new Id("operatorParameter"); var binaryOperatorPart = new Id("binaryOperatorPart"); var unaryOperatorPart = new Id("unaryOperatorPart"); var overloadableBinaryOperator = new Id("overloadableBinaryOperator"); var overloadableUnaryOperator = new Id("overloadableUnaryOperator"); var conversionOperatorDeclarator = new Id("conversionOperatorDeclarator"); parser.Add(new Rule("operatorDeclaration", operatorDeclarator - operatorBody )); parser.Add(new Rule("operatorDeclarator", new Seq( "operator", new Seq( new Lit("+") | "-", "(", operatorParameter, binaryOperatorPart | unaryOperatorPart ) | overloadableUnaryOperator - "(" - operatorParameter - unaryOperatorPart | overloadableBinaryOperator - "(" - operatorParameter - binaryOperatorPart) ) { semantics = SemanticFlags.OperatorDeclarator }); parser.Add(new Rule("operatorParameter", type - NAME ) { semantics = SemanticFlags.FixedParameterDeclaration }); parser.Add(new Rule("unaryOperatorPart", ")" )); parser.Add(new Rule("binaryOperatorPart", "," - operatorParameter - ")" )); parser.Add(new Rule("overloadableUnaryOperator", /*'+' | '-' | */ new Lit("!") | "~" | "++" | "--" | "true" | "false" )); parser.Add(new Rule("overloadableBinaryOperator", /*'+' | '-' | */ // >> check needed new Lit("*") | "/" | "%" | "&" | "|" | "^" | "<<" | new If(new Seq(">",">"), new Seq(">",">")) | "==" | "!=" | ">" | "<" | ">=" | "<=" )); parser.Add(new Rule("conversionOperatorDeclaration", conversionOperatorDeclarator - operatorBody )); parser.Add(new Rule("conversionOperatorDeclarator", (new Lit("implicit") | "explicit") - "operator" - type - "(" - operatorParameter - ")" ) { semantics = SemanticFlags.ConversionOperatorDeclarator }); parser.Add(new Rule("operatorBody", "{" - statementList - "}" | ";" ) { semantics = SemanticFlags.MethodBodyScope }); var typeOrGeneric = new Id("typeOrGeneric"); var typeArgumentList = new Id("typeArgumentList"); var unboundTypeRank = new Id("unboundTypeRank"); var structInterfaces = new Id("structInterfaces"); var structBody = new Id("structBody"); var structMemberDeclaration = new Id("structMemberDeclaration"); parser.Add(new Rule("structDeclaration", "struct" - NAME - new Opt(typeParameterList) - new Opt(structInterfaces) - new Opt(typeParameterConstraintsClauses) - structBody - new Opt(";") ) { semantics = SemanticFlags.StructDeclaration | SemanticFlags.TypeDeclarationScope }); //struct_modifier: // 'new' | 'public' | 'protected' | 'internal' | 'private' | 'unsafe' ; parser.Add(new Rule("structInterfaces", ":" - interfaceTypeList ) { semantics = SemanticFlags.StructInterfacesScope }); parser.Add(new Rule("structBody", "{" - new Many(structMemberDeclaration) - "}" ) { semantics = SemanticFlags.StructBodyScope }); parser.Add(new Rule("structMemberDeclaration", new Seq( attributes, modifiers, constantDeclaration | "void" - methodDeclaration | new If(PARTIAL, PARTIAL - ("void" - methodDeclaration | classDeclaration | structDeclaration | interfaceDeclaration)) | new If(IDENTIFIER - "(", constructorDeclaration) | new Seq( type, new If(memberName - "(", methodDeclaration) | new If(memberName - "{", propertyDeclaration) | new If(memberName - "." - "this", typeName - "." - indexerDeclaration) | new If(predefinedType - "." - "this", predefinedType - "." - indexerDeclaration) | indexerDeclaration | fieldDeclaration | operatorDeclaration ) | classDeclaration | structDeclaration | interfaceDeclaration | enumDeclaration | delegateDeclaration | eventDeclaration | conversionOperatorDeclaration | ".STRUCTBODY" ) )); var interfaceBase = new Id("interfaceBase"); var interfaceBody = new Id("interfaceBody"); var interfaceMemberDeclaration = new Id("interfaceMemberDeclaration"); var interfaceMethodDeclaration = new Id("interfaceMethodDeclaration"); var interfaceEventDeclaration = new Id("interfaceEventDeclaration"); var interfacePropertyDeclaration = new Id("interfacePropertyDeclaration"); var interfaceIndexerDeclaration = new Id("interfaceIndexerDeclaration"); var interfaceAccessorDeclarations = new Id("interfaceAccessorDeclarations"); var interfaceGetAccessorDeclaration = new Id("interfaceGetAccessorDeclaration"); var interfaceSetAccessorDeclaration = new Id("interfaceSetAccessorDeclaration"); parser.Add(new Rule("interfaceDeclaration", "interface" - NAME - new Opt(typeParameterList) - new Opt(interfaceBase) - new Opt(typeParameterConstraintsClauses) - interfaceBody - new Opt(";") ) { semantics = SemanticFlags.InterfaceDeclaration | SemanticFlags.TypeDeclarationScope }); parser.Add(new Rule("interfaceBase", ":" - interfaceTypeList ) { semantics = SemanticFlags.InterfaceBaseScope }); parser.Add(new Rule("interfaceBody", "{" - new Many(interfaceMemberDeclaration) - "}" ) { semantics = SemanticFlags.InterfaceBodyScope }); parser.Add(new Rule("interfaceMemberDeclaration", new Seq( attributes, modifiers, "void" - interfaceMethodDeclaration | interfaceEventDeclaration | new Seq( type, new If(memberName - "(", interfaceMethodDeclaration) | new If(memberName - "{", interfacePropertyDeclaration) | interfaceIndexerDeclaration ) | ".INTERFACEBODY" ) )); parser.Add(new Rule("interfacePropertyDeclaration", NAME - "{" - interfaceAccessorDeclarations - "}" ) { semantics = SemanticFlags.InterfacePropertyDeclaration }); parser.Add(new Rule("interfaceMethodDeclaration", NAME - new Opt(typeParameterList) - "(" - new Opt(formalParameterList) - ")" - new Opt(typeParameterConstraintsClauses) - ";" ) { semantics = SemanticFlags.MethodDeclarationScope | SemanticFlags.InterfaceMethodDeclaration }); parser.Add(new Rule("interfaceEventDeclaration", new Seq( "event", typeName, NAME, ";" ) ) { semantics = SemanticFlags.InterfaceEventDeclaration }); parser.Add(new Rule("interfaceIndexerDeclaration", new Seq( "this", "[", formalParameterList, "]", "{", interfaceAccessorDeclarations, "}" ) ) { semantics = SemanticFlags.InterfaceIndexerDeclaration }); parser.Add(new Rule("interfaceAccessorDeclarations", new Seq( attributes, new If(s => s.Current.text == "get", interfaceGetAccessorDeclaration - new Opt(attributes - interfaceSetAccessorDeclaration)) | interfaceSetAccessorDeclaration - new Opt(attributes - interfaceGetAccessorDeclaration) ) )); parser.Add(new Rule("interfaceGetAccessorDeclaration", GET - ";" ) { semantics = SemanticFlags.InterfaceGetAccessorDeclaration }); parser.Add(new Rule("interfaceSetAccessorDeclaration", SET - ";" ) { semantics = SemanticFlags.InterfaceSetAccessorDeclaration }); var enumBase = new Id("enumBase"); var enumBody = new Id("enumBody"); var enumMemberDeclarations = new Id("enumMemberDeclarations"); var enumMemberDeclaration = new Id("enumMemberDeclaration"); parser.Add(new Rule("enumDeclaration", "enum" - NAME - new Opt(enumBase) - enumBody - new Opt(";") ) { semantics = SemanticFlags.EnumDeclaration | SemanticFlags.TypeDeclarationScope }); parser.Add(new Rule("enumBase", new Seq( ":", integralType ) ) { semantics = SemanticFlags.EnumBaseScope } ); parser.Add(new Rule("enumBody", "{" - new Opt(enumMemberDeclarations) - "}" ) { semantics = SemanticFlags.EnumBodyScope }); parser.Add(new Rule("enumMemberDeclarations", new Seq( enumMemberDeclaration, new Many(new IfNot(new Seq( ",", "}" ) | "}", "," - enumMemberDeclaration)), new Opt(",") ) )); parser.Add(new Rule("enumMemberDeclaration", attributes - NAME - new Opt("=" - constantExpression) ) { semantics = SemanticFlags.EnumMemberDeclaration }); parser.Add(new Rule("delegateDeclaration", "delegate" - ("void" | type) - NAME - new Opt(typeParameterList) - "(" - new Opt(formalParameterList) - ")" - new Opt(typeParameterConstraintsClauses) - ";" ) { semantics = SemanticFlags.DelegateDeclaration | SemanticFlags.TypeDeclarationScope }); var attributeTargetSpecifier = new Id("attributeTargetSpecifier"); var ATTRIBUTETARGET = new Id("ATTRIBUTETARGET"); parser.Add(new Rule("ATTRIBUTETARGET", (IDENTIFIER | "event:" | "return:" | "field:" | "method:" | "param:" | "property:" | "type:" | "assembly:" | "module:") ) { contextualKeyword = true }); parser.Add(new Rule("attributeTargetSpecifier", (new If(s => s.Current.text == "field" || s.Current.text == "method" || s.Current.text == "param" || s.Current.text == "property" || s.Current.text == "type" || s.Current.text == "assembly" || s.Current.text == "module", ATTRIBUTETARGET) | "event" | "return") - ":" )); parser.Add(new Rule("attributes", new Many( "[" - new If(attributeTargetSpecifier, attributeTargetSpecifier) - attribute - new Many("," - attribute) - "]" ) ) { semantics = SemanticFlags.AttributesScope }); parser.Add(new Rule("attribute", typeName - new Opt(attributeArguments) | ".ATTRIBUTE" )); var rankSpecifiers = new Id("rankSpecifiers"); parser.Add(new Rule("type", predefinedType - new Opt("?") - new Opt(rankSpecifiers) | typeName - new Opt("?") - new Opt(rankSpecifiers) )); parser.Add(new Rule("type2", predefinedType - new Opt(rankSpecifiers) | typeName - new Opt(rankSpecifiers) )); //parser.Add(new Rule("typeSpecifier", // predefinedType - new Opt("?") - new Opt(rankSpecifiers) // | typeName - new Opt("?") - new Opt(rankSpecifiers) // )); parser.Add(new Rule("exceptionClassType", typeName | "object" | "string" )); parser.Add(new Rule("nonArrayType", (typeName | simpleType) - new Opt("?") | "object" | "string" )); // parser.Add(new Rule("arrayType", // nonArrayType - rankSpecifiers // )); parser.Add(new Rule("simpleType", numericType | "bool" )); parser.Add(new Rule("numericType", integralType | floatingPointType | "decimal" )); parser.Add(new Rule("integralType", new Lit("sbyte") | "byte" | "short" | "ushort" | "int" | "uint" | "long" | "ulong" | "char" )); parser.Add(new Rule("floatingPointType", new Lit("float") | "double" )); parser.Add(new Rule("typeName", namespaceOrTypeName )); parser.Add(new Rule("globalNamespace", IDENTIFIER | "global" )); parser.Add(new Rule("namespaceOrTypeName", new If(IDENTIFIER - "::", globalNamespace - "::") - typeOrGeneric - new Many("." - typeOrGeneric) )); parser.Add(new Rule("typeOrGeneric", IDENTIFIER - new If("<" - type, typeArgumentList) - new If("<" - (new Lit(",") | ">"), unboundTypeRank) // new If(new Seq(IDENTIFIER, typeArgumentList), new Seq(IDENTIFIER, typeArgumentList)) // | IDENTIFIER )); parser.Add(new Rule("typeArgumentList", "<" - type - new Many("," - type) - ">" )); parser.Add(new Rule("unboundTypeRank", "<" - new Many(",") - ">" )); //parser.Add(new Rule("typeArguments", // type - new Many("," - type) // )); parser.Add(new Rule("rankSpecifier", "[" - new Many(",") - "]" )); var unaryExpression = new Id("unaryExpression"); var assignmentOperator = new Id("assignmentOperator"); var assignment = new Id("assignment"); var nonAssignmentExpression = new Id("nonAssignmentExpression"); var castExpression = new Id("castExpression"); parser.Add(new Rule("expression", new If(unaryExpression - assignmentOperator, assignment) | nonAssignmentExpression )); parser.Add(new Rule("assignment", unaryExpression - assignmentOperator - (expression | ".EXPECTEDTYPE") )); var preIncrementExpression = new Id("preIncrementExpression"); var preDecrementExpression = new Id("preDecrementExpression"); parser.Add(new Rule("unaryExpression", new If("(" - type - ")" - IDENTIFIER, castExpression) | new If(castExpression, castExpression) | primaryExpression - new Many(new Lit("++") | "--") // TODO: Fix this! Post increment operators should be primaryExpressionPart | new Seq( new Lit("+") | "-" | "!", unaryExpression ) | new Seq( "~", unaryExpression | ".EXPECTEDTYPE" ) | preIncrementExpression | preDecrementExpression )); parser.Add(new Rule("castExpression", "(" - type - ")" - unaryExpression )); parser.Add(new Rule("assignmentOperator", new Lit("=") | "+=" | "-=" | "*=" | "/=" | "%=" | "&=" | "|=" | "^=" | "<<=" | new Seq(">", ">=") )); parser.Add(new Rule("preIncrementExpression", "++" - unaryExpression )); parser.Add(new Rule("preDecrementExpression", "--" - unaryExpression )); var brackets = new Id("brackets"); var primaryExpressionStart = new Id("primaryExpressionStart"); var primaryExpressionPart = new Id("primaryExpressionPart"); var objectCreationExpression = new Id("objectCreationExpression"); //var delegateCreationExpression = new Id("delegateCreationExpression"); var anonymousObjectCreationExpression = new Id("anonymousObjectCreationExpression"); var sizeofExpression = new Id("sizeofExpression"); var checkedExpression = new Id("checkedExpression"); var uncheckedExpression = new Id("uncheckedExpression"); var defaultValueExpression = new Id("defaultValueExpression"); var anonymousMethodExpression = new Id("anonymousMethodExpression"); //* parser.Add(new Rule("primaryExpression", primaryExpressionStart - new Many(primaryExpressionPart) | new Seq( "new", ((nonArrayType | ".EXPECTEDTYPE") - (objectCreationExpression | arrayCreationExpression)) | implicitArrayCreationExpression | anonymousObjectCreationExpression, new Many(primaryExpressionPart)) | anonymousMethodExpression )); var parenExpression = new Id("parenExpression"); var typeofExpression = new Id("typeofExpression"); var qidStart = new Id("qidStart"); var qidPart = new Id("qidPart"); var accessIdentifier = new Id("accessIdentifier"); parser.Add(new Rule("typeofExpression", new Lit("typeof") - "(" - (type | "void") - ")" )); parser.Add(new Rule("predefinedType", new Lit("bool") | "byte" | "char" | "decimal" | "double" | "float" | "int" | "long" | "object" | "sbyte" | "short" | "string" | "uint" | "ulong" | "ushort" )); parser.Add(new Rule("qid", qidStart - new Many(qidPart) )); parser.Add(new Rule("qidStart", predefinedType | new If(IDENTIFIER - "<", NAME - typeParameterList) | IDENTIFIER - new Opt("::" - IDENTIFIER) )); parser.Add(new Rule("qidPart", new If("." - IDENTIFIER, accessIdentifier) | "." )); parser.Add(new Rule("primaryExpressionStart", predefinedType | LITERAL | "true" | "false" | new If(IDENTIFIER - typeArgumentList /*- (new Lit("(") | ")" | ":" | ";" | "," | "." | "?" | "==" | "!="*/, IDENTIFIER - typeArgumentList) | new If(IDENTIFIER - "::", globalNamespace - "::") - IDENTIFIER | parenExpression | "this" | "base" | typeofExpression | sizeofExpression | checkedExpression | uncheckedExpression | defaultValueExpression )); //var bracketsOrArguments = new Id("bracketsOrArguments"); var argument = new Id("argument"); var attributeArgument = new Id("attributeArgument"); var expressionList = new Id("expressionList"); var argumentValue = new Id("argumentValue"); var argumentName = new Id("argumentName"); var attributeMemberName = new Id("attributeMemberName"); var variableReference = new Id("variableReference"); parser.Add(new Rule("primaryExpressionPart", accessIdentifier | brackets | arguments )); parser.Add(new Rule("accessIdentifier", "." - IDENTIFIER - new If(typeArgumentList, typeArgumentList) )); //parser.Add(new Rule("bracketsOrArguments", // brackets | arguments // )); parser.Add(new Rule("brackets", "[" - new Opt(expressionList) - "]" )); parser.Add(new Rule("expressionList", expression - new Many("," - expression) )); parser.Add(new Rule("parenExpression", "(" - expression - ")" )); parser.Add(new Rule("arguments", "(" - argumentList - ")" )); parser.Add(new Rule("attributeArguments", "(" - attributeArgumentList - ")" )); parser.Add(new Rule("argumentList", new Opt(argument - new Many("," - argument)) ) { semantics = SemanticFlags.ArgumentListScope }); parser.Add(new Rule("attributeArgumentList", new Opt(attributeArgument - new Many("," - attributeArgument)) ) { semantics = SemanticFlags.AttributeArgumentsScope }); parser.Add(new Rule("argument", new If(IDENTIFIER - ":", argumentName - argumentValue) | argumentValue )); parser.Add(new Rule("attributeArgument", new If(IDENTIFIER - "=", attributeMemberName - argumentValue) | new If(IDENTIFIER - ":", argumentName - argumentValue) | argumentValue )); parser.Add(new Rule("argumentName", IDENTIFIER - ":" )); parser.Add(new Rule("attributeMemberName", IDENTIFIER - "=" )); parser.Add(new Rule("argumentValue", expression | new Seq( new Lit("out") | "ref", variableReference ) | ".EXPECTEDTYPE" )); parser.Add(new Rule("variableReference", expression )); parser.Add(new Rule("rankSpecifiers", "[" - new Many(",") - "]" - new Many("[" - new Many(",") - "]") )); //parser.Add(new Rule("delegateCreationExpression", // new Seq( typeName, "(", typeName, ")" ) // )); var anonymousObjectInitializer = new Id("anonymousObjectInitializer"); var memberDeclaratorList = new Id("memberDeclaratorList"); var memberDeclarator = new Id("memberDeclarator"); var memberAccessExpression = new Id("memberAccessExpression"); parser.Add(new Rule("anonymousObjectCreationExpression", anonymousObjectInitializer ) { semantics = SemanticFlags.AnonymousObjectCreation }); parser.Add(new Rule("anonymousObjectInitializer", "{" - new Opt(memberDeclaratorList) - new Opt(",") - "}" )); parser.Add(new Rule("memberDeclaratorList", memberDeclarator - new Many( new If("," - IDENTIFIER, "," - memberDeclarator) ) )); parser.Add(new Rule("memberDeclarator", new If(IDENTIFIER - "=", IDENTIFIER - "=" - expression) | memberAccessExpression ) { semantics = SemanticFlags.MemberDeclarator }); parser.Add(new Rule("memberAccessExpression", expression )); //parser.Add(new Rule("primaryOrArrayCreationExpression", // new If( /*arrayCreationExpression*/ "new" - new Opt(nonArrayType) - "[", arrayCreationExpression ) // | primaryExpression // )); var objectOrCollectionInitializer = new Id("objectOrCollectionInitializer"); var objectInitializer = new Id("objectInitializer"); var collectionInitializer = new Id("collectionInitializer"); var elementInitializerList = new Id("elementInitializerList"); var elementInitializer = new Id("elementInitializer"); var memberInitializerList = new Id("memberInitializerList"); var memberInitializer = new Id("memberInitializer"); parser.Add(new Rule("objectCreationExpression", arguments - new Opt(objectOrCollectionInitializer) | objectOrCollectionInitializer )); parser.Add(new Rule("objectOrCollectionInitializer", "{" - ((new If(IDENTIFIER - "=", objectInitializer) | "}" | collectionInitializer)) )); parser.Add(new Rule("collectionInitializer", elementInitializerList - new Opt(",") - "}" )); parser.Add(new Rule("elementInitializerList", elementInitializer - new Many(new IfNot(new Opt(",") - "}", "," - elementInitializer)) )); parser.Add(new Rule("elementInitializer", nonAssignmentExpression | "{" - expressionList - "}" | ".EXPECTEDTYPE" )); parser.Add(new Rule("objectInitializer", new Opt(memberInitializerList) - new Opt(",") - (new Lit("}") | ".MEMBERINITIALIZER") )); parser.Add(new Rule("memberInitializerList", memberInitializer - new Many(new IfNot(new Opt(",") - "}", "," - memberInitializer)) ) { semantics = SemanticFlags.MemberInitializerScope }); parser.Add(new Rule("memberInitializer", (IDENTIFIER | ".MEMBERINITIALIZER") - "=" - (expression | objectOrCollectionInitializer | ".EXPECTEDTYPE") )); //var invocationPart = new Id("invocationPart"); var explicitAnonymousFunctionParameterList = new Id("explicitAnonymousFunctionParameterList"); var explicitAnonymousFunctionParameter = new Id("explicitAnonymousFunctionParameter"); var anonymousFunctionParameterModifier = new Id("anonymousFunctionParameterModifier"); var explicitAnonymousFunctionSignature = new Id("explicitAnonymousFunctionSignature"); parser.Add(new Rule("arrayCreationExpression", new If( new Seq("[", new Lit(",") | "]"), rankSpecifiers - arrayInitializer ) | "[" - expressionList - "]" - new Opt(rankSpecifiers) - new Opt(arrayInitializer) )); parser.Add(new Rule("implicitArrayCreationExpression", rankSpecifier - arrayInitializer )); //parser.Add(new Rule("invocationPart", // accessIdentifier | brackets // )); parser.Add(new Rule("arrayInitializer", "{" - new Opt(variableInitializerList) - "}" )); parser.Add(new Rule("variableInitializerList", variableInitializer - new Many(new IfNot(new Seq(",", "}"), "," - new Opt(variableInitializer))) - new Opt(",") )); parser.Add(new Rule("sizeofExpression", new Lit("sizeof") - "(" - simpleType - ")" )); parser.Add(new Rule("checkedExpression", new Lit("checked") - "(" - expression - ")" )); parser.Add(new Rule("uncheckedExpression", new Lit("unchecked") - "(" - expression - ")" )); parser.Add(new Rule("defaultValueExpression", new Seq( "default", "(", type, ")" ) )); var anonymousFunctionSignature = new Id("anonymousFunctionSignature"); var lambdaExpression = new Id("lambdaExpression"); var queryExpression = new Id("queryExpression"); var conditionalExpression = new Id("conditionalExpression"); var lambdaExpressionBody = new Id("lambdaExpressionBody"); var anonymousMethodBody = new Id("anonymousMethodBody"); var implicitAnonymousFunctionParameterList = new Id("implicitAnonymousFunctionParameterList"); var implicitAnonymousFunctionParameter = new Id("implicitAnonymousFunctionParameter"); var FROM = new Id("FROM"); parser.Add(new Rule("FROM", IDENTIFIER | "from") { contextualKeyword = true }); var SELECT = new Id("SELECT"); parser.Add(new Rule("SELECT", IDENTIFIER) { contextualKeyword = true }); var GROUP = new Id("GROUP"); parser.Add(new Rule("GROUP", IDENTIFIER | "group") { contextualKeyword = true }); var INTO = new Id("INTO"); parser.Add(new Rule("INTO", new If(s => s.Current.text == "into", IDENTIFIER | "into")) { contextualKeyword = true }); var ORDERBY = new Id("ORDERBY"); parser.Add(new Rule("ORDERBY", new If(s => s.Current.text == "orderby", IDENTIFIER | "orderby")) { contextualKeyword = true }); var JOIN = new Id("JOIN"); parser.Add(new Rule("JOIN", new If(s => s.Current.text == "join", IDENTIFIER | "join")) { contextualKeyword = true }); var LET = new Id("LET"); parser.Add(new Rule("LET", new If(s => s.Current.text == "let", IDENTIFIER | "let")) { contextualKeyword = true }); var ON = new Id("ON"); parser.Add(new Rule("ON", new If(s => s.Current.text == "on", IDENTIFIER | "on")) { contextualKeyword = true }); var EQUALS = new Id("EQUALS"); parser.Add(new Rule("EQUALS", new If(s => s.Current.text == "equals", IDENTIFIER | "equals")) { contextualKeyword = true }); var BY = new Id("BY"); parser.Add(new Rule("BY", new If(s => s.Current.text == "by", IDENTIFIER | "by")) { contextualKeyword = true }); var ASCENDING = new Id("ASCENDING"); parser.Add(new Rule("ASCENDING", IDENTIFIER | "ascending") { contextualKeyword = true }); var DESCENDING = new Id("DESCENDING"); parser.Add(new Rule("DESCENDING", IDENTIFIER | "descending") { contextualKeyword = true }); var fromClause = new Id("fromClause"); parser.Add(new Rule("nonAssignmentExpression", new If(anonymousFunctionSignature - "=>", lambdaExpression) | new If(IDENTIFIER - IDENTIFIER - "in", queryExpression) | new If(IDENTIFIER - type - IDENTIFIER - "in", queryExpression) | conditionalExpression )); parser.Add(new Rule("lambdaExpression", anonymousFunctionSignature - "=>" - lambdaExpressionBody ) { semantics = SemanticFlags.LambdaExpressionScope | SemanticFlags.LambdaExpressionDeclaration }); parser.Add(new Rule("anonymousFunctionSignature", new Seq( "(", new Opt( new If(new Seq(IDENTIFIER, new Lit(",") | ")"), implicitAnonymousFunctionParameterList) | explicitAnonymousFunctionParameterList), ")") | implicitAnonymousFunctionParameter ));// { semantics = SemanticFlags.LambdaExpressionDeclaration }); parser.Add(new Rule("implicitAnonymousFunctionParameterList", implicitAnonymousFunctionParameter - new Many("," - implicitAnonymousFunctionParameter) )); parser.Add(new Rule("implicitAnonymousFunctionParameter", IDENTIFIER ) { semantics = SemanticFlags.ImplicitParameterDeclaration }); parser.Add(new Rule("lambdaExpressionBody", expression | "{" - statementList - "}" ) { semantics = SemanticFlags.LambdaExpressionBodyScope }); parser.Add(new Rule("anonymousMethodExpression", "delegate" - new Opt(explicitAnonymousFunctionSignature) - anonymousMethodBody ) { semantics = SemanticFlags.AnonymousMethodDeclaration | SemanticFlags.AnonymousMethodScope }); parser.Add(new Rule("anonymousMethodBody", "{" - statementList - "}" ) { semantics = SemanticFlags.AnonymousMethodBodyScope }); parser.Add(new Rule("explicitAnonymousFunctionSignature", "(" - new Opt(explicitAnonymousFunctionParameterList) - ")" ) { semantics = SemanticFlags.FormalParameterListScope }); parser.Add(new Rule("explicitAnonymousFunctionParameterList", explicitAnonymousFunctionParameter - new Many("," - explicitAnonymousFunctionParameter) )); parser.Add(new Rule("explicitAnonymousFunctionParameter", new Opt(anonymousFunctionParameterModifier) - type - NAME ) { semantics = SemanticFlags.ExplicitParameterDeclaration }); parser.Add(new Rule("anonymousFunctionParameterModifier", new Lit("ref") | "out" )); var queryBody = new Id("queryBody"); var queryBodyClause = new Id("queryBodyClause"); var queryContinuation = new Id("queryContinuation"); var letClause = new Id("letClause"); var whereClause = new Id("whereClause"); var joinClause = new Id("joinClause"); var orderbyClause = new Id("orderbyClause"); var orderingList = new Id("orderingList"); var ordering = new Id("ordering"); var selectClause = new Id("selectClause"); var groupClause = new Id("groupClause"); parser.Add(new Rule("queryExpression", fromClause - queryBody ) { semantics = SemanticFlags.QueryExpressionScope }); parser.Add(new Rule("fromClause", FROM - (new If(NAME - "in", NAME) | type - NAME) - "in" - expression ) { semantics = SemanticFlags.FromClauseVariableDeclaration }); parser.Add(new Rule("queryBody", new Many( new If(s => s.Current.text == "from" | s.Current.text == "let" | s.Current.text == "join" | s.Current.text == "orderby" | s.Current.text == "where", queryBodyClause) ) - (new If(s => s.Current.text == "select", selectClause) | "select" | groupClause) - new Opt(queryContinuation) ) { semantics = SemanticFlags.QueryBodyScope }); parser.Add(new Rule("queryContinuation", INTO - IDENTIFIER - queryBody )); parser.Add(new Rule("queryBodyClause", new If(s => s.Current.text == "from", fromClause) | new If(s => s.Current.text == "let", letClause) | new If(s => s.Current.text == "join", joinClause) | new If(s => s.Current.text == "orderby", orderbyClause) | whereClause )); parser.Add(new Rule("joinClause", JOIN - new Opt(type) - IDENTIFIER - "in" - expression - ON - expression - EQUALS - expression - new Opt(INTO - IDENTIFIER) )); parser.Add(new Rule("letClause", LET - IDENTIFIER - "=" - expression )); parser.Add(new Rule("orderbyClause", ORDERBY - orderingList )); parser.Add(new Rule("orderingList", ordering - new Many("," - ordering) )); parser.Add(new Rule("ordering", expression - new Opt(new If(s => s.Current.text == "ascending", ASCENDING) | DESCENDING) )); parser.Add(new Rule("selectClause", SELECT - expression )); parser.Add(new Rule("groupClause", GROUP- expression - BY - expression )); parser.Add(new Rule("whereClause", WHERE - booleanExpression )); parser.Add(new Rule("booleanExpression", expression )); var nullCoalescingExpression = new Id("nullCoalescingExpression"); var conditionalOrExpression = new Id("conditionalOrExpression"); var conditionalAndExpression = new Id("conditionalAndExpression"); var inclusiveOrExpression = new Id("inclusiveOrExpression"); var exclusiveOrExpression = new Id("exclusiveOrExpression"); var andExpression = new Id("andExpression"); var equalityExpression = new Id("equalityExpression"); var relationalExpression = new Id("relationalExpression"); var shiftExpression = new Id("shiftExpression"); var additiveExpression = new Id("additiveExpression"); var multiplicativeExpression = new Id("multiplicativeExpression"); parser.Add(new Rule("conditionalExpression", nullCoalescingExpression - new Opt("?" - expression - ":" - expression) ) { autoExclude = true }); parser.Add(new Rule("nullCoalescingExpression", conditionalOrExpression - new Many("??" - conditionalOrExpression) ) { autoExclude = true }); parser.Add(new Rule("conditionalOrExpression", conditionalAndExpression - new Many("||" - conditionalAndExpression) ) { autoExclude = true }); parser.Add(new Rule("conditionalAndExpression", inclusiveOrExpression - new Many("&&" - inclusiveOrExpression) ) { autoExclude = true }); parser.Add(new Rule("inclusiveOrExpression", exclusiveOrExpression - new Many("|" - (exclusiveOrExpression | ".EXPECTEDTYPE")) ) { autoExclude = true }); parser.Add(new Rule("exclusiveOrExpression", andExpression - new Many("^" - andExpression) ) { autoExclude = true }); parser.Add(new Rule("andExpression", equalityExpression - new Many("&" - (equalityExpression | ".EXPECTEDTYPE")) ) { autoExclude = true }); parser.Add(new Rule("equalityExpression", relationalExpression - new Many( (new Lit("==") | "!=") - (relationalExpression | ".EXPECTEDTYPE") ) ) { autoExclude = true }); parser.Add(new Rule("relationalExpression", new Seq( shiftExpression, new Many( new Seq( new Lit("<") | ">" | "<=" | ">=", (shiftExpression | ".EXPECTEDTYPE") ) | new Seq( new Lit("is") | "as", new If(type2 - "?" - expression - ":", type2) | type) )) ) { autoExclude = true }); parser.Add(new Rule("shiftExpression", new Seq( additiveExpression, new Many(new If(new Seq(">", ">") | "<<", new Seq( new Seq(">", ">") | "<<", additiveExpression )))) ) { autoExclude = true }); parser.Add(new Rule("additiveExpression", new Seq( multiplicativeExpression, new Many(new Seq( new Lit("+") | "-", multiplicativeExpression )) ) ) { autoExclude = true }); parser.Add(new Rule("multiplicativeExpression", new Seq( unaryExpression, new Many(new Seq( new Lit("*") | "/" | "%", unaryExpression )) ) ) { autoExclude = true }); Rule.debug = false; parser.InitializeGrammar(); InitializeTokenCategories(); //Debug.Log(parser); }
/// <summary> /// Validates the name ID. /// </summary> /// <param name="nameId">The name ID.</param> public void ValidateNameId(NameId nameId) { if (nameId == null) { throw new ArgumentNullException("nameId"); } if (string.IsNullOrEmpty(nameId.Format)) { return; } if (!Uri.IsWellFormedUriString(nameId.Format, UriKind.Absolute)) { throw new Saml20FormatException("NameID element has Format attribute which is not a wellformed absolute uri."); } // The processing rules from [SAML2.0 standard] section 8.3 are implemented here if (nameId.Format == Saml20Constants.NameIdentifierFormats.Email) { if (!Saml20Utils.ValidateRequiredString(nameId.Value)) { throw new Saml20FormatException("NameID with Email Format attribute MUST contain a Value that contains more than whitespace characters"); } try { new MailAddress(nameId.Value); } catch (FormatException fe) { throw new Saml20FormatException("Value of NameID is not a valid email address according to the IETF RFC 2822 specification", fe); } catch (IndexOutOfRangeException ie) { throw new Saml20FormatException("Value of NameID is not a valid email address according to the IETF RFC 2822 specification", ie); } } else if (nameId.Format == Saml20Constants.NameIdentifierFormats.X509SubjectName) { if (!Saml20Utils.ValidateRequiredString(nameId.Value)) { throw new Saml20FormatException("NameID with X509SubjectName Format attribute MUST contain a Value that contains more than whitespace characters"); } // TODO: Consider checking for correct encoding of the Value according to the // XML Signature Recommendation (http://www.w3.org/TR/xmldsig-core/) section 4.4.4 } else if (nameId.Format == Saml20Constants.NameIdentifierFormats.Windows) { // Required format is 'DomainName\UserName' but the domain name and the '\' are optional if (!Saml20Utils.ValidateRequiredString(nameId.Value)) { throw new Saml20FormatException("NameID with Windows Format attribute MUST contain a Value that contains more than whitespace characters"); } } else if (nameId.Format == Saml20Constants.NameIdentifierFormats.Kerberos) { // Required format is 'name[/instance]@REALM' if (!Saml20Utils.ValidateRequiredString(nameId.Value)) { throw new Saml20FormatException("NameID with Kerberos Format attribute MUST contain a Value that contains more than whitespace characters"); } if (nameId.Value.Length < 3) { throw new Saml20FormatException("NameID with Kerberos Format attribute MUST contain a Value with at least 3 characters"); } if (nameId.Value.IndexOf("@") < 0) { throw new Saml20FormatException("NameID with Kerberos Format attribute MUST contain a Value that contains a '@'"); } // TODO: Consider implementing the rules for 'name', 'instance' and 'REALM' found in IETF RFC 1510 (http://www.ietf.org/rfc/rfc1510.txt) here } else if (nameId.Format == Saml20Constants.NameIdentifierFormats.Entity) { if (!Saml20Utils.ValidateRequiredString(nameId.Value)) { throw new Saml20FormatException("NameID with Entity Format attribute MUST contain a Value that contains more than whitespace characters"); } if (nameId.Value.Length > 1024) { throw new Saml20FormatException("NameID with Entity Format attribute MUST have a Value that contains no more than 1024 characters"); } if (nameId.NameQualifier != null) { throw new Saml20FormatException("NameID with Entity Format attribute MUST NOT set the NameQualifier attribute"); } if (nameId.SPNameQualifier != null) { throw new Saml20FormatException("NameID with Entity Format attribute MUST NOT set the SPNameQualifier attribute"); } if (nameId.SPProvidedID != null) { throw new Saml20FormatException("NameID with Entity Format attribute MUST NOT set the SPProvidedID attribute"); } } else if (nameId.Format == Saml20Constants.NameIdentifierFormats.Persistent) { if (!Saml20Utils.ValidateRequiredString(nameId.Value)) { throw new Saml20FormatException("NameID with Persistent Format attribute MUST contain a Value that contains more than whitespace characters"); } if (nameId.Value.Length > 256) { throw new Saml20FormatException("NameID with Persistent Format attribute MUST have a Value that contains no more than 256 characters"); } } else if (nameId.Format == Saml20Constants.NameIdentifierFormats.Transient) { if (!Saml20Utils.ValidateRequiredString(nameId.Value)) { throw new Saml20FormatException("NameID with Transient Format attribute MUST contain a Value that contains more than whitespace characters"); } if (nameId.Value.Length > 256) { throw new Saml20FormatException("NameID with Transient Format attribute MUST have a Value that contains no more than 256 characters"); } if (!Saml20Utils.ValidateIdString(nameId.Value)) { throw new Saml20FormatException("NameID with Transient Format attribute MUST have a Value with at least 16 characters (the equivalent of 128 bits)"); } } }
/// <summary> /// Performs the attribute query against the specified IdP endpoint and adds the resulting attributes to <c>Saml20Identity.Current</c>. /// </summary> /// <param name="context">The http context.</param> /// <param name="endPoint">The IdP to perform the query against.</param> /// <param name="nameIdFormat">The name id format.</param> public void PerformQuery(HttpContext context, IdentityProvider endPoint, string nameIdFormat) { Logger.DebugFormat("{0}.{1} called", GetType(), "PerformQuery()"); var builder = new HttpSoapBindingBuilder(context); var name = new NameId { Value = Saml20Identity.Current.Name, Format = nameIdFormat }; _attrQuery.Subject.Items = new object[] { name }; _attrQuery.SamlAttribute = _attributes.ToArray(); var query = new XmlDocument(); query.LoadXml(Serialization.SerializeToXmlString(_attrQuery)); XmlSignatureUtils.SignDocument(query, Id); if (query.FirstChild is XmlDeclaration) { query.RemoveChild(query.FirstChild); } Logger.DebugFormat(TraceMessages.AttrQuerySent, endPoint.Metadata.GetAttributeQueryEndpointLocation(), query.OuterXml); Stream s; try { s = builder.GetResponse(endPoint.Metadata.GetAttributeQueryEndpointLocation(), query.OuterXml, endPoint.AttributeQuery); } catch (Exception e) { Logger.Error(e.Message, e); throw; } var parser = new HttpSoapBindingParser(s); var status = parser.GetStatus(); if (status.StatusCode.Value != Saml20Constants.StatusCodes.Success) { Logger.ErrorFormat(ErrorMessages.AttrQueryStatusNotSuccessful, Serialization.SerializeToXmlString(status)); throw new Saml20Exception(status.StatusMessage); } bool isEncrypted; var xmlAssertion = Saml20SignonHandler.GetAssertion(parser.SamlMessage, out isEncrypted); if (isEncrypted) { var ass = new Saml20EncryptedAssertion((RSA)Saml2Config.Current.ServiceProvider.SigningCertificate.GetCertificate().PrivateKey); ass.LoadXml(xmlAssertion); ass.Decrypt(); xmlAssertion = ass.Assertion.DocumentElement; } var assertion = new Saml20Assertion(xmlAssertion, null, Saml2Config.Current.AssertionProfile.AssertionValidator, endPoint.QuirksMode); Logger.DebugFormat(TraceMessages.AttrQueryAssertionReceived, xmlAssertion == null ? string.Empty : xmlAssertion.OuterXml); if (!assertion.CheckSignature(Saml20SignonHandler.GetTrustedSigners(endPoint.Metadata.Keys, endPoint))) { Logger.Error(ErrorMessages.AssertionSignatureInvalid); throw new Saml20Exception(ErrorMessages.AssertionSignatureInvalid); } foreach (var attr in assertion.Attributes) { Saml20Identity.Current.AddAttributeFromQuery(attr.Name, attr); } }
public void OnTriggerEnter(Collider other) { otherNameID = other.GetComponent <BehaviorID>().nameIDObj; ChangeValue(); }
/// <summary> /// Processes a successful SAML response and redirect to the requested URL. /// </summary> /// <param name="page">The page object.</param> /// <param name="samlResponse">The SAML response object.</param> /// <param name="relayState">The relay state.</param> public static void SamlSuccessRedirect(Page page, ComponentPro.Saml2.Response samlResponse, string relayState) { // Get the previously loaded certificate. X509Certificate2 x509Certificate = (X509Certificate2)page.Application[Global.SpCertKey]; Assertion samlAssertion; // Check assertions. if (samlResponse.GetAssertions().Count > 0) { // Extract the first assertion. samlAssertion = samlResponse.GetAssertions()[0]; } else if (samlResponse.GetEncryptedAssertions().Count > 0) { // Extract the first assertion. samlAssertion = samlResponse.GetEncryptedAssertions()[0].Decrypt(x509Certificate.PrivateKey, null); } else { throw new ApplicationException("No assertions in response"); } string userName; // Get the subject name identifier. if (samlAssertion.Subject.NameId != null) { //userName = samlAssertion.Subject.NameId.NameIdentifier; userName = samlAssertion.GetAttributeValueByFriendlyName("eduPersonPrincipalName"); System.Collections.Generic.Dictionary<string, string> dict = new System.Collections.Generic.Dictionary<string, string>(); foreach (ComponentPro.Saml2.Attribute attribute in samlAssertion.AttributeStatements[0].Attributes) { dict.Add(attribute.FriendlyName, attribute.Values[0].ToString()); System.Diagnostics.Trace.WriteLine(attribute.FriendlyName + ":" + attribute.Values[0].ToString()); } HttpContext.Current.Session.Add("samlAttributes", dict); } else if (samlAssertion.Subject.EncryptedId != null) { NameId nameId = samlAssertion.Subject.EncryptedId.Decrypt(x509Certificate.PrivateKey, null); userName = nameId.NameIdentifier; } else { throw new ApplicationException("No name in subject"); } try { string aaURL = "https://idp.testshib.org:8443/idp/profile/SAML2/SOAP/AttributeQuery"; //Testing subject NameId subje = new NameId(userName,null,null,SamlNameIdentifierFormat.Unspecified,aaURL); //Testing subject Subject subject = new Subject(new NameId(userName)); SubjectConfirmation subjectConfirmation = new SubjectConfirmation(SamlSubjectConfirmationMethod.Bearer); SubjectConfirmationData subjectConfirmationData = new SubjectConfirmationData(); subjectConfirmationData.Recipient = aaURL; subjectConfirmation.SubjectConfirmationData = subjectConfirmationData; subject.SubjectConfirmations.Add(subjectConfirmation); AttributeQuery attributeQuery = new AttributeQuery(); //attributeQuery.Subject = subject; attributeQuery.Destination = aaURL; attributeQuery.Issuer = new Issuer(Global.entityId); attributeQuery.Attributes.Add(new ComponentPro.Saml2.Attribute() { FriendlyName = "givenName" }); attributeQuery.Subject = new Subject(samlAssertion.Subject.NameId); attributeQuery.Sign(x509Certificate); System.Diagnostics.Trace.WriteLine("Trying to get attributes from AA"); System.Diagnostics.Trace.WriteLine("AA query " + attributeQuery.GetXml().OuterXml); System.Diagnostics.Trace.WriteLine("AA Subject " + attributeQuery.Subject.ToString()); ArtifactResponse artifactResponse = ArtifactResponse.SendSamlMessageReceiveAftifactResponse(aaURL, attributeQuery); Response attrResponse; attrResponse = new ComponentPro.Saml2.Response(artifactResponse.Message); System.Diagnostics.Trace.WriteLine("AA reponse " + attrResponse.GetXml().OuterXml); } catch (Exception e) { System.Diagnostics.Trace.WriteLine("Execption: " + e.ToString()); //throw; } // Get the originally requested resource URL from the relay state. string resourceUrl = (string)SamlSettings.CacheProvider.Remove(relayState); if (resourceUrl == null) { throw new ApplicationException("Invalid relay state"); } // Create a login context for the asserted identity. FormsAuthentication.SetAuthCookie(userName, false); // Redirect to the originally requested resource URL. page.Response.Redirect(resourceUrl, false); }
/// <summary> /// Construct a NameEntry. /// </summary> public NameEntry(NameId prefix, StringId atom) { Prefix = prefix; Atom = atom; }
static int Main(string[] args) { if (args.Length != 1) { printUsage(Environment.GetCommandLineArgs()[0]); return(-1); } string pstFile = args[0]; // Check if the file exists if (!File.Exists(pstFile)) { Console.WriteLine( "The specified PST file argument is incorrect. " + "Either it is not a file or the file does not exist"); return(-1); } IPst pst = new Pst(pstFile); var nameIdMap = pst.NameIDMap; var nameIdMapObject = nameIdMap.PropertyBag; Console.WriteLine("Bucket Count: {0}", nameIdMap.BucketCount); Console.WriteLine(Environment.NewLine); //Dump out all the Guids using (var guids = new GuidStreamReader(nameIdMapObject.OpenPropertyStream(PropId.KnownValue.PidTagNameidStreamGuid))) { Console.WriteLine("GUID Stream: (* indicates predefined guid)"); Console.WriteLine("\t [000] {0}*", Guid.Empty); Console.WriteLine("\t [001] {0}*", GuidStreamReader.MapiGuid); Console.WriteLine("\t [002] {0}*", GuidStreamReader.PublicStringsGuid); for (int i = 3; i < nameIdMap.PropertyCount; i++) { Console.WriteLine("\t [{0:D3}] {1}", i, guids.ReadGuid(i)); } } Console.WriteLine(Environment.NewLine); //Dump out the Entry Stream); using (var entries = new EntryStreamReader(nameIdMapObject.OpenPropertyStream(PropId.KnownValue.PidTagNameidStreamEntry))) { Console.WriteLine("Entry Stream: "); for (int i = 0; i < nameIdMap.PropertyCount; i++) { Console.WriteLine("\t [{0:D3}] {1}", i, entries.ReadEntry(i)); } } Console.WriteLine(Environment.NewLine); using (var strings = new BinaryReader(nameIdMapObject.OpenPropertyStream(PropId.KnownValue.PidTagNameidStreamString))) { Console.WriteLine("String Stream: "); var streamLength = strings.BaseStream.Length; while (strings.BaseStream.Position < streamLength) { var stringLength = strings.ReadInt32(); var stringBytes = strings.ReadBytes(stringLength); Console.WriteLine(Encoding.Unicode.GetString(stringBytes)); //seek to nearest 4-byte boundary var offset = stringLength % 4; if (offset != 0) { strings.BaseStream.Seek((4 - offset), SeekOrigin.Current); } } } Console.WriteLine("Hash Buckets:"); for (int i = 0; i < nameIdMap.BucketCount; i++) { var bucketProperty = i + 0x1000; if (nameIdMapObject.PropertyExists((PropId)bucketProperty)) { var bytes = nameIdMapObject.ReadProperty((PropId)bucketProperty); var nameIdbytes = new byte[8]; for (int x = 0; x < bytes.Length; x += 8) { Array.Copy(bytes, x, nameIdbytes, 0, 8); var nameId = new NameId(nameIdbytes); Console.WriteLine("[{0:D3}] Hash: 0x{1:X8}, Guid Index: {2}, \r\n\tProperty Index: 0x{3:X4}, Is String? {4}", i, nameId.Id, nameId.GuidIndex, (nameId.PropertyIndex + 0x8000), nameId.IsString); Console.WriteLine(); } } } foreach (var np in nameIdMap.NamedProperties) { Console.WriteLine(); Console.WriteLine(np.ToString()); Console.WriteLine(); } Console.ReadKey(true); return(0); }
private void OnTriggerExit(Collider other) { otherIdObj = other.GetComponent <IdBehaviour>().nameIdObj; StartCoroutine(CheckId(otherIdObj, triggerExitMatches)); }
private string ReadString(NameId id) { using (var stringStream = new StringStreamReader(_propBag.OpenPropertyStream(PropId.KnownValue.PidTagNameidStreamString))) return(stringStream.ReadString(id.Id)); }
private Guid ReadGuid(NameId id) { using (var guidStream = new GuidStreamReader(_propBag.OpenPropertyStream(PropId.KnownValue.PidTagNameidStreamGuid))) return(guidStream.ReadGuid((int)id.GuidIndex)); }
protected void ReadResponseStatus(XmlReader reader, StatusResponse response) { reader.MoveToContent(); var responseTo = reader.GetAttribute("InResponseTo"); response.InResponseTo = responseTo; var version = reader.GetAttribute("Version"); response.Version = version; var destination = reader.GetAttribute("Destination"); response.Destination = destination; var id = reader.GetAttribute("ID"); response.ID = id; var issueInstant = reader.GetAttribute("IssueInstant"); response.IssueInstantString = issueInstant; var consent = reader.GetAttribute("Consent"); response.Consent = consent; while (!reader.IsStartElement("Issuer", Saml20Constants.Assertion)) { if (!reader.Read()) { throw new InvalidOperationException("Can't find status code element."); } } var format = reader.GetAttribute("Format") ?? NameIdentifierFormats.Entity; reader.Read(); var issuer = reader.Value; var nameId = new NameId { Format = format, Value = issuer }; response.Issuer = nameId; while (!reader.IsStartElement("Status", Saml20Constants.Protocol)) { if (!reader.Read()) { throw new InvalidOperationException("Can't find status code element."); } } var status = new Status(); while (reader.Read() && !(reader.NodeType == XmlNodeType.EndElement && reader.LocalName == "Status")) { if (reader.IsStartElement("StatusCode", Saml20Constants.Protocol)) { var statusCode = reader.GetAttribute("Value"); var newCode = new StatusCode(); if (status.StatusCode == null) { status.StatusCode = newCode; } else { var temp = status.StatusCode; while (temp.SubStatusCode != null) { temp = temp.SubStatusCode; } temp.SubStatusCode = newCode; } if (!String.IsNullOrWhiteSpace(statusCode)) { newCode.Value = statusCode; } continue; } if (reader.IsStartElement("StatusMessage", Saml20Constants.Protocol)) { reader.Read(); status.StatusMessage = reader.Value; continue; } if (reader.IsStartElement("StatusDetail", Saml20Constants.Protocol)) { status.StatusDetail = new StatusDetail(); var elements = new List <XmlElement>(); while (!(reader.NodeType == XmlNodeType.EndElement && reader.LocalName == "StatusDetail")) { reader.ReadStartElement(); var doc = new XmlDocument(); var el = doc.ReadNode(reader); if (el is XmlElement) { elements.Add((XmlElement)el); } } status.StatusDetail.Any = elements.ToArray(); continue; } } response.Status = status; }