code: def check_call_arguments(lineno, id_, args):
      
      if not global_.SYMBOL_TABLE.check_is_declared(id_, lineno, 'function'):
          return False
  
      if not global_.SYMBOL_TABLE.check_class(id_, CLASS.function, lineno):
          return False
  
      entry = global_.SYMBOL_TABLE.get_entry(id_)
  
      if len(args) != len(entry.params):
          c = 's' if len(entry.params) != 1 else ''
          syntax_error(lineno, "Function '%s' takes %i parameter%s, not %i" %
                       (id_, len(entry.params), c, len(args)))
          return False
  
      for arg, param in zip(args, entry.params):
          if not arg.typecast(param.type_):
              return False
  
          if param.byref:
              from symbols.var import SymbolVAR
              if not isinstance(arg.value, SymbolVAR):
                  syntax_error(lineno, "Expected a variable name, not an "
                                       "expression (parameter By Reference)")
                  return False
  
              if arg.class_ not in (CLASS.var, CLASS.array):
                  syntax_error(lineno, "Expected a variable or array name "
                                       "(parameter By Reference)")
                  return False
  
              arg.byref = True
  
      if entry.forwarded:  # The function / sub was DECLARED but not implemented
          syntax_error(lineno, "%s '%s' declared but not implemented" % (CLASS.to_string(entry.class_), entry.name))
          return False
  
      return True
docs: Check arguments against function signature.
  
          Checks every argument in a function call against a function.
          Returns True on success.