protected virtual void OnError(LexicalInfo info, String message)
{
String detailedMessage = String.Format(
"{0}. On {1}, Line {2} - from {3} until {4}", message,
info.Filename, info.Line, info.StartCol, info.EndCol);
throw new BuilderException(info, detailedMessage);
}
public TypeReference(LexicalInfo info, String value, TargetTypeEnum targetType) : this(info)
{
if (targetType == TargetTypeEnum.Link)
{
LinkRef = value;
}
else
{
TypeName = value;
}
}
public void RaiseErrorEvent( LexicalInfo info, String message )
{
SetHasError();
ErrorDelegate errorDelegate = (ErrorDelegate) _events[ErrorEvent];
if (errorDelegate != null)
{
errorDelegate(info, message);
}
}
protected EngineConfiguration ParseContents()
{
AspectLanguageLexer lexer = new AspectLanguageLexer(_reader);
AspectParser parser = new AspectParser(lexer);
try
{
return parser.Parse();
}
catch (antlr.RecognitionException e)
{
int line = e.getLine();
int startColumn = e.getColumn();
String filename = e.getFilename();
LexicalInfo info = new LexicalInfo(filename, line, startColumn, -1);
throw new BuilderException(info, e.Message);
}
}
private Type LoadType( String typeName, String assemblyName, LexicalInfo info )
{
String qualifiedName = String.Format("{0}, {1}", typeName, assemblyName);
try
{
return Type.GetType( qualifiedName, true, false );
}
catch(Exception)
{
Context.RaiseErrorEvent( info, "Could not load type specified " + qualifiedName );
}
return null;
}
public DefinitionBase( LexicalInfo info ) : base(info)
{
}
protected void OnError(LexicalInfo info, string message)
{
messages.Append(message);
messages.Append(';');
}
public InterceptorEntryDefinition( String key, LexicalInfo info ) : base(info)
{
Key = key;
}
private void AssertIsInterceptor(LexicalInfo info, Type type, String message)
{
if (!typeof (IInterceptor).IsAssignableFrom(type))
{
Context.RaiseErrorEvent(info, message);
}
}
public MixinDefinition( LexicalInfo info ) : base(info)
{
}
public InterceptorDefinition( LexicalInfo info ) : base(info)
{
}
public TypeReference(LexicalInfo info) : base(info)
{
}
public TypeReference(LexicalInfo info, String typeName) : this(info)
{
TypeName = typeName;
}
public MixinEntryDefinition( String key, LexicalInfo info ) : base(info)
{
Key = key;
}
public DefinitionBase Add(String key, LexicalInfo info)
{
MixinEntryDefinition entry = new MixinEntryDefinition( key, info );
Add(entry);
return entry;
}
public ImportDirective(LexicalInfo lexInfo, String ns) : base(lexInfo)
{
Namespace = ns;
}
public AspectDefinition(LexicalInfo info, String name) : base(info)
{
Name = name;
}
public NodeBase(LexicalInfo info)
{
LexicalInfo = info;
}
public BuilderException(LexicalInfo info, String message) : base(message)
{
_info = info;
}
public DefinitionBase Add( String key, LexicalInfo info )
{
InterceptorEntryDefinition entry = new InterceptorEntryDefinition( key, info );
Add(entry);
return entry;
}
protected void RaiseErrorEvent(LexicalInfo info, String message)
{
Context.RaiseErrorEvent(info, message);
}
public NodeBase(LexicalInfo info)
{
LexicalInfo = info;
}
private void AssertNotInterface(LexicalInfo info, Type type, String message)
{
if (type.IsInterface)
{
Context.RaiseErrorEvent(info, message);
}
}
public PointCutDefinition(LexicalInfo info, PointCutFlags flags) : base(info)
{
_flags = flags;
}
public AssemblyReference( LexicalInfo info, String assemblyName ) : base(info)
{
_assemblyName = assemblyName;
}
public MixinEntryDefinition(String key, LexicalInfo info) : base(info)
{
Key = key;
}
