public void Constructor1_Deny_Unrestricted () { CodeTypeReference ctr = new CodeTypeReference (); CodeDefaultValueExpression cdve = new CodeDefaultValueExpression (ctr); Assert.AreSame (ctr, cdve.Type, "Type"); cdve.Type = new CodeTypeReference (); }
public TypescriptDefaultValueExpression( CodeDefaultValueExpression codeExpression, CodeGeneratorOptions options, ITypescriptTypeMapper typescriptTypeMapper) { _codeExpression = codeExpression; _options = options; _typescriptTypeMapper = typescriptTypeMapper; System.Diagnostics.Debug.WriteLine("TypescriptDefaultValueExpression Created"); }
public void Constructor1 () { CodeTypeReference type = new CodeTypeReference ("mono"); CodeDefaultValueExpression cdve = new CodeDefaultValueExpression (type); Assert.IsNotNull (cdve.Type, "#1"); Assert.AreSame (type, cdve.Type, "#2"); cdve = new CodeDefaultValueExpression ((CodeTypeReference) null); Assert.IsNotNull (cdve.Type, "#3"); Assert.AreEqual (typeof (void).FullName, cdve.Type.BaseType, "#4"); }
protected override void GenerateDefaultValueExpression(CodeDefaultValueExpression e) { base.Output.Write("CType(Nothing, " + this.GetTypeOutput(e.Type) + ")"); }
/// <summary> /// Visits a <see cref="CodeDefaultValueExpression"/>. /// </summary> /// <param name="codeDefaultValueExpression">The <see cref="CodeDefaultValueExpression"/> to visit.</param> protected virtual void VisitCodeDefaultValueExpression(CodeDefaultValueExpression codeDefaultValueExpression) { if (codeDefaultValueExpression == null) { return; } this.VisitCodeTypeReference(codeDefaultValueExpression.Type); }
public void Visit (CodeDefaultValueExpression o) { g.GenerateDefaultValueExpression (o); }
protected virtual void GenerateDefaultValueExpression (CodeDefaultValueExpression e) { throw new NotImplementedException (); }
private void GenerateDefaultValueExpression(CodeDefaultValueExpression e) { Output.Write("default("); OutputType(e.Type); Output.Write(")"); }
private CodeMethodReturnStatement GenerateTypedMethodBody(IReturnType returnType) { var expression = new CodeDefaultValueExpression(new CodeTypeReference(returnType.Type)); return new CodeMethodReturnStatement { Expression = expression }; }
protected override void GenerateDefaultValueExpression (CodeDefaultValueExpression e) { Output.Write ("default("); OutputType (e.Type); Output.Write (')'); }
private static void ValidateDefaultValueExpression(CodeDefaultValueExpression e) { ValidateTypeReference(e.Type); }
// protected virtual void GenerateDefaultValueExpression(CodeDefaultValueExpression e) { }
private CodeStatementCollection GenerateImperativeStatement(IdentifierExpression node) { var parserId = ParserIdentifier.FromIdentifierExpression(node); if (parserId.Name != "Error") { var typeRef = CodeHelper.TypeRef(parserId.Type ?? _config.BaseClass); typeRef = parserId.IsList ? GetListTypeRef(typeRef) : typeRef; var init = new CodeDefaultValueExpression(typeRef); var varDecl = new CodeVariableDeclarationStatement(typeRef, node.Identifier, init); _scope.Add(node.Identifier, new AphidObject()); return new CodeStatementCollection(new[] { varDecl }); } else { return new CodeStatementCollection(new[] { new CodeThrowExceptionStatement( new CodeObjectCreateExpression( _config.ExceptionClass, CodeHelper.VarRef("_currentToken"))) }); } }
/// <summary> /// Generates code for the specified code default value expression. /// </summary> /// <remarks><c>NULL</c></remarks> protected override void GenerateDefaultValueExpression(CodeDefaultValueExpression e) { // TODO: Output.Write(SpecialWords.Null); }
private void EmitActionsTable(CodeTypeDeclaration target) { // Next are the tables used to determine what action to take based on the current state and lookahead token. These tables are used to implement // functions that take a state number and lookahead value and return an action integer. // Suppose the action integer is N. Then the action is determined as follows // 0 <= N < NSTATE Shift N. That is, push the lookahead token onto the stack and goto state N. // NSTATE <= N < NSTATE+NRULE Reduce by rule N-NSTATE. // N == NSTATE+NRULE A syntax error has occurred. // N == NSTATE+NRULE+1 The parser accepts its input. // N == NSTATE+NRULE+2 No such action. Denotes unused slots in the _actions[] table. // The action table is constructed as a single large table named yy_action[]. // Given state S and lookahead X, the action is computed as // _actions[_shift_ofsts[S] + X] // If the index value _shift_ofsts[S]+X is out of range or if the value _lookaheads[_shift_ofsts[S]+X] is not equal to X or if _shift_ofsts[S] // is equal to SHIFT_USE_DFLT, it means that the action is not in the table and that _defaults[S] should be used instead. // The formula above is for computing the action when the lookahead is a terminal symbol. If the lookahead is a non-terminal (as occurs after // a reduce action) then the _reduce_ofsts[] array is used in place of the _shift_ofsts[] array and REDUCE_USE_DFLT is used in place of SHIFT_USE_DFLT. // The following are the tables generated in this section: // _actions[] A single table containing all actions. // _lookaheads[] A table containing the lookahead for each entry in yy_action. Used to detect hash collisions. // _shift_ofsts[] For each state, the offset into yy_action for shifting terminals. // _reduce_ofsts[] For each state, the offset into yy_action for shifting non-terminals after a reduce. // _defaults[] Default action for each state. int maxTokenOffset; int minTokenOffset; int maxNonTerminalOffset; int minNonTerminalOffset; var actionTable = EmitterActionTable.Make(_ctx, out maxTokenOffset, out minTokenOffset, out maxNonTerminalOffset, out minNonTerminalOffset); CodeMemberField field; #region Actions var n = actionTable.Size; _emitCtx.ACTIONS = actionTable.Size; target.Members.Add(new CodeMemberField(typeof(int), "ACTIONS") { Attributes = MemberAttributes.Family | MemberAttributes.Const, InitExpression = new CodePrimitiveExpression(_emitCtx.ACTIONS) }); // var actionInits = new CodePrimitiveExpression[n]; for (var i = 0; i < n; i++) { var action = actionTable.GetAction(i); if (action < 0) action = _ctx.States + _ctx.Rules + 2; actionInits[i] = new CodePrimitiveExpression(action); } Type actionArrayType; _emitCtx.ACTIONTYPE = GetMinimumSizeType(0, _ctx.States + _ctx.Rules + 5, out actionArrayType); target.Members.Add(field = new CodeMemberField(actionArrayType, "_actions") { Attributes = MemberAttributes.Family | MemberAttributes.Static | MemberAttributes.Final, InitExpression = new CodeArrayCreateExpression(_emitCtx.ACTIONTYPE, actionInits) { Size = n } }); field.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Tables: Actions")); field.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "Tables: Actions")); // #define NO_ACTION (NSTATE+NRULE+2) // #define ACCEPT_ACTION (NSTATE+NRULE+1) // #define ERROR_ACTION (NSTATE+NRULE) target.Members.Add(new CodeMemberField(typeof(int), "NO_ACTION") { Attributes = MemberAttributes.Family | MemberAttributes.Const, InitExpression = new CodePrimitiveExpression(_ctx.States + _ctx.Rules + 2) }); target.Members.Add(new CodeMemberField(typeof(int), "ACCEPT_ACTION") { Attributes = MemberAttributes.Family | MemberAttributes.Const, InitExpression = new CodePrimitiveExpression(_ctx.States + _ctx.Rules + 1) }); target.Members.Add(new CodeMemberField(typeof(int), "ERROR_ACTION") { Attributes = MemberAttributes.Family | MemberAttributes.Const, InitExpression = new CodePrimitiveExpression(_ctx.States + _ctx.Rules) }); #endregion #region Lookahead var lookaheadInits = new CodePrimitiveExpression[n]; for (var i = 0; i < n; i++) { var lookahead = actionTable.GetLookahead(i); if (lookahead < 0) lookahead = _ctx.Symbols.Length - 1; lookaheadInits[i] = new CodePrimitiveExpression(lookahead); } Type codeArrayType; _emitCtx.CODETYPE = GetMinimumSizeType(0, _ctx.Symbols.Length, out codeArrayType); target.Members.Add(field = new CodeMemberField(codeArrayType, "_lookaheads") { Attributes = MemberAttributes.Family | MemberAttributes.Static | MemberAttributes.Final, InitExpression = new CodeArrayCreateExpression(_emitCtx.CODETYPE, lookaheadInits) { Size = n } }); field.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Tables: Lookaheads")); field.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "Tables: Lookaheads")); #endregion #region Shift Offsets n = _ctx.States; _emitCtx.SHIFT_USE_DFLT = minTokenOffset - 1; target.Members.Add(new CodeMemberField(typeof(int), "SHIFT_USE_DFLT") { Attributes = MemberAttributes.Family | MemberAttributes.Const, InitExpression = new CodePrimitiveExpression(_emitCtx.SHIFT_USE_DFLT) }); while (n > 0 && _ctx.Sorted[n - 1].TokenOffset == State.NO_OFFSET) n--; _emitCtx.SHIFT_COUNT = n - 1; target.Members.Add(new CodeMemberField(typeof(int), "SHIFT_COUNT") { Attributes = MemberAttributes.Family | MemberAttributes.Const, InitExpression = new CodePrimitiveExpression(_emitCtx.SHIFT_COUNT) }); _emitCtx.SHIFT_MIN = minTokenOffset; target.Members.Add(new CodeMemberField(typeof(int), "SHIFT_MIN") { Attributes = MemberAttributes.Family | MemberAttributes.Const, InitExpression = new CodePrimitiveExpression(_emitCtx.SHIFT_MIN) }); _emitCtx.SHIFT_MAX = maxTokenOffset; target.Members.Add(new CodeMemberField(typeof(int), "SHIFT_MAX") { Attributes = MemberAttributes.Family | MemberAttributes.Const, InitExpression = new CodePrimitiveExpression(_emitCtx.SHIFT_MAX) }); var shiftInits = new CodePrimitiveExpression[n]; for (var i = 0; i < n; i++) { var state = _ctx.Sorted[i]; var offset = state.TokenOffset; if (offset == State.NO_OFFSET) offset = minTokenOffset - 1; shiftInits[i] = new CodePrimitiveExpression(offset); } Type shiftArrayType; var shiftType = GetMinimumSizeType(minTokenOffset - 1, maxTokenOffset, out shiftArrayType); target.Members.Add(field = new CodeMemberField(shiftArrayType, "_shift_ofsts") { Attributes = MemberAttributes.Family | MemberAttributes.Static | MemberAttributes.Final, InitExpression = new CodeArrayCreateExpression(shiftType, shiftInits) { Size = n } }); field.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Tables: Shift Offsets")); field.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "Tables: Shift Offsets")); #endregion #region Reduce Offsets n = _ctx.States; _emitCtx.REDUCE_USE_DFLT = minNonTerminalOffset - 1; target.Members.Add(new CodeMemberField(typeof(int), "REDUCE_USE_DFLT") { Attributes = MemberAttributes.Family | MemberAttributes.Const, InitExpression = new CodePrimitiveExpression(_emitCtx.REDUCE_USE_DFLT) }); while (n > 0 && _ctx.Sorted[n - 1].NonTerminalOffset == State.NO_OFFSET) n--; _emitCtx.REDUCE_COUNT = n - 1; target.Members.Add(new CodeMemberField(typeof(int), "REDUCE_COUNT") { Attributes = MemberAttributes.Family | MemberAttributes.Const, InitExpression = new CodePrimitiveExpression(n - 1) }); _emitCtx.REDUCE_MIN = minNonTerminalOffset; target.Members.Add(new CodeMemberField(typeof(int), "REDUCE_MIN") { Attributes = MemberAttributes.Family | MemberAttributes.Const, InitExpression = new CodePrimitiveExpression(_emitCtx.REDUCE_MIN) }); _emitCtx.REDUCE_MAX = maxNonTerminalOffset; target.Members.Add(new CodeMemberField(typeof(int), "REDUCE_MAX") { Attributes = MemberAttributes.Family | MemberAttributes.Const, InitExpression = new CodePrimitiveExpression(_emitCtx.REDUCE_MAX) }); var reduceInits = new CodePrimitiveExpression[n]; for (var i = 0; i < n; i++) { var state = _ctx.Sorted[i]; var offset = state.NonTerminalOffset; if (offset == State.NO_OFFSET) offset = minNonTerminalOffset - 1; reduceInits[i] = new CodePrimitiveExpression(offset); } Type reduceArrayType; var reduceType = GetMinimumSizeType(minNonTerminalOffset - 1, maxNonTerminalOffset, out reduceArrayType); target.Members.Add(field = new CodeMemberField(reduceArrayType, "_reduce_ofsts") { Attributes = MemberAttributes.Family | MemberAttributes.Static | MemberAttributes.Final, InitExpression = new CodeArrayCreateExpression(reduceType, reduceInits) { Size = n } }); field.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Tables: Reduce Offsets")); field.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "Tables: Reduce Offsets")); #endregion #region Defaults n = _ctx.States; var defaultInits = new CodePrimitiveExpression[n]; for (var i = 0; i < n; i++) { var state = _ctx.Sorted[i]; defaultInits[i] = new CodePrimitiveExpression(state.Default); } target.Members.Add(field = new CodeMemberField(actionArrayType, "_defaults") { Attributes = MemberAttributes.Family | MemberAttributes.Static | MemberAttributes.Final, InitExpression = new CodeArrayCreateExpression(_emitCtx.ACTIONTYPE, defaultInits) { Size = n } }); field.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Tables: Defaults")); field.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "Tables: Defaults")); #endregion #region Fallbacks if (_ctx.HasFallback) { n = _ctx.Terminals - 1; while (n > 0 && _ctx.Symbols[n].Fallback == null) n--; var fallbackInits = new CodeExpression[n + 1]; for (var i = 0; i <= n; i++) { var symbol = _ctx.Symbols[i]; if (symbol.Fallback == null) fallbackInits[i] = new CodeDefaultValueExpression(new CodeTypeReference(_emitCtx.CODETYPE)); /* {symbol.Name,10} => nothing */ else fallbackInits[i] = new CodePrimitiveExpression(symbol.Fallback.ID); /* {symbol.Name,10} => symbol.Fallback.Name */ } target.Members.Add(field = new CodeMemberField(codeArrayType, "_fallbacks") { Attributes = MemberAttributes.Family | MemberAttributes.Static | MemberAttributes.Final, InitExpression = new CodeArrayCreateExpression(_emitCtx.CODETYPE, fallbackInits) { Size = n } }); field.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Tables: Fallbacks")); field.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "Tables: Fallbacks")); } #endregion }
public void Generate(CodeDefaultValueExpression expression) { throw new NotSupportedException(); }
protected virtual CodeDefaultValueExpression Rewrite(CodeDefaultValueExpression source, ref bool didRewrite) { if (source == null) { return source; } bool didChildRewrite = false; CodeDefaultValueExpression result = new CodeDefaultValueExpression(); result.Type = this.Rewrite(source.Type, ref didChildRewrite); this.Rewrite(result.UserData, source.UserData, ref didChildRewrite); if (didChildRewrite) { didRewrite = true; return result; } else { return source; } }
public void Constructor0_Deny_Unrestricted () { CodeDefaultValueExpression cdve = new CodeDefaultValueExpression (); Assert.AreEqual ("System.Void", cdve.Type.BaseType, "Type"); cdve.Type = new CodeTypeReference (); }