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 ();
}
