import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
@Override
public void register(Trigger t) {
  whiches.forEach(which -> {
    String pattern = which.getPattern();
    if (!expressions.contains(pattern)) {
      expressions.add(pattern);
      expressionInfos.put(pattern, which);
    }

    Map<SyntaxInfo, Trigger> handlerMap = isChanger ? changerHandlers : expressionHandlers;
    if (handlerMap.containsKey(which)) {
      Skript.error(String.format("The custom expression '%s' already has a handler.", pattern));
    } else {
      handlerMap.put(which, t);
    }
  });
  updateExpressions();
}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
@Override
public T[] getAll(Event e) {
  Trigger trigger = expressionHandlers.get(which);
  ExpressionGetEvent expressionEvent = new ExpressionGetEvent(e, exprs, parseResult);

  if (trigger == null) {
    Skript.error(
        String.format("The custom expression '%s' no longer has a get handler.",
            which.getPattern())
    );
    return Util.newArray(superType, 0);
  } else {
    trigger.execute(expressionEvent);
  }

  if (expressionEvent.getOutput() == null) {
    Skript.error(
        String.format("The get handler for '%s' did not continue.", which.getPattern())
    );
    return Util.newArray(superType, 0);
  }

  return Converters.convertArray(expressionEvent.getOutput(), types, superType);
}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
/**
 * For unit testing
 * 
 * @param node
 * @return The loaded Trigger
 */
@Nullable
static Trigger loadTrigger(final SectionNode node) {
	String event = node.getKey();
	if (event == null) {
		assert false : node;
		return null;
	}
	if (event.toLowerCase().startsWith("on "))
		event = "" + event.substring("on ".length());
	
	final NonNullPair<SkriptEventInfo<?>, SkriptEvent> parsedEvent = SkriptParser.parseEvent(event, "can't understand this event: '" + node.getKey() + "'");
	if (parsedEvent == null) {
		assert false;
		return null;
	}
	
	setCurrentEvent("unit test", parsedEvent.getFirst().events);
	try {
		return new Trigger(null, event, parsedEvent.getSecond(), loadItems(node));
	} finally {
		deleteCurrentEvent();
	}
}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
@Override
public void unregister(final Trigger t) {
	assert t == this.t;
	this.t = null;
	final Iterator<EvtAtInfo> iter = triggers.values().iterator();
	while (iter.hasNext()) {
		final EvtAtInfo i = iter.next();
		i.list.remove(this);
		if (i.currentIndex >= i.list.size())
			i.currentIndex--;
		if (i.list.isEmpty())
			iter.remove();
	}
	if (triggers.isEmpty())
		unregisterAll();
}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
@Override
	public void register(final Trigger trigger) {
//		if (types == null) {
//			final BlockLocation l = new BlockLocation(world, x, y, z);
//			List<Trigger> ts = blockTriggers.get(l);
//			if (ts == null)
//				blockTriggers.put(l, ts = new ArrayList<Trigger>());
//			ts.add(trigger);
//		} else {
		for (final ItemType t : types) {
			for (final ItemData d : t) {
				if (d.getId() > Skript.MAXBLOCKID)
					continue;
				List<Trigger> ts = itemTypeTriggers.get(d.getId());
				if (ts == null)
					itemTypeTriggers.put(d.getId(), ts = new ArrayList<Trigger>());
				ts.add(trigger);
			}
		}
//		}
		if (!registeredExecutor) {
			Bukkit.getPluginManager().registerEvent(PlayerMoveEvent.class, new Listener() {}, SkriptConfig.defaultEventPriority.value(), executor, Skript.getInstance(), true);
			registeredExecutor = true;
		}
	}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
@Override
	public void unregister(final Trigger t) {
//		final Iterator<Entry<BlockLocation, List<Trigger>>> i = blockTriggers.entrySet().iterator();
//		while (i.hasNext()) {
//			final List<Trigger> ts = i.next().getValue();
//			ts.remove(t);
//			if (ts.isEmpty())
//				i.remove();
//		}
		final Iterator<Entry<Integer, List<Trigger>>> i2 = itemTypeTriggers.entrySet().iterator();
		while (i2.hasNext()) {
			final List<Trigger> ts = i2.next().getValue();
			ts.remove(t);
			if (ts.isEmpty())
				i2.remove();
		}
	}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
