resolves the arguments for the callable and returns the array of args
434096
public function resolveArguments($callable, array $context) {
        $resolve_arg = $this->resolve_arg;

        $rf = $this->callableToReflectionFunctionAbstract($callable);

        $args = [];
        foreach ($rf->getParameters() as $i => $arg_meta) {
            $arg = $resolve_arg($arg_meta, $context);
            if (!count($arg) && $arg_meta->isOptional()) {
                continue;
            } else if (!count($arg)) {
                throw new Exception\ResolutionException($arg_meta);
            }

            $args[] = $arg[0];
        }

        return $args;
    }
1025511
def _parse_args(arg):
    '''
    
    '''
    yaml_args = salt.utils.args.yamlify_arg(arg)

    if yaml_args is None:
        return []
    elif not isinstance(yaml_args, list):
        return [yaml_args]
    else:
        return yaml_args
617983
def parse_args(self, arguments=None):
        
        self._args = self.parser.parse_args(arguments)
        return self.args
332430
def get_args_pairs(arguments):
    

    return ' '.join(' '.join(['-' + k, tcl_str(str(v))]) for k, v in arguments.items())
235282
def _parse_arguments():
        
        parser = get_base_arguments(get_parser())
        parser = get_tc_arguments(parser)
        args, unknown = parser.parse_known_args()
        return args, unknown
66061
def arguments(args = nil)
      return @_arguments if args.nil?
      @_arguments = []
      [*args].map(&:split).flatten.each do |arg|
        @_arguments << Clin::Argument.new(arg)
      end
    end
106048
private function resolveArgumentsFromMethodCall(Return_ $returnNode): array
    {
        $arguments = [];
        if ($returnNode->expr instanceof MethodCall) {
            foreach ($returnNode->expr->args as $arg) {
                if ($arg->value instanceof Array_) {
                    $arguments[] = $arg->value;
                }
            }
        }

        return $arguments;
    }
866685
def __arg_comps(self):
        '''
        
        '''
        fun = self.argv[0] if self.argv else ''
        parsed = salt.utils.args.parse_input(
            self.argv[1:],
            condition=False,
            no_parse=self.opts.get('no_parse', []))
        args = parsed[0]
        kws = parsed[1]
        return fun, args, kws
50837
def get_args_names(method)
      args = method.args
      args_names = ' '
      args.each_with_index { |a, i|args_names << "${#{i + 1}:#{a}}, " }
      args_names.chop!.chop! unless args.empty?
    end
763849
private function _resolveArgs(array $args)
        {
            $resolved = array();
            foreach ($args as $argDefinition) {
                switch ($argDefinition['type']) {
                    case 'lookup':
                        $resolved[] = $this->_lookupRecursive($argDefinition['item']);
                        break;
                    case 'value':
                        $resolved[] = $argDefinition['item'];
                        break;
                }
            }

            return $resolved;
        }
573087
def fn_kwargs(callable):
    
    fn = get_fn(callable)
    (args, _, _, defaults) = _inspect.getargspec(fn)
    if defaults is None: return { }
    return dict(list(zip(reversed(args), reversed(defaults))))
482565
function fixArgs (callee) {
  return (options, fn) => {
    if (typeof fn != 'function' && typeof options == 'function') {
      fn = options;
      options = {};
    }
    else {
      options = options || {};
    }

    options.asc = options.asc || options.asc == null;

    return callee(options, fn);
  };
}
1253479
function () {

            var args = arguments,
                argc = arguments.length;

            if (argc === 1) {
                if (args[0] === undefined || args[0] === null) {
                    return undefined;
                }

                return args[0];

            } else if (argc === 2) {

                if (args[0] === undefined || args[0] === null) {
                    return args[1];
                }

                return args[0];

            } else {

                if (args[0][args[1]] === undefined || args[0][args[1]] === null) {
                    return args[2];
                }

                return args[0][args[1]];
            }
        }
1108877
function resolveArray(arg) {
  var resolvedArray = new Array(arg.length);
  return arg
      .reduce(function(soFar, value, index) {
        return soFar
            .then(resolveItem.bind(null, value))
            .then(function(value) {
              resolvedArray[index] = value;
            });
      }, Promise.resolve())
      .then(function() {
        return resolvedArray;
      });
}
1184740
def resolve_args(args)
      if args.last.is_a?(Hash)
        deps = args.pop
        resolve_args_with_dependencies(args, deps)
      else
        resolve_args_without_dependencies(args)
      end
    end
1362185
function collectArguments() {
  var args = arguments, i = args.length, arr = new Array(i);
  while (i--) {
    arr[i] = args[i];
  }
  return arr;
}
827520
function resolveArgument(expr, argIndex) {
    if (typeof argIndex === 'undefined') {
        argIndex = 0;
    }
    if (!expr.arguments.length || !expr.arguments[argIndex]) {
        return;
    }
    this.applyPluginsBailResult('call require:commonjs:item', expr,
            this.evaluateExpression(expr.arguments[argIndex]));
}