This registers an alias.
189315
def register(keyword, command)
      @aliases.register(keyword.to_sym) do
        lambda do |args|
          # directly execute shell commands
          if command.start_with?("!")
            return Util::SafeExec.exec "#{command[1..-1]} #{args.join(" ")}".strip
          end

          return CLI.new(command.split.concat(args), @env).execute
        end
      end
    end
157231
public function registerAlias($alias, $file, $extension = null)
    {
        if ($extension === null) {
            $extension = File::extension($file);
        }

        $extension = strtolower($extension);

        if (!isset($this->aliases[$extension])) {
            $this->aliases[$extension] = [];
        }

        $this->aliases[$extension][$alias] = $file;

        return $this;
    }
509883
def register_signal(alias: str, signal: pyqtSignal):
        
        if SignalDispatcher.signal_alias_exists(alias):
            raise SignalDispatcherError('Alias "' + alias + '" for signal already exists!')

        SignalDispatcher.signals[alias] = signal
1298172
def delete_alias(self, alias_name):
        """"""
        for aliases in self.key_to_aliases.values():
            if alias_name in aliases:
                aliases.remove(alias_name)
668594
def register_property_alias(aliaz, attribute)
      std = standard_attribute(attribute)
      raise ArgumentError.new("#{self} attribute not found: #{attribute}") if std.nil?
      @local_std_prop_hash[aliaz.to_sym] = std
    end
954389
protected function registerProvidersAliases()
    {
        $loader = AliasLoader::getInstance();
        foreach ($this->aliases as $alias => $provider) {
            if (class_exists($provider)) {
                $loader->alias(
                    $alias,
                    $provider
                );
            }
        }
    }
700593
def register(matcher, *aliases):
    
    docstr = matcher.__doc__ if matcher.__doc__ is not None else ''
    helpmatchers[matcher] = docstr.strip()

    for alias in aliases:
        matchers[alias] = matcher
        # Map a normalized version of the alias
        norm = normalize(alias)
        normalized[norm] = alias
        # Map a version without snake case
        norm = norm.replace('_', '')
        normalized[norm] = alias
91163
public static function registerTypeAlias($alias, $type)
    {
        Assert::notBlank($alias, 'Alias name cannot be blank');
        Assert::notBlank($type, 'Target type name cannot be blank');
        self::$aliases[strtolower($alias)] = $type;
    }
775951
def Alias(self, alias):
        """"""
        # FIXME
        if self.generate_comments:
            self.print_comment(alias)
        print("%s = %s # alias" % (alias.name, alias.alias), file=self.stream)
        self._aliases += 1
        return
11113
protected static void registerAlias(Class<?> parent, String alias, String cname) {
    Entry e = data.get(parent);
    assert (e != null);
    e.addAlias(alias, cname);
  }
962262
def make_alias(self, entry):
        
        entry.add_alias(self)
        self.alias = entry
        self.scope = entry.scope  # Local aliases can be "global" (static)
        self.byref = entry.byref
        self.offset = entry.offset
        self.addr = entry.addr
814922
protected function registerContainerAliases()
    {
        $aliases = [
            'app' => ['Illuminate\Container\Container', 'Illuminate\Contracts\Container\Container'],
            'config' => ['Illuminate\Config\Repository', 'Illuminate\Contracts\Config\Repository'],
            'log' => ['Psr\Log\LoggerInterface'],
        ];
        
        foreach ($aliases as $key => $aliases) {
            foreach ($aliases as $alias) {
                $this->alias($key, $alias);
            }
        }
    }
463147
def register_aliases(self, aliases):
    
    if not isinstance(aliases, BuildFileAliases):
      raise TypeError('The aliases must be a BuildFileAliases, given {}'.format(aliases))

    for alias, target_type in aliases.target_types.items():
      self._register_target_alias(alias, target_type)

    for alias, target_macro_factory in aliases.target_macro_factories.items():
      self._register_target_macro_factory_alias(alias, target_macro_factory)

    for alias, obj in aliases.objects.items():
      self._register_exposed_object(alias, obj)

    for alias, context_aware_object_factory in aliases.context_aware_object_factories.items():
      self._register_exposed_context_aware_object_factory(alias, context_aware_object_factory)
542515
def register_name(self, clsdict):
        
        if self.name is None:
            return
        clsdict[self.name] = self.value
192730
def using(self, alias):
        
        clone = self._clone()
        clone._index = alias
        return clone
608310
public void addAlias(Object alias) {
	  if (lock == SET) {
		 throw new IllegalStateException("EntryInfo is locked");
	  }
	  if (alias != null && !alias.equals("")) {
		  aliasList.add(alias);
	  }
   }
1297264
public static void register(String type, String local, String alias) {
        instance.get(type).register(local, alias);
    }