@Override
public void unregister(Trigger t) {
  whiches.forEach(which -> {
    Map<SyntaxInfo, Trigger> handlerMap = isChanger ? changerHandlers : expressionHandlers;
    handlerMap.remove(which);

    if (!expressionHandlers.containsKey(which) && !changerHandlers.containsKey(which)) {
      expressions.remove(which.getPattern());
      expressionInfos.remove(which.getPattern());
    }
  });
  updateExpressions();
}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
@Override
public void change(Event e, Object[] delta, Changer.ChangeMode mode) {
  Trigger trigger = changerHandlers.get(which);
  ExpressionChangeEvent expressionEvent =
      new ExpressionChangeEvent(e, exprs, parseResult, delta, mode);

  if (trigger == null) {
    Skript.error(
        String.format("The custom expression '%s' no longer has a change handler.",
            which.getPattern())
    );
  } else {
    trigger.execute(expressionEvent);
  }
}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
@Override
public void register(Trigger t) {
  if (effects.contains(which)) {
    Skript.error(String.format("The custom effect '%s' already has a handler.", which));
    return;
  }
  effects.add(which);
  effectHandlers.put(which, t);
  updateEffects();
}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
private EffectEvent invokeEffect(Event e) {
  Trigger trigger = effectHandlers.get(which);
  EffectEvent effectEvent = new EffectEvent(e, exprs, parseResult, which, getNext());
  if (trigger == null) {
    Skript.error(String.format("The custom effect '%s' no longer has a handler.", which));
  } else {
    trigger.execute(effectEvent);
  }
  return effectEvent;
}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
@Override
public void register(Trigger t) {
  whiches.forEach(which -> {
    String pattern = which.getPattern();
    if (!conditions.contains(pattern)) {
      conditions.add(pattern);
      conditionInfos.put(pattern, which);
      conditionHandlers.put(which, t);
    } else {
      Skript.error(String.format("The custom condition '%s' already has a handler.", pattern));
    }
  });
  updateConditions();
}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
@Override
public void unregister(Trigger t) {
  whiches.forEach(which -> {
    conditions.remove(which.getPattern());
    conditionInfos.remove(which.getPattern());
    conditionHandlers.remove(which);
  });
  updateConditions();
}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
@Override
public boolean check(Event e) {
  Trigger trigger = conditionHandlers.get(which);
  ConditionEvent conditionEvent = new ConditionEvent(e, exprs, parseResult);
  trigger.execute(conditionEvent);
  return conditionEvent.isMarkedContinue() == !which.isInverted();
}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
@Override
public void register(Trigger trigger) {
    if (!afterInitRun) {
        afterInit();
        afterInitRun = true;
    }
}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
private final static Iterator<Trigger> getTriggers(final Class<? extends Event> event) {
	return new Iterator<Trigger>() {
		@Nullable
		private Class<?> e = event;
		@Nullable
		private Iterator<Trigger> current = null;
		
		@Override
		public boolean hasNext() {
			Iterator<Trigger> current = this.current;
			Class<?> e = this.e;
			while (current == null || !current.hasNext()) {
				if (e == null || !Event.class.isAssignableFrom(e))
					return false;
				final List<Trigger> l = triggers.get(e);
				this.current = current = l == null ? null : l.iterator();
				this.e = e = e.getSuperclass();
			}
			return true;
		}
		
		@Override
		public Trigger next() {
			final Iterator<Trigger> current = this.current;
			if (current == null || !hasNext())
				throw new NoSuchElementException();
			final Trigger next = current.next();
			assert next != null;
			return next;
		}
		
		@Override
		public void remove() {
			throw new UnsupportedOperationException();
		}
	};
}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
static void addTrigger(final Class<? extends Event>[] events, final Trigger trigger) {
	for (final Class<? extends Event> e : events) {
		List<Trigger> ts = triggers.get(e);
		if (ts == null)
			triggers.put(e, ts = new ArrayList<Trigger>());
		ts.add(trigger);
	}
}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
static ScriptInfo removeTriggers(final File script) {
	final ScriptInfo info = new ScriptInfo();
	info.files = 1;
	
	final Iterator<List<Trigger>> triggersIter = SkriptEventHandler.triggers.values().iterator();
	while (triggersIter.hasNext()) {
		final List<Trigger> ts = triggersIter.next();
		for (int i = 0; i < ts.size(); i++) {
			if (script.equals(ts.get(i).getScript())) {
				info.triggers++;
				ts.remove(i);
				i--;
				if (ts.isEmpty())
					triggersIter.remove();
			}
		}
	}
	
	for (int i = 0; i < selfRegisteredTriggers.size(); i++) {
		final Trigger t = selfRegisteredTriggers.get(i);
		if (script.equals(t.getScript())) {
			info.triggers++;
			((SelfRegisteringSkriptEvent) t.getEvent()).unregister(t);
			selfRegisteredTriggers.remove(i);
			i--;
		}
	}
	
	info.commands = Commands.unregisterCommands(script);
	
	info.functions = Functions.clearFunctions(script);
	
	return info;
}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
static void removeAllTriggers() {
		triggers.clear();
		for (final Trigger t : selfRegisteredTriggers)
			((SelfRegisteringSkriptEvent) t.getEvent()).unregisterAll();
		selfRegisteredTriggers.clear();
//		unregisterEvents();
	}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
@SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD")
public ScriptFunction(final String name, final Parameter<?>[] parameters, final SectionNode node, @Nullable final ClassInfo<T> returnType, final boolean single) {
	super(name, parameters, returnType, single);
	
	// here to allow recursion
	Functions.functions.put(name, new FunctionData(this));
	
	Functions.currentFunction = this;
	try {
		trigger = new Trigger(node.getConfig().getFile(), "function " + name, new SimpleEvent(), ScriptLoader.loadItems(node));
	} finally {
		Functions.currentFunction = null;
	}
}
 

import ch.njol.skript.lang.Trigger; //导入依赖的package包/类
@Override
public void register(final Trigger t) {
	this.t = t;
	for (final World w : worlds) {
		EvtAtInfo i = triggers.get(w);
		if (i == null) {
			triggers.put(w, i = new EvtAtInfo());
			i.lastTick = (int) w.getTime() - 1;
		}
		i.list.add(this);
		Collections.sort(i.list);
	}
	registerListener();
}