void ConvertParameters(List <ParameterDeclarationExpression> input, B.ParameterDeclarationCollection output)
{
bool isParams = false;
foreach (ParameterDeclarationExpression pde in input)
{
B.ParameterDeclaration para = ConvertParameter(pde, out isParams);
if (para != null)
{
output.Add(para);
}
}
output.HasParamArray = isParams;
}
B.ParameterDeclaration ConvertParameter(ParameterDeclarationExpression pde, out bool isParams)
{
B.ParameterDeclaration para = new B.ParameterDeclaration(pde.ParameterName, ConvertTypeReference(pde.TypeReference));
if ((pde.ParamModifier & ParameterModifiers.Optional) != 0)
{
AddError(pde, "Optional parameters are not supported.");
}
if ((pde.ParamModifier & ParameterModifiers.Out) != 0)
{
para.Modifiers |= B.ParameterModifiers.Ref;
}
if ((pde.ParamModifier & ParameterModifiers.Ref) != 0)
{
para.Modifiers |= B.ParameterModifiers.Ref;
}
isParams = (pde.ParamModifier & ParameterModifiers.Params) != 0;
ConvertAttributes(pde.Attributes, para.Attributes);
return(para);
}
public override void LeaveParameterDeclaration(ParameterDeclaration node)
{
CheckName(node,node.Name);
}
protected bool parameter_declaration(
ParameterDeclarationCollection c
) //throws RecognitionException, TokenStreamException
{
bool variableArguments;
IToken id1 = null;
IToken begin1 = null;
IToken id2 = null;
IToken begin2 = null;
IToken id = null;
TypeReference tr = null;
ParameterModifiers pm = ParameterModifiers.None;
variableArguments = false;
Expression nameSplice = null;
try { // for error handling
attributes();
{
switch ( LA(1) )
{
case MULTIPLY:
{
{
match(MULTIPLY);
if (0==inputState.guessing)
{
variableArguments=true;
}
{
switch ( LA(1) )
{
case ID:
{
id1 = LT(1);
match(ID);
if (0==inputState.guessing)
{
id = id1;
}
break;
}
case SPLICE_BEGIN:
{
begin1 = LT(1);
match(SPLICE_BEGIN);
nameSplice=atom();
if (0==inputState.guessing)
{
id = begin1;
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1) )
{
case AS:
{
match(AS);
tr=array_type_reference();
break;
}
case RPAREN:
case RBRACK:
case COMMA:
case BITWISE_OR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
break;
}
case REF:
case ID:
case SPLICE_BEGIN:
{
{
{
switch ( LA(1) )
{
case REF:
{
pm=parameter_modifier();
break;
}
case ID:
case SPLICE_BEGIN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1) )
{
case ID:
{
id2 = LT(1);
match(ID);
if (0==inputState.guessing)
{
id = id2;
}
break;
}
case SPLICE_BEGIN:
{
begin2 = LT(1);
match(SPLICE_BEGIN);
nameSplice=atom();
if (0==inputState.guessing)
{
id = begin2;
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1) )
{
case AS:
{
match(AS);
tr=type_reference();
break;
}
case RPAREN:
case RBRACK:
case COMMA:
case BITWISE_OR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if (0==inputState.guessing)
{
ParameterDeclaration pd = new ParameterDeclaration(ToLexicalInfo(id));
pd.Name = id.getText();
pd.Type = tr;
pd.Modifiers = pm;
AddAttributes(pd.Attributes);
c.Add(
nameSplice != null
? new SpliceParameterDeclaration(pd, nameSplice)
: pd);
}
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex, "parameter_declaration");
recover(ex,tokenSet_86_);
}
else
{
throw ex;
}
}
return variableArguments;
}
public override void OnParameterDeclaration(ParameterDeclaration node)
{
_emitter.EmitParameterAttributes(node);
}
void EmitParameterAttributes(ParameterDeclaration node)
{
ParameterBuilder builder = (ParameterBuilder)GetBuilder(node);
EmitAttributes(node, builder.SetCustomAttribute);
}
//throws RecognitionException, TokenStreamException
protected bool parameter_declaration(
ParameterDeclarationCollection c
)
{
bool variableArguments;
IToken id1 = null;
IToken id2 = null;
IToken id = null;
TypeReference tr = null;
ParameterModifiers pm = ParameterModifiers.None;
variableArguments = false;
try { // for error handling
attributes();
{
switch ( LA(1) )
{
case MULTIPLY:
{
{
match(MULTIPLY);
if (0==inputState.guessing)
{
variableArguments=true;
}
id1 = LT(1);
match(ID);
{
switch ( LA(1) )
{
case AS:
{
match(AS);
tr=array_type_reference();
break;
}
case RPAREN:
case RBRACK:
case COMMA:
case BITWISE_OR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if (0==inputState.guessing)
{
id = id1;
}
}
break;
}
case REF:
case ID:
{
{
{
switch ( LA(1) )
{
case REF:
{
pm=parameter_modifier();
break;
}
case ID:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
id2 = LT(1);
match(ID);
{
switch ( LA(1) )
{
case AS:
{
match(AS);
tr=type_reference();
break;
}
case RPAREN:
case RBRACK:
case COMMA:
case BITWISE_OR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if (0==inputState.guessing)
{
id = id2;
}
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if (0==inputState.guessing)
{
ParameterDeclaration pd = new ParameterDeclaration(SourceLocationFactory.ToLexicalInfo(id));
pd.Name = id.getText();
pd.Type = tr;
pd.Modifiers = pm;
AddAttributes(pd.Attributes);
c.Add(pd);
}
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex);
recover(ex,tokenSet_81_);
}
else
{
throw ex;
}
}
return variableArguments;
}
public override void OnProperty(Property node)
{
if (WasVisited(node))
{
return;
}
MarkVisited(node);
Method setter = node.Setter;
Method getter = node.Getter;
Visit(node.Attributes);
Visit(node.Type);
Visit(node.Parameters);
ResolvePropertyOverride(node);
if (null != getter)
{
if (null != node.Type)
{
getter.ReturnType = node.Type.CloneNode();
}
getter.Parameters.ExtendWithClones(node.Parameters);
Visit(getter);
}
IType typeInfo = null;
if (null != node.Type)
{
typeInfo = GetType(node.Type);
}
else
{
if (null != getter)
{
typeInfo = GetEntity(node.Getter).ReturnType;
if (typeInfo == TypeSystemServices.VoidType)
{
typeInfo = TypeSystemServices.ObjectType;
node.Getter.ReturnType = CodeBuilder.CreateTypeReference(getter.LexicalInfo, typeInfo);
}
}
else
{
typeInfo = TypeSystemServices.ObjectType;
}
node.Type = CodeBuilder.CreateTypeReference(node.LexicalInfo, typeInfo);
}
if (null != setter)
{
ParameterDeclaration parameter = new ParameterDeclaration();
parameter.Type = CodeBuilder.CreateTypeReference(typeInfo);
parameter.Name = "value";
parameter.Entity = new InternalParameter(parameter, node.Parameters.Count+CodeBuilder.GetFirstParameterIndex(setter));
setter.Parameters.ExtendWithClones(node.Parameters);
setter.Parameters.Add(parameter);
setter.Name = "set_" + node.Name;
Visit(setter);
}
}
//throws RecognitionException, TokenStreamException
protected void callable_parameter_declaration(
ParameterDeclarationCollection c
)
{
TypeReference tr = null;
ParameterModifiers pm = ParameterModifiers.None;
try { // for error handling
{
{
switch ( LA(1) )
{
case REF:
{
pm=parameter_modifier();
break;
}
case CALLABLE:
case CHAR:
case ID:
case LPAREN:
case SPLICE_BEGIN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
tr=type_reference();
}
}
if (0==inputState.guessing)
{
ParameterDeclaration pd = new ParameterDeclaration(tr.LexicalInfo);
pd.Name = "arg" + c.Count;
pd.Type = tr;
pd.Modifiers = pm;
c.Add(pd);
}
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex);
recover(ex,tokenSet_69_);
}
else
{
throw ex;
}
}
}
override public bool Replace(Node existing, Node newNode)
{
if (base.Replace(existing, newNode))
{
return(true);
}
if (_attributes != null)
{
Attribute item = existing as Attribute;
if (null != item)
{
Attribute newItem = (Attribute)newNode;
if (_attributes.Replace(item, newItem))
{
return(true);
}
}
}
if (_parameters != null)
{
ParameterDeclaration item = existing as ParameterDeclaration;
if (null != item)
{
ParameterDeclaration newItem = (ParameterDeclaration)newNode;
if (_parameters.Replace(item, newItem))
{
return(true);
}
}
}
if (_genericParameters != null)
{
GenericParameterDeclaration item = existing as GenericParameterDeclaration;
if (null != item)
{
GenericParameterDeclaration newItem = (GenericParameterDeclaration)newNode;
if (_genericParameters.Replace(item, newItem))
{
return(true);
}
}
}
if (_returnType == existing)
{
this.ReturnType = (TypeReference)newNode;
return(true);
}
if (_returnTypeAttributes != null)
{
Attribute item = existing as Attribute;
if (null != item)
{
Attribute newItem = (Attribute)newNode;
if (_returnTypeAttributes.Replace(item, newItem))
{
return(true);
}
}
}
return(false);
}
public override void OnParameterDeclaration(ParameterDeclaration p)
{
WriteAttributes(p.Attributes, false);
if (p.IsByRef)
{
WriteKeyword("ref ");
}
if (p.ParentNode.NodeType == NodeType.CallableTypeReference)
{
Visit(p.Type);
}
else
{
Write(p.Name);
WriteTypeReference(p.Type);
}
}
public SpliceParameterDeclaration(ParameterDeclaration pd, Expression nameExpression) :
base(pd.LexicalInfo)
{
this.ParameterDeclaration = pd;
this.NameExpression = nameExpression;
}
public void parameter_declaration(INodeWithParameters m)
{
try
{
TypeReference reference;
switch (this.LA(1))
{
case 0x63:
this.attributes();
break;
case 12:
case 0x10:
case 0x21:
case 0x3b:
break;
default:
throw new NoViableAltException(this.LT(1), this.getFilename());
}
IToken token = this.identifier();
switch (this.LA(1))
{
case 0x42:
this.match(0x42);
reference = this.type_reference();
break;
case 0x40:
case 0x43:
break;
default:
throw new NoViableAltException(this.LT(1), this.getFilename());
}
if (base.inputState.guessing == 0)
{
ParameterDeclaration declaration;
ParameterDeclaration declaration1 = declaration = new ParameterDeclaration(ToLexicalInfo(token));
declaration.set_Name(token.getText());
declaration.set_Type(reference);
ParameterDeclaration node = declaration;
m.get_Parameters().Add(node);
this.FlushAttributes(node);
}
}
catch (RecognitionException exception)
{
if (base.inputState.guessing != 0)
{
throw;
}
this.reportError(exception);
this.recover(exception, tokenSet_18_);
}
}
public void function_type_parameters(ParameterDeclarationCollection parameters)
{
try
{
this.match(0x3f);
switch (this.LA(1))
{
case 0x13:
case 0x3b:
{
TypeReference reference = this.type_reference();
if (base.inputState.guessing == 0)
{
ParameterDeclaration declaration;
ParameterDeclaration declaration1 = declaration = new ParameterDeclaration();
declaration.set_Type(reference);
declaration.set_Name("arg" + parameters.Count);
parameters.Add(declaration);
}
while (this.LA(1) == 0x43)
{
this.match(0x43);
reference = this.type_reference();
if (base.inputState.guessing == 0)
{
ParameterDeclaration declaration2;
ParameterDeclaration declaration3 = declaration2 = new ParameterDeclaration();
declaration2.set_Type(reference);
declaration2.set_Name("arg" + parameters.Count);
parameters.Add(declaration2);
}
}
break;
}
case 0x40:
break;
default:
throw new NoViableAltException(this.LT(1), this.getFilename());
}
this.match(0x40);
}
catch (RecognitionException exception)
{
if (base.inputState.guessing != 0)
{
throw;
}
this.reportError(exception);
this.recover(exception, tokenSet_35_);
}
}
public MappedVariableDefinition(CompileResults results, ParameterDeclaration node)
: base(results, node, node.Name.Length)
{
}
public ParameterDeclaration CreateParameterDeclaration(int index, string name, IType type, bool byref)
{
var modifiers = byref ? ParameterModifiers.Ref : ParameterModifiers.None;
var parameter = new ParameterDeclaration(name, CreateTypeReference(type), modifiers);
parameter.Entity = new InternalParameter(parameter, index);
return parameter;
}
override public object Clone()
{
ParameterDeclaration clone = new ParameterDeclaration();
clone._lexicalInfo = _lexicalInfo;
clone._endSourceLocation = _endSourceLocation;
clone._documentation = _documentation;
clone._isSynthetic = _isSynthetic;
clone._entity = _entity;
if (_annotations != null) clone._annotations = (Hashtable)_annotations.Clone();
clone._name = _name;
if (null != _type)
{
clone._type = _type.Clone() as TypeReference;
clone._type.InitializeParent(clone);
}
clone._modifiers = _modifiers;
if (null != _attributes)
{
clone._attributes = _attributes.Clone() as AttributeCollection;
clone._attributes.InitializeParent(clone);
}
return clone;
}
protected override void CustomizeCompiler(BooCompiler compiler, CompilerPipeline pipeline, string[] urls)
{
ParameterDeclarationCollection parameters = new ParameterDeclarationCollection();
ParameterDeclaration newParameterDeclaration =
new ParameterDeclaration("input", new SimpleTypeReference("System.String"));
parameters.Add(newParameterDeclaration);
pipeline.Insert(1, new ImplicitBaseClassCompilerStep(typeof(MyClassWithParams),
"Hello",
parameters,
"System"));
}
public override bool Replace(Node existing, Node newNode)
{
if (base.Replace(existing, newNode))
{
return true;
}
if (_type == existing)
{
this.Type = (TypeReference)newNode;
return true;
}
if (_attributes != null)
{
Attribute item = existing as Attribute;
if (null != item)
{
Attribute newItem = (Attribute)newNode;
if (_attributes.Replace(item, newItem))
{
return true;
}
}
}
if (_parameterDeclaration == existing)
{
this.ParameterDeclaration = (ParameterDeclaration)newNode;
return true;
}
if (_nameExpression == existing)
{
this.NameExpression = (Expression)newNode;
return true;
}
return false;
}
public override void OnParameterDeclaration(ParameterDeclaration node)
{
node.Name = node.Name.TrimStart('@');
base.OnParameterDeclaration(node);
}
public ClassDefinition GetContextFieldDeclaration()
{
Field field;
Field field2;
ParameterDeclaration declaration;
MemberReferenceExpression expression;
ReferenceExpression expression2;
BinaryExpression expression3;
ReferenceExpression expression4;
ReferenceExpression expression5;
MemberReferenceExpression expression6;
BinaryExpression expression7;
Block block;
Constructor constructor;
ClassDefinition definition;
Type type = this._evaluationContext.GetType();
Type type2 = this._evaluationContext.ScriptContainer.GetType();
ClassDefinition definition1 = definition = new ClassDefinition(LexicalInfo.Empty);
definition.set_Name("_");
TypeMember[] memberArray1 = new TypeMember[3];
Field field1 = field = new Field(LexicalInfo.Empty);
field.set_Modifiers(40);
field.set_Name("ScriptContainer");
field.set_Type(TypeReference.Lift(type2));
field.set_IsVolatile(false);
memberArray1[0] = field;
Field field3 = field2 = new Field(LexicalInfo.Empty);
field2.set_Name("EvaluationContext");
field2.set_Type(TypeReference.Lift(type));
field2.set_IsVolatile(false);
memberArray1[1] = field2;
Constructor constructor1 = constructor = new Constructor(LexicalInfo.Empty);
constructor.set_Name("constructor");
ParameterDeclaration[] declarationArray1 = new ParameterDeclaration[1];
ParameterDeclaration declaration1 = declaration = new ParameterDeclaration(LexicalInfo.Empty);
declaration.set_Name("context");
declaration.set_Type(TypeReference.Lift(type));
declarationArray1[0] = declaration;
constructor.set_Parameters(ParameterDeclarationCollection.FromArray(false, declarationArray1));
Block block1 = block = new Block(LexicalInfo.Empty);
Statement[] statementArray1 = new Statement[2];
BinaryExpression expression1 = expression3 = new BinaryExpression(LexicalInfo.Empty);
expression3.set_Operator(15);
MemberReferenceExpression expression14 = expression = new MemberReferenceExpression(LexicalInfo.Empty);
expression.set_Name("EvaluationContext");
expression.set_Target(new SelfLiteralExpression(LexicalInfo.Empty));
expression3.set_Left(expression);
ReferenceExpression expression15 = expression2 = new ReferenceExpression(LexicalInfo.Empty);
expression2.set_Name("context");
expression3.set_Right(expression2);
statementArray1[0] = Statement.Lift(expression3);
BinaryExpression expression16 = expression7 = new BinaryExpression(LexicalInfo.Empty);
expression7.set_Operator(15);
ReferenceExpression expression17 = expression4 = new ReferenceExpression(LexicalInfo.Empty);
expression4.set_Name("ScriptContainer");
expression7.set_Left(expression4);
MemberReferenceExpression expression18 = expression6 = new MemberReferenceExpression(LexicalInfo.Empty);
expression6.set_Name("ScriptContainer");
ReferenceExpression expression19 = expression5 = new ReferenceExpression(LexicalInfo.Empty);
expression5.set_Name("context");
expression6.set_Target(expression5);
expression7.set_Right(expression6);
statementArray1[1] = Statement.Lift(expression7);
block.set_Statements(StatementCollection.FromArray(statementArray1));
constructor.set_Body(block);
memberArray1[2] = constructor;
definition.set_Members(TypeMemberCollection.FromArray(memberArray1));
return definition;
}
public static Expression Lift(ParameterDeclaration p)
{
return(new ReferenceExpression(p.LexicalInfo, p.Name));
}
public override void OnParameterDeclaration(ParameterDeclaration node)
{
if (node.LexicalInfo != null)
results.MapParsedNode(new MappedVariableDefinition(results, node));
base.OnParameterDeclaration(node);
}
B.ParameterDeclaration ConvertParameter(ParameterDeclarationExpression pde, out bool isParams)
{
B.ParameterDeclaration para = new B.ParameterDeclaration(pde.ParameterName, ConvertTypeReference(pde.TypeReference));
if ((pde.ParamModifier & ParameterModifiers.Optional) != 0) {
AddError(pde, "Optional parameters are not supported.");
}
if ((pde.ParamModifier & ParameterModifiers.Out) != 0) {
para.Modifiers |= B.ParameterModifiers.Ref;
}
if ((pde.ParamModifier & ParameterModifiers.Ref) != 0) {
para.Modifiers |= B.ParameterModifiers.Ref;
}
isParams = (pde.ParamModifier & ParameterModifiers.Params) != 0;
ConvertAttributes(pde.Attributes, para.Attributes);
return para;
}
ParameterAttributes GetParameterAttributes(ParameterDeclaration param)
{
return ParameterAttributes.None;
}
public static Expression Lift(ParameterDeclaration p)
{
return new ReferenceExpression(p.LexicalInfo, p.Name);
}
override public bool Replace(Node existing, Node newNode)
{
if (base.Replace(existing, newNode))
{
return(true);
}
if (_attributes != null)
{
Attribute item = existing as Attribute;
if (null != item)
{
Attribute newItem = (Attribute)newNode;
if (_attributes.Replace(item, newItem))
{
return(true);
}
}
}
if (_parameters != null)
{
ParameterDeclaration item = existing as ParameterDeclaration;
if (null != item)
{
ParameterDeclaration newItem = (ParameterDeclaration)newNode;
if (_parameters.Replace(item, newItem))
{
return(true);
}
}
}
if (_genericParameters != null)
{
GenericParameterDeclaration item = existing as GenericParameterDeclaration;
if (null != item)
{
GenericParameterDeclaration newItem = (GenericParameterDeclaration)newNode;
if (_genericParameters.Replace(item, newItem))
{
return(true);
}
}
}
if (_returnType == existing)
{
this.ReturnType = (TypeReference)newNode;
return(true);
}
if (_returnTypeAttributes != null)
{
Attribute item = existing as Attribute;
if (null != item)
{
Attribute newItem = (Attribute)newNode;
if (_returnTypeAttributes.Replace(item, newItem))
{
return(true);
}
}
}
if (_body == existing)
{
this.Body = (Block)newNode;
return(true);
}
if (_locals != null)
{
Local item = existing as Local;
if (null != item)
{
Local newItem = (Local)newNode;
if (_locals.Replace(item, newItem))
{
return(true);
}
}
}
if (_explicitInfo == existing)
{
this.ExplicitInfo = (ExplicitMemberInfo)newNode;
return(true);
}
return(false);
}
public override void OnParameterDeclaration(ParameterDeclaration node)
{
_emitter.EmitParameterAttributes(node, this._knownTypes);
}
protected bool callable_parameter_declaration(
ParameterDeclarationCollection c
) //throws RecognitionException, TokenStreamException
{
bool varArgs;
TypeReference tr = null;
ParameterModifiers pm = ParameterModifiers.None;
varArgs = false;
try { // for error handling
{
switch ( LA(1) )
{
case MULTIPLY:
{
{
match(MULTIPLY);
if (0==inputState.guessing)
{
varArgs=true;
}
tr=type_reference();
}
break;
}
case CALLABLE:
case CHAR:
case REF:
case THEN:
case LPAREN:
case ID:
case SPLICE_BEGIN:
{
{
{
switch ( LA(1) )
{
case REF:
{
pm=parameter_modifier();
break;
}
case CALLABLE:
case CHAR:
case THEN:
case LPAREN:
case ID:
case SPLICE_BEGIN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
tr=type_reference();
}
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if (0==inputState.guessing)
{
ParameterDeclaration pd = new ParameterDeclaration(tr.LexicalInfo);
pd.Name = "arg" + c.Count;
pd.Type = tr;
pd.Modifiers = pm;
c.Add(pd);
}
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex, "callable_parameter_declaration");
recover(ex,tokenSet_87_);
}
else
{
throw ex;
}
}
return varArgs;
}
void EmitParameterAttributes(ParameterDeclaration node, TypeCreator knownTypes)
{
ParameterBuilder builder = (ParameterBuilder)GetBuilder(node);
EmitAttributes(node, builder.SetCustomAttribute, knownTypes);
}
public override void LeaveParameterDeclaration(ParameterDeclaration node)
{
AssertIdentifierName(node, node.Name);
CheckParameterType(node.Type);
}
public InternalParameter(ParameterDeclaration parameter, int index)
{
_parameter = parameter;
_index = index;
}
public ReferenceExpression CreateReference(ParameterDeclaration parameter)
{
return CreateReference((InternalParameter)TypeSystemServices.GetEntity(parameter));
}
public SpliceParameterDeclaration(ParameterDeclaration pd, Expression nameExpression) :
base(pd.LexicalInfo)
{
this.ParameterDeclaration = pd;
this.NameExpression = nameExpression;
}
