
	Where results make sense

Topic: Formal parameters

In the News (Fri 1 Jan 10)

Northern Trust

Marvin Harrison

Peter Chernin

Gary Locke

Match Play

Penelope Cruz

Mickey Rourke

AR Rahman

Danny Boyle

Hugh Jackman

	[No title]
		An OPEN association for a formal generic or formal parameter is equivalent to the generic or parameter being unassociated, i.e., the formal generic or formal parameter must be of mode IN and it must have a default expression.
		It seems clear that formal (and local) generics are allowed default expressions, whose value is used to supply the value in the absence of an association element for a given instance of the generic.
		Formal parameters and their association (or lack of association) are discussed in Sections 2.1.1ff (Formal Parameters), 4.3.3ff (Interface Declarations), 7.3.3 (Function Calls), and 8.5 (Procedure Call Statement).
	www.vhdl.org /isac/IRs-VHDL-87/IR0066.txt (2667 words)

	C++ Notes: Function Parameters (Site not responding. Last check: 2007-10-21)
		Formal parameters are written in the function prototype and function header of the definition.
		Formal parameters are local variables which are assigned values from the arguments when the function is called.
		For value parameters (the default), the value of the actual parameter is assigned to the formal parameter variable.
	www.fredosaurus.com /notes-cpp/functions/params.html (237 words)

	Java Programming: Section 4.3 (Site not responding. Last check: 2007-10-21)
		When a subroutine is called, the actual parameters in the subroutine call statement are evaluated and the values are assigned to the formal parameters in the subroutine's definition.
		A common mistake is to assign values to the formal parameters at the beginning of the subroutine, or to ask the user to input their values.
		I'll finish this section on parameters by noting that we now have three different sorts of variables that can be used inside a subroutine: local variables defined in the subroutine, formal parameter names, and static member variables that are defined outside the subroutine but inside the same class as the subroutine.
	math.hws.edu /javanotes/c4/s3.html (2368 words)

	SMAL32 Manual, Macro Assembly
		The three macro parameter modes are: Name mode, in which the formal parameter is declared by just its name; list mode, in which the formal parameter name is surrounded by parentheses; and value mode, in which the formal parameter name is preceded by an equals sign.
		When a formal parameter is declared as a name parameter, the actual parameter may be any text which does not include commas unless the commas are parenthesized and as long as any parentheses in the text are balanced.
		When a formal parameter is declared as a list parameter, the actual parameter must be enclosed in parentheses and may contain any lexically valid text as long as the parentheses it contains are balanced.
	www.cs.uiowa.edu /~jones/cross/smal32/macro.html (1815 words)

	CSI 311: Notes on Parameter Passing (Site not responding. Last check: 2007-10-21)
		The l-values of the formal parameters are set equal to the l-values of the actual parameters.
		In particular, the conventions involving the scopes of variables and the parameter passing mechanisms are different in the various languages.
		Parameters must be declared as "var" parameters if the pass by reference mechanism is to be used.
	www.cs.albany.edu /~dran/teaching/csi311/parameter_passing.html (734 words)

	Parameters
		The correspondence between the actual parameters of the caller and the formal parameters of the called procedure is established by position or by keyword.
		Parameters can be inputs to the program unit; they can be outputs in which the values are set or changed by the program unit; or they can be both inputs and outputs.
		Parameters that are not used in the actual argument list are set to be undefined upon entering the procedure or function.
	www.astro.princeton.edu /~esirko/idl_html_help/procedures7.html (726 words)

	Procedure
		In case of constants, variables and signals, the parameter mode determines the direction of the information flow and it decides which formal parameters can be read or written inside the procedure.
		In case of formal parameters such as signal, variable and file, the actual parameters must be objects of the same class.
		Procedure Proc_1 has two formal parameters: the first one is a constant and it is of mode in and of the integer type, the second one is an output variable of the integer type.
	www.itn.liu.se /~andki/vhdl_refguide/VHD00052.htm (841 words)

	[No title]
		An expression that occurs in a generic formal part is either the default expression for a generic formal object of mode in, or a constituent of an entry name given as default name for a formal subprogram, or the default expression for a parameter of a formal subprogram.
		The type of a generic formal object of mode in must not be a limited type; the subtype of such a generic formal object is the subtype denoted by the type mark given in the generic parameter declaration.
		A generic formal object of mode in out is a variable and denotes the object supplied as the matching generic actual parameter in a generic instantiation, as described in section 12.3.
	www.csci.csusb.edu /dick/cs320/ada/lrm/12.generics (3312 words)

	Pref::typeCheck -- type checking of formal parameters (Site not responding. Last check: 2007-10-21)
		A type can be determined to every formal parameter with a new syntax.
		If the type checking will be enabled, the types of given parameters of such a procedure will be checked and results an error if it fails.
		The new syntax to test parameters directly (without a test in the procedure body) is the formal parameter followed by a colon and then the type object:
	www.sciface.com /STATIC/DOC25/de/Pref/typeCheck.shtml (203 words)

	Compilers - Chapter 17
		Formal parameters in a subprogram (when declared in this way) are effectively variables local to that subprogram, which start their lives initialized to the values of the corresponding actual parameter expressions.
		Formal parameters are treated within the Block of a function or procedure in most cases as though they were variables.
		Formal parameter names, like local variable names, will be entered at a higher level than the procedure or function name, so as to reserve them local status.
	www.scifac.ru.ac.za /compilers/cha17g.htm (6999 words)

	[No title]
		formal parameters --- the local variables assigned to the data objects passed to the subprogram at the time it is called.
		(In other words, the formal parameters are treated as uninitialized local variables and at the end of the subprogram, their values are copied to the locations that were passed as the actual parameters.) How Ada does it --------------- Ada controls parameter passing by declaring them to be in, out or in out.
		Parameter transmission ---------------------- The actual parameters have to be computed first, then the code for the called subprogram runs; the prologue copies the actual parameters or pointers to the actual parameters into locations in the activation record.
	www.eecis.udel.edu /~chester/courses/670-04s/subroutines (1546 words)

	' + pPage + '
		Untyped formal parameters allow you to pass a variable of any data type or length to it.
		Notice the output length is not passed from the actual to the formal parameter.
		Parameters can be passed in three ways: by value, by value and results, and by reference.
	cma.zdnet.com /book/abap/ch18/ch18.htm (4590 words)

	[No title]
		The parameters which are not specified may be referenced by name as expanded names using the formal package as its prefix.
		Similarly, any implicit declarations associated with a given parameter of the formal package may be named using the formal package as a prefix only when the actual for the parameter is not specified.
		In addition, for each actual parameter that is not required to match, a copy of the declaration of the corresponding formal parameter of the template is included in the visible part of the formal package.
	www.ada-auth.org /cgi-bin/cvsweb.cgi/AIs/AI-00317.TXT?rev=1.7 (1575 words)

	[No title] (Site not responding. Last check: 2007-10-21)
		Provided by a subprogram that takes a generic parameter that is used in a type of expression that describes the types of the parameters of the subprogram.
		A subprogram that passes a subprogram name as a parameter must have in its static ancestry the unit in which that subprogram was declared so the compiler can simply pass the link to the static parent of the subprogram to be passed, along with the subprogram name.
		When the call is to a subprogram that has been passed as a parameter, pointers to all of the static ancestors of that subprogram must be placed in the display, thus requiring that that number of old display pointers is saved.
	www.geocities.com /vxrbn/cs320/9-16FULL.doc (2953 words)

	[No title] (Site not responding. Last check: 2007-10-21)
		Data/information passed in via parameters The parameters that appear in the subprogram definition (header, prototype) are the formal parameters.
		Positional Parameters The binding of actual parameters (in the call) to the formal parameters are done simply by the position they appear in.
		Pass-By-Name When a parameter is passed by name, the text of the actual parameter is passed and substituted for the formal parameter everywhere it appears in the subprogram.
	www.cs.uah.edu /~mallen/cs524/chapter9.doc (1354 words)

	CT201 Lecture 17: Void Function Calls with Parameters
		Call-by-value formal parameters are equivalent to locally declared variables which are automatically initialised by assignments of the values of the corresponding actual parameters at call time.
		As the value parameters cease to exist when the call is completed, it is not appropriate to refer to them in the condition, so occurrences of them should be replaced by their values in terms of external data.
		Let R denote the list of static formal parameters, W the list of dynamic ones, and a the list of variables occurring in actual parameters (these, of course, may be expressions).
	www.co.umist.ac.uk /~zeng/ct201/CT201Lec17.htm (2316 words)

	Oberon-2 Report
		Value parameters are local variables to which the value of the corresponding actual parameter is assigned as an initial value.
		The scope of a formal parameter extends from its declaration to the end of the procedure block in which it is declared.
		If r is a receiver parameter declared with type T, r.P^denotes the (redefined) procedure P bound to the base type of T. In a forward declaration of a type-bound procedure the receiver parameter must be of the same type as in the actual procedure declaration.
	www.excelsior-usa.com /doc/o2rep10.html (929 words)

	[Chapter 15] 15.6 Parameters (Site not responding. Last check: 2007-10-21)
		The parameters of a module are at least as important as the code that implements the module (the module's body).
		The formal parameters are the names that are declared in the parameter list of the header of a module.
		The formal parameter and the actual parameter that corresponds to the formal parameter (when called) must be of the same or compatible datatypes.
	www.unix.org.ua /orelly/oracle/prog2/ch15_06.htm (3143 words)

	[No title] (Site not responding. Last check: 2007-10-21)
		Pass-by-Result (out-mode) _________________________ - no value is transferred to formal parameters but just before subprogram terminates the value of the formal parame- ter is passed to the actual parameter.
		sub (p1,p1) if the two formal parameters are assigned different values in the sub- program, the order of return affects the result.
		Parameters that are Subprogram Names ********************************** - It is useful to be able to pass the name of a subprogram as a parameter**.
	www.cs.uregina.ca /~norma/cs440-chapter8.txt (1497 words)

	Inheritance and Derived Classes (Site not responding. Last check: 2007-10-21)
		At run time, the values of the actual parameters are copied into the formal parameters before the function is executed.
		If the actual and value foraml parameters are of different data types, a type conversion is performed from the actual to the formal parameter type, provided such a type conversion is defined.
		If, for example, the actual parameters were arrays of 1000 elements each, this would result in a considerable saving of time, equivalent to 3000 copy opeartions on entry, for example.
	www.ece.eps.hw.ac.uk /~andy/dsa/section7.htm (656 words)

	Introduction
		The actual parameter must be assignment compatible with the formal parameter or, in the case of a conformant array parameter, must conform with the formal parameter.
		The actual parameter must have a type identical with the formal parameter or conform with the formal parameter, in the case of a conformant array schema.
		Two formal parameter lists are congruent if they contain an equal number of parameters, and the parameters in corresponding positions are equivalent.
	docs.hp.com /en/92431-90013/ch08s01.html (778 words)

	[No title]
		The header defines the name of the routine and its formal parameters and is always considered as a part of the formal specification of the routine.
		The type consistency between actual and formal parameters is defined so that routines can be analyzed strictly on the basis of their formal parameters without regard to any actual parameters; the consistency rules then ensure that the type constraints of the actual parameters satisfy the type constraints of the formals.
		The formal parameters are bound to the actual parameters so that the formals are interpreted as pseudonyms for the names of the corresponding actuals.
	www.cs.utexas.edu /users/boyer/ftp/ics-reports/cmp10.text (14594 words)

	Chapter 6: Compiling Procedure and Function Calls
		When compiling a call to a procedure or function, each actual parameter is checked to see that it matches in kind and type with the corresponding formal parameter of the procedure's declaration.
		It is important that you should be able to distinguish between the formal parameters of a procedure (as declared in its declaration) and the actual parameters of a call to the procedure.
		, passed as a parameter [2227], is the pointer to the identifier of the routine being called.
	homepages.cwi.nl /~steven/pascal/book/6procfunc.html (1544 words)

	[No title]
		In case of formal parameters that are arrays or records, Ada 83 implementations give a choice between pass-by-value-result and pass-by-reference.
		Note: because the address of the second parameter is computed at the beginning of fun, any change of the global i has no effect on the address used at the end to return the value of list[i].
		Parameters That Are Subpgm Names Occasions to pass subpgms as parameters: Ex: Visiting nodes of a Binary Tree, and Processing via different functions.
	vorlon.cwru.edu /~jrl7/345/ch9.doc (3040 words)

	Hyperlinked ECMA C# Language Specification
		4 In a method invocation, a parameter array permits either a single argument of the given array type to be specified, or it permits zero or more arguments of the array element type to be specified.
		2 Names are introduced into this declaration space by the formal parameter list of the method and by local variable declarations in the block of the method.
		Paragraph 61 A method invocation (§14.5.5.1) creates a copy, specific to that invocation, of the formal parameters and local variables of the method, and the argument list of the invocation assigns values or variable references to the newly created formal parameters.
	www.jaggersoft.com /csharp_standard/17.5.1.htm (440 words)

	Formal and Actual Parameters (Site not responding. Last check: 2007-10-21)
		Return type is int / int function3(char letter1, char letter2) { return (1); } / function header - 2 formal parameters named letter and number of type char, int.
		Return type is void - this functions acts like a procedure / void function4(char letter, int number) { return; /note: the return statement returns nothing and is NOT needed/ } / function header - 0 formal parameters.
		Return type is void - this functions acts like a procedure / void function5(void) { } / function header - 1 formal parameter of type address of an integer.
	www.cs.montana.edu /~sonder/C_examples/Functions/form_act.html (184 words)

	Conformant Array Parameters
		A conformant array parameter is a formal array parameter defined by a conformant array schema (the syntax appears in the
		The actual parameter for the formal conformant array schema is an array, and its bounds are the actual parameters of the formal bounds parameters.
		When HP Pascal passes an actual parameter to a formal conformant array parameter of more than one dimension, it also passes one hidden parameter for each inner dimension that is itself a conformant array.
	docs.hp.com /en/92431-90014/ch07s05.html (389 words)

	3.5 Evaluation Rules: Actual and Formal Parameters, Locals, Globals (Site not responding. Last check: 2007-10-21)
		Because it is neither a parameter nor a local variable Maple defines it to be a global variable.
		For reasons of efficiency and desirability, the Maple designers have decided that local variables and parameters evaluate one level, i.e.
		function can be used to get full evaluation for local variables and parameters, and one level evaluation of global variables should you ever need it, e.g.
	users.aber.ac.uk /tpd/MA104_prg/node19.html (297 words)

	[No title] (Site not responding. Last check: 2007-10-21)
		The original value of the actual parameter is accessible to the procedure.
		In the algorithm: Proc_One (this_var) In the module: procedure Proc_One(this_one iot in/out num)¡Ô" 33ÿþ#33ÿþ,ª,’. ó:R¨How In/Out Parameters Work¡&ÿ3þ¨nIn/out formal parameters act as a reference to the matching actual parameter.
		Reading and writing are allowed.¡Fo" 33ÿþ#33ÿþó;S¨How Out Parameters Work¡&ÿ3þ¨öOut formal parameters act as a reference to the matching actual parameter.
	www.cc.gatech.edu /fac/Bill.Leahy/cs1311/cs1311lecture05.ppt (701 words)

Try your search on: Qwika (all wikis)