Expression IContractDeserializer.ParseContract (MethodContract mc, string text, ErrorNodeList errs)
  {
    Expression expression = null;
    currentMethodContract = mc;
    currentMethod = null;
    currentType = null;
    if (mc != null){
      currentMethod = mc.DeclaringMethod;
      currentType = currentMethod.DeclaringType;
    }
    try{
      Parser.ParseContract(this.assembly, text, out expression);
    }catch (Exception e){
      ErrorNodeList eList = errs != null ? errs : this.ErrorList;
      if (eList != null){
#if OLDERRORS
        ErrorHandler eh = new ErrorHandler(eList);
        eh.HandleError(mc,System.Compiler.Error.GenericError,"Deserializer error: " + e.Message);
#else
        this.assembly.MetadataImportErrors.Add(e);
#endif
      }
      throw e;
    }
    return expression;
  }

		/// <summary> 
		/// Constructor for client support
		/// </summary>
		/// <param name="sizeOfRawBuffer"> The size of the raw buffer </param>
		/// <param name="userArg"> A Reference to the Users arguments </param>
		/// <param name="messageHandler">  Reference to the user defined message handler method </param>
		/// <param name="closeHandler">  Reference to the user defined close handler method </param>
		/// <param name="errorHandler">  Reference to the user defined error handler method </param>
		public SocketClient(int sizeOfRawBuffer, object userArg, 
			MessageHandler messageHandler, CloseHandler closeHandler, 
			ErrorHandler errorHandler, ConnectHandler connectHandler)
		{
			// Create the raw buffer
			this.SizeOfRawBuffer = sizeOfRawBuffer;
			this.RawBuffer  = new Byte[this.SizeOfRawBuffer];

			// Save the user argument
			this.userArg = userArg;

			// Set the handler methods
			this.messageHandler = messageHandler;
			this.closeHandler = closeHandler;
			this.errorHandler = errorHandler;
            this.connectHandler = connectHandler;

			// Set the async socket method handlers
			this.callbackReadMethod  = new AsyncCallback(ReceiveComplete);
			this.callbackWriteMethod = new AsyncCallback(SendComplete);
            this.callbackWriteHeadMethod = new AsyncCallback(SendHead);

			this.m_Connected = true;
			// Init the dispose flag
			this.disposed = false;
		}

        public void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
        {
            var eh=new ErrorHandler();

            foreach (ChannelDispatcherBase cdb in serviceHostBase.ChannelDispatchers)
                ((ChannelDispatcher)cdb).ErrorHandlers.Insert(0, eh);
        }

 public override void DoSemanticChecks(ErrorHandler errs, Scope currentScope)
 {
     foreach (AstNode astNode in _content)
     {
         astNode.DoSemanticChecks(errs, currentScope);
     }
 }

        public static void rankingTops(String token, String list_id, int count, int start_row, String time_type, String relation_type, YebobHandler handler, ErrorHandler onError)
        {
            String url = String.Format("{0}/ranking/tops?list_id={1}&count={2}&start_row={3}&time_type={4}&relation_type={5}",
                URL_PREFIX, list_id, count, start_row, time_type, relation_type);

            getWithToken(token, url, handler, onError);
        }

    /// <summary>
    /// Awards an achievement.
    /// </summary>
    /// <param name="achievementName">The name of the achievement to award.</param>
    /// <param name="success">Callback triggers on successful award.</param>
    /// <param name="error">Callback triggers on error.</param>
    public static Coroutine AwardAchievement(string achievementName, SuccessHandler success, ErrorHandler error)
    {
        drWWW www = new drWWW(drAPI.awardAchievement);
        www.AddField("name", achievementName);

        www.OnSuccess += delegate {
            if (!(bool)www.result) { // This should never occur, but the check is here just in case
                drDebug.LogWarning("Did not award achievement \"" + achievementName + "\"");
                return;
            }

            if (!_awardedAchievements.Contains(achievementName)) {
                _awardedAchievements.Add(achievementName);
            }

            drClient.RefreshCanvasComponent(drClient.CanvasComponent.Achievements);
            drDebug.Log("Awarded achievement " + achievementName);
        }; www.OnSuccess += success;

        www.OnError += delegate (string errorMessage) {
            drDebug.LogError("Error awarding achievement \"" + achievementName + "\": " + errorMessage);
        }; www.OnError += error;

        return www.Fetch();
    }

        public void ApplyDispatchBehavior(ServiceDescription serviceDescription, System.ServiceModel.ServiceHostBase serviceHostBase)
        {
            IErrorHandler handler = new ErrorHandler();
            foreach (ChannelDispatcher chDisp in serviceHostBase.ChannelDispatchers)
            {
                if (chDisp.BindingName.Contains("WebHttpBinding"))
                {
                    chDisp.ErrorHandlers.Add(handler);
                    foreach (EndpointDispatcher epDisp in chDisp.Endpoints)
                    {
                        epDisp.DispatchRuntime.MessageInspectors.Add(new Authenticator());
                    }
                }
            }

            foreach (ServiceEndpoint endpoint in serviceDescription.Endpoints)
            {
                if (endpoint.Binding.GetType() == typeof(WebHttpBinding))
                {
                    foreach (OperationDescription operation in endpoint.Contract.Operations)
                    {
                        operation.Behaviors.Add(new CustomMessageFormatter.Behavior());
                    }
                }
            }
        }

        public override Microsoft.VisualStudio.Package.AuthoringScope ParseSource(ParseRequest req)
        {
            Babel.Source source = (Babel.Source)this.GetSource(req.FileName);
            bool yyparseResult = false;

            // req.DirtySpan seems to be set even though no changes have occurred
            // source.IsDirty also behaves strangely
            // might be possible to use source.ChangeCount to sync instead

            if (req.DirtySpan.iStartIndex != req.DirtySpan.iEndIndex
                || req.DirtySpan.iStartLine != req.DirtySpan.iEndLine) {
                ErrorHandler handler = new ErrorHandler();
                Scanner scanner = new Scanner(); // string interface
                Parser parser = new Parser();  // use noarg constructor
                parser.scanner = scanner;
                scanner.Handler = handler;
                parser.SetHandler(handler);
                scanner.SetSource(req.Text, 0);

                parser.MBWInit(req);
                yyparseResult = parser.Parse();

                // store the parse results
                // source.ParseResult = aast;
                source.ParseResult = null;
                source.Braces = parser.Braces;

                // for the time being, just pull errors back from the error handler
                if (handler.ErrNum > 0) {
                    foreach (Babel.Parser.Error error in handler.SortedErrorList()) {
                        TextSpan span = new TextSpan();
                        span.iStartLine = span.iEndLine = error.line - 1;
                        span.iStartIndex = error.column;
                        span.iEndIndex = error.column + error.length;
                        req.Sink.AddError(req.FileName, error.message, span, Severity.Error);
                    }
                }
            }
            switch (req.Reason) {
                case ParseReason.Check:
                case ParseReason.HighlightBraces:
                case ParseReason.MatchBraces:
                case ParseReason.MemberSelectAndHighlightBraces:
                    // send matches to sink
                    // this should (probably?) be filtered on req.Line / col
                    if (source.Braces != null) {
                        foreach (TextSpan[] brace in source.Braces) {
                            if (brace.Length == 2)
                                req.Sink.MatchPair(brace[0], brace[1], 1);
                            else if (brace.Length >= 3)
                                req.Sink.MatchTriple(brace[0], brace[1], brace[2], 1);
                        }
                    }
                    break;
                default:
                    break;
            }

            return new AuthoringScope(req.Text);
        }

        public Parser(Scanner scanner, ErrorHandler errors)
        {
            _scanner = scanner;
            _scanner.GetToken();

            _errors = errors;
        }

    /// <summary>
    /// Loads data.
    /// </summary>
    /// <param name="success">Callback triggers on successful data load.</param>
    /// <param name="error">Callback triggers on error.</param>
    public static Coroutine LoadData(SuccessHandler success, ErrorHandler error)
    {
        drWWW www = new drWWW(drAPI.loadData);

        www.OnSuccess += delegate {
            Hashtable result = www.result as Hashtable;

            if (result["data"] == null) {
                drDebug.LogWarning("No data exists in the data store to load");
           		return;
            }

            if (data == null) {
                data = new Dictionary<string, object>();
            }

            StoreReturnData(result["data"] as Hashtable);

            drDebug.Log("Loaded data");
        }; www.OnSuccess += success;

        www.OnError += delegate (string errorMessage) {
            drDebug.LogError("Error loading data: " + errorMessage);
        }; www.OnError += error;

        return www.Fetch();
    }

 public static Thread StartTry(MethodInvoker code, ErrorHandler on_error = null, MethodInvoker on_finally = null, bool background = true)
 {
     Thread t = new Thread(
         () => {
             try
             {
                 code.Invoke();
             }
             catch (ThreadAbortException e)
             {
                 Thread.ResetAbort();
             }
             catch (Exception e)
             {
                 if (on_error != null)
                     on_error.Invoke(e);
                 else
                     Message.Error(e);
             }
             finally
             {
                 on_finally?.Invoke();
             }
         }
     );
     t.IsBackground = background;
     t.Start();
     return t;
 }

    new void Awake()
    {
        base.Awake();
        if(smartFox.IsConnected)
        {
            CharacterList = new CharacterListHandler();
            CharacterSelected = new CharacterSelectedHandler();
            errorHandler = new ErrorHandler();

            // Register callback delegate
            smartFox.AddEventListener(SFSEvent.CONNECTION_LOST, OnConnectionLost);
            smartFox.AddEventListener(SFSEvent.LOGOUT, OnLogout);

            smartFox.AddLogListener(LogLevel.DEBUG, OnDebugMessage);

            // Personal message handlers
            handlers.Add("characterlist", CharacterList);
            handlers.Add("characterSelected", CharacterSelected);
            handlers.Add("error", errorHandler);

            CharacterList.afterMessageRecieved += AfterCharacterList;
            CharacterSelected.afterMessageRecieved += AfterCharacterSelected;

            // We are ready to get the character list
            new GetCharactersMessage(smartFox, false).Send();

        }
        else
        {
            Application.LoadLevel("Lobby");
        }
    }

        public PublishFolderPicker(string destinationName, ErrorHandler errorCallback, string rootPath)
        {
            // This call is required by the Windows Form Designer.
            InitializeComponent();
            destinationTree.RightToLeftLayout = true;
            this.buttonOK.Text = Res.Get(StringId.OKButtonText);
            this.buttonCancel.Text = Res.Get(StringId.CancelButton);
            this.label1.Text = Res.Get(StringId.PublishFolderPickerCaption);
            this.buttonNewFolder.ButtonText = Res.Get(StringId.NewFolder);
            this.buttonNewFolder.AccessibleName = Res.Get(StringId.NewFolder);
            this.buttonNewFolder.ToolTip = Res.Get(StringId.NewFolderTooltip);
            this.Text = Res.Get(StringId.PublishFolderPickerTitle);

            //set the error handler.
            errorHandler = errorCallback;

            //Root Node
            RootNode = new TreeNode();

            // configure tree
            RootNode.Text = destinationName;
            RootNode.Tag = rootPath;
            destinationTree.Nodes.Add(RootNode);
            destinationTree.SelectedNode = RootNode;
            destinationTree.SelectedNode.ImageIndex = 0;
        }

	public XmlParserInput
				(TextReader reader,
				 XmlNameTable nameTable,
				 ErrorHandler error)
			: this(reader, nameTable, null, error)
			{
			}

 public void ApplyDispatchBehavior(ServiceDescription serviceDescription, System.ServiceModel.ServiceHostBase serviceHostBase)
 {
    ErrorHandler handler = new ErrorHandler();
    foreach (ChannelDispatcher dispatcher in serviceHostBase.ChannelDispatchers)
    {
       dispatcher.ErrorHandlers.Add(handler);
    }
 }

        /**
         * Creates a network access point.
         * @param apDescriptor the address and port where to bind.
         * @param messageQueue the FIFO list where incoming messages should be queued
         * @param errorHandler the instance to notify when errors occur.
         */
        public NetAccessPoint(NetAccessPointDescriptor apDescriptor,
			MessageQueue             messageQueue,
			ErrorHandler			    errorHandler)
        {
            this.apDescriptor = apDescriptor;
            this.messageQueue = messageQueue;
            this.errorHandler = errorHandler;
        }

 public void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
 {
     IErrorHandler errorHandler = new ErrorHandler();
     foreach (ChannelDispatcher channelDispatcher in serviceHostBase.ChannelDispatchers)
     {
         channelDispatcher.ErrorHandlers.Add(errorHandler);
     }
 }

	protected Verifier( XmlReader document, ExpBuilder builder, ErrorHandler handler ) {
		this.document = document;
		this.handler = handler;
		this.builder = builder;
		this.attPruner = new AttPruner(builder);
		
		emptyStringToken = new StringToken("",builder,this);
	}

        public MessageProcessor(MessageQueue                  queue,
			MessageEventHandler    messageHandler,
			ErrorHandler           errorHandler)
        {
            this.messageQueue    = queue;
            this.messageHandler    = messageHandler;
            this.errorHandler    = errorHandler;
        }

        /// <summary>
        /// Provides the ability to change run-time property values or insert custom extension objects such as error handlers, 
        /// message or parameter interceptors, security extensions, and other custom extension objects.
        /// </summary>
        /// <param name="serviceDescription">
        /// The service description.
        /// </param>
        /// <param name="serviceHostBase">
        /// The host that is currently being built.
        /// </param>
        public void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
        {
            IErrorHandler errorHandler = new ErrorHandler(serviceDescription.ServiceType);

            foreach (var channelDispatcher in serviceHostBase.ChannelDispatchers.OfType<ChannelDispatcher>())
            {
                channelDispatcher.ErrorHandlers.Add(errorHandler);
            }
        }