Goto
Goto (goto, GOTO, GO TO, GoTo, or other case combinations, depending on the programming language) is a
goto
is a form of branch or jump statement, in some cases combined with a stack adjustment. Many languages support the goto
statement, and many do not (see § language supportThe
The use of goto was formerly common, but since the advent of structured programming in the 1960s and 1970s, its use has declined significantly. It remains in use in certain common usage patterns, but alternatives are generally used if available. In the past, there was considerable debate in academia and industry on the merits of the use of goto statements. The primary criticism is that code that uses goto statements is harder to understand than alternative constructions. Debates over its (more limited) uses continue in academia and software industry circles.
Usage
goto label
The goto
statement is often combined with the
IF condition THEN goto label
Programming languages impose different restrictions with respect to the destination of a goto
statement. For example, the
Criticism
At the pre-ALGOL meeting held in 1959, Heinz Zemanek explicitly cast doubt on the necessity of GOTO statements; at the time no one[citation needed] paid attention to his remark, including Edsger W. Dijkstra, who later became the iconic opponent of GOTO.[3] The 1970s and 1980s saw a decline in the use of GOTO statements in favor of the structured programming paradigm, with GOTO criticized as leading to unmaintainable spaghetti code. Some programming style coding standards, for example the GNU Pascal Coding Standards, recommend against the use of GOTO statements.[4] The Böhm–Jacopini proof (1966) did not settle the question of whether to adopt structured programming for software development, partly because the construction was more likely to obscure a program than to improve it because its application requires the introduction of additional local variables.[5] It did, however, spark a prominent debate among computer scientists, educators, language designers and application programmers that saw a slow but steady shift away from the formerly ubiquitous use of the GOTO. Probably the most famous criticism of GOTO is a 1968 letter by Edsger Dijkstra called "Go-to statement considered harmful".[3] In that letter, Dijkstra argued that unrestricted GOTO statements should be abolished from higher-level languages because they complicated the task of analyzing and verifying the correctness of programs (particularly those involving loops).[6] The letter itself sparked a debate, including a ""GOTO Considered Harmful" Considered Harmful" letter[7] sent to Communications of the ACM (CACM) in March 1987, as well as further replies by other people, including Dijkstra's On a Somewhat Disappointing Correspondence.[8]
An alternative viewpoint is presented in Donald Knuth's Structured Programming with go to Statements, which analyzes many common programming tasks and finds that in some of them GOTO is the optimal language construct to use.[9] In The C Programming Language, Brian Kernighan and Dennis Ritchie warn that goto
is "infinitely abusable", but also suggest that it could be used for end-of-function error handlers and for multi-level breaks from loops.[10] These two patterns can be found in numerous subsequent books on C by other authors;[11][12]
[13][14] a 2007 introductory textbook notes that the error handling pattern is a way to work around the "lack of built-in exception handling within the C language".[11] Other programmers, including Linux kernel designer and coder Linus Torvalds or software engineer and book author Steve McConnell, also object to Dijkstra's point of view, stating that GOTOs can be a useful language feature, improving program speed, size and code clarity, but only when used in a sensible way by a comparably sensible programmer.[15][16] According to computer science professor John Regehr, in 2013, there were about 100,000 instances of goto in the Linux kernel code.[17]
Other academics took a more extreme viewpoint and argued that even instructions like break
and return
from the middle of loops are bad practice as they are not needed in the Böhm–Jacopini result, and thus advocated that loops should have a single exit point.[18] For instance, Bertrand Meyer wrote in his 2009 textbook that instructions like break
and continue
"are just the old goto
in sheep's clothing".[19] A slightly modified form of the Böhm–Jacopini result, however, allows the avoidance of additional variables in structured programming, as long as multi-level breaks from loops are allowed.[20] Because some languages like C don't allow multi-level breaks via their break
keyword, some textbooks advise the programmer to use goto
in such circumstances.[14] The MISRA C 2004 standard bans goto
, continue
, as well as multiple return
and break
statements.[21] The 2012 edition of the MISRA C standard downgraded the prohibition on goto
from "required" to "advisory" status; the 2012 edition has an additional, mandatory rule that prohibits only backward, but not forward jumps with goto
.[22][23]
Entry 17.10 in comp.lang.c FAQ list[27] addresses the issue of GOTO use directly, stating
Programming style, like writing style, is somewhat of an art and cannot be codified by inflexible rules, although discussions about style often seem to center exclusively around such rules. In the case of the goto statement, it has long been observed that unfettered use of goto's quickly leads to unmaintainable spaghetti code. However, a simple, unthinking ban on the goto statement does not necessarily lead immediately to beautiful programming: an unstructured programmer is just as capable of constructing a Byzantine tangle without using any goto's (perhaps substituting oddly-nested loops and Boolean control variables, instead). Many programmers adopt a moderate stance: goto's are usually to be avoided, but are acceptable in a few well-constrained situations, if necessary: as multi-level break statements, to coalesce common actions inside a switch statement, or to centralize cleanup tasks in a function with several error returns. (...) Blindly avoiding certain constructs or following rules without understanding them can lead to just as many problems as the rules were supposed to avert. Furthermore, many opinions on programming style are just that: opinions. They may be strongly argued and strongly felt, they may be backed up by solid-seeming evidence and arguments, but the opposing opinions may be just as strongly felt, supported, and argued. It's usually futile to get dragged into "style wars", because on certain issues, opponents can never seem to agree, or agree to disagree, or stop arguing.
Common usage patterns
While overall usage of goto has been declining, there are still situations in some languages where a goto provides the shortest and most straightforward way to express a program's logic (while it is possible to express the same logic without gotos, the equivalent code will be longer and often more difficult to understand). In other languages, there are structured alternatives, notably exceptions and tail calls.
Situations in which goto is often useful include:
- To make the code more readable and easier to follow[15][28]
- To make smaller programs, and get rid of code duplication[15][28]
- Implement a tail call elimination), particularly in automatically generated C code.[29] For example, goto in the canonical LR parser.
- Implementing multi-level break and continue if not directly supported in the language; this is a common idiom in C.[14] Although Java reserves the goto keyword, it doesn't actually implement it. Instead, Java implements labelled break and labelled continue statements.[30] According to the Java documentation, the use of gotos for multi-level breaks was the most common (90%) use of gotos in C.[31] Java was not the first language to take this approach—forbidding goto, but providing multi-level breaks— the BLISS programming language (more precisely the BLISS-11 version thereof) preceded it in this respect.[32]
- Surrogates for single-level break or continue (retry) statements when the potential introduction of additional loops could incorrectly affect the control flow. This practice has been observed in Netbsd code.[33]
- Error handling (in absence of exceptions), particularly cleanup code such as resource deallocation.setjmp and longjmp are another alternative, and have the advantage of being able to unwind part of the call stack.
- Popping the stack in, e.g., Algol, PL/I.
- Specialized scripting languages that operate in a linear manner, such as a dialogue system for video games.[36]
These uses are relatively common in C, but much less common in C++ or other languages with higher-level features.[34] However, throwing and catching an exception inside a function can be extraordinarily inefficient in some languages; a prime example is Objective-C, where a goto is a much faster alternative.[37]
Another use of goto statements is to modify poorly factored
Alternatives
Structured programming
The modern notion of
goto
, since the target code, being drawn from the library, would not know where to jump back to.
Later, high-level languages such as
- Loops using
while
,repeat until
ordo
, andfor
statements switch
a.k.a.case
statements, a form of multiway branching
These new language mechanisms replaced equivalent flows which previously would have been written using goto
s and if
s. Multi-way branching replaces the "computed goto" in which the instruction to jump to is determined dynamically (conditionally).
Under certain conditions it is possible to eliminate local goto statements of legacy programs by replacing them with multilevel loop exit statements.[40]
Exceptions
In practice, a strict adherence to the basic three-structure template of structured programming yields highly nested code, due to inability to exit a structured unit prematurely, and a combinatorial explosion with quite complex program state data to handle all possible conditions.
Two solutions have been generally adopted: a way to exit a structured unit prematurely, and more generally
break
and continue
allow one to terminate a loop or continue to the next iteration, without requiring an extra while
or if
statement. In some languages multi-level breaks are also possible. For handling exceptional situations, specialized exception handlingtry
/catch
/finally
in Java.
The throw-catch exception handling mechanisms can also be easily abused to create non-transparent control structures, just like goto can be abused.[41]
Tail calls
In a paper delivered to the ACM conference in Seattle in 1977,
Although Steele's paper did not introduce much that was new to computer science, at least as it was practised at MIT, it brought to light the scope for procedure call optimization, which made the modularity-promoting qualities of procedures into a more credible alternative to the then-common coding habits of large monolithic procedures with complex internal control structures and extensive state data. In particular, the tail call optimizations discussed by Steele turned the procedure into a credible way of implementing iteration through single
Coroutines
Continuations
A
In Scheme, continuations can even move control from an outer context to an inner one if desired. This almost limitless control over what code is executed next makes complex control structures such as coroutines and cooperative multitasking relatively easy to write.[43]
Message passing
In non-procedural paradigms, goto is less relevant or completely absent. One of the main alternatives is
Variations
There are a number of different language constructs under the class of goto statements.
Computed GOTO and Assigned GOTO
In Fortran, a computed GOTO
jumps to one of several labels in a list, based on the value of an expression. An example is goto (20,30,40) i
.[44] The equivalent construct in C is the switch statement, and in newer Fortran a SELECT CASE
construct is the recommended syntactical alternative.[45] BASIC had a 'On GoTo'
statement that achieved the same goal, but in Visual Basic this construct is no longer supported.[46]
In versions prior to Fortran 95, Fortran also had an assigned goto variant that transfers control to a statement label (line number) which is stored in (assigned to) an integer variable. Jumping to an integer variable that had not been ASSIGNed to was unfortunately possible, and was a major source of bugs involving assigned gotos.[47] The Fortran assign
statement only allows a constant (existing) line number to be assigned to the integer variable. However, some compilers allowed accidentally treating this variable as an integer thereafter, for example increment it, resulting in unspecified behavior at goto
time. The following code demonstrates the behavior of the goto i
when line i is unspecified:
assign 200 to i
i = i+1
goto i ! unspecified behavior
200 write(*,*) "this is valid line number"
Several C compilers implement two non-standard C/C++ extensions relating to gotos originally introduced by gcc.[48] The GNU extension allows the address of a label inside the current function to be obtained as a void*
using the unary, prefix label value operator &&
. The goto instruction is also extended to allow jumping to an arbitrary void*
expression. This C extension is referred to as a computed goto in documentation of the C compilers that support it; its semantics are a superset of Fortran's assigned goto, because it allows arbitrary pointer expressions as the goto target, while Fortran's assigned goto doesn't allow arbitrary expressions as jump target.[49] As with the standard goto in C, the GNU C extension allows the target of the computed goto to reside only in the current function. Attempting to jump outside the current function results in unspecified behavior.[49]
Some variants of BASIC also support a computed GOTO in the sense used in GNU C, i.e. in which the target can be any line number, not just one from a list. For example, in MTS BASIC one could write GOTO i*1000
to jump to the line numbered 1000 times the value of a variable i (which might represent a selected menu option, for example).[50]
PL/I label variables achieve the effect of computed or assigned GOTO
s.
ALTER
Up to the 1985 ANSI COBOL standard had the ALTER statement which could be used to change the destination of an existing GO TO, which had to be in a paragraph by itself.[51] The feature, which allowed polymorphism, was frequently condemned and seldom used.[52]
Perl GOTO
In Perl, there is a variant of the goto
statement that is not a traditional GOTO statement at all. It takes a function name and transfers control by effectively substituting one function call for another (a tail call): the new function will not return to the GOTO, but instead to the place from which the original function was called.[53]
Emulated GOTO
There are several programming languages that do not support GOTO by default. By using GOTO emulation, it is still possible to use GOTO in these programming languages, albeit with some restrictions. One can emulate GOTO in Java,[54] JavaScript,[55] and Python.[56][57]
PL/I label variables
PL/I has the data type LABEL, which can be used to implement both the "assigned goto" and the "computed goto." PL/I allows branches out of the current block. A calling procedure can pass a label as an argument to a called procedure which can then exit with a branch. The value of a label variable includes the address of a stack frame, and a goto out of block pops the stack.
/* This implements the equivalent of */ /* the assigned goto */ declare where label; where = somewhere; goto where; ... somewhere: /* statement */ ; ...
/* This implements the equivalent of */ /* the computed goto */ declare where (5) label; declare inx fixed; where(1) = abc; where(2) = xyz; ... goto where(inx); ... abc: /* statement */ ; ... xyz: /* statement */ ; ...
A simpler way to get an equivalent result is using a label constant array that doesn't even need an explicit declaration of a LABEL type variable:
/* This implements the equivalent of */ /* the computed goto */ declare inx fixed; ... goto where(inx); ... where(1): /* statement */ ; ... where(2): /* statement */ ; ...
MS/DOS GOTO
In a DOS batch file, Goto directs execution to a label that begins with a colon. The target of the Goto can be a variable.
@echo off
SET D8str=%date%
SET D8dow=%D8str:~0,3%
FOR %%D in (Mon Wed Fri) do if "%%D" == "%D8dow%" goto SHOP%%D
echo Today, %D8dow%, is not a shopping day.
goto end
:SHOPMon
echo buy pizza for lunch - Monday is Pizza day.
goto end
:SHOPWed
echo buy Calzone to take home - today is Wednesday.
goto end
:SHOPFri
echo buy Seltzer in case somebody wants a zero calorie drink.
:end
Language support
Many languages support the goto
statement, and many do not. In Java, goto
is a reserved word, but is unusable, although the compiled file.class generates GOTOs and LABELs.[58] Python does not have support for goto, although there are several joke modules that provide it.[56][57] There is no goto statement in Seed7 and hidden gotos like break- and continue-statements are also omitted.[59] In PHP there was no native support for goto
until version 5.3 (libraries were available to emulate its functionality).[60]
C# and Visual Basic .NET both support goto
.[61][62] However, it does not allow jumping to a label outside of the current scope, and respects object disposal and finally constructs, making it significantly less powerful and dangerous than the goto
keyword in other programming languages. It also makes case and default statements labels, whose scope is the enclosing switch statement; goto case or goto default is often used as an explicit replacement for implicit fallthrough, which C# disallows.
The PL/I programing language has a GOTO statement that unwinds the stack for an out of block transfer and does not permit a transfer into a block from outside of it.
Other languages may have their own separate keywords for explicit fallthroughs, which can be considered a version of goto
restricted to this specific purpose. For example, Go uses the fallthrough
keyword and doesn't allow implicit fallthrough at all,[63] while Perl 5 uses next
for explicit fallthrough by default, but also allows setting implicit fallthrough as default behavior for a module.
Most languages that have goto statements call it that, but in the early days of computing, other names were used. For example, in MAD the TRANSFER TO statement was used.[64] APL uses a right pointing arrow, →
for goto.
C has goto, and it is commonly used in various idioms, as discussed above.
Functional programming languages such as Scheme generally do not have goto, instead using continuations.
See also
- COMEFROM
- Control flow
- GOSUB
- Switch statement – a multiway branch (or conditional goto)
- Non-structured programming
Notes
- ^ Watt & Findlay 2004.
- ^ Kernighan & Ritchie 1988, p. 224, A9.6 Jump Statements.
- ^ a b Dijkstra 1968.
- ^ GNU Pascal development team 2005, 5.1 Assorted Pascal Programming Tips.
- ^ Louden & Lambert 2012.
- ^ "The unbridled use of the goto statement has as an immediate consequence that it becomes terribly hard to find a meaningful set of coordinates in which to describe the process progress. ... The 'go to' statement as it stands is just too primitive, it is too much an invitation to make a mess of one's program."
- ^ Rubin 1987.
- ^ Dijkstra, Edsger W. On a Somewhat Disappointing Correspondence (EWD-1009) (PDF). E.W. Dijkstra Archive. Center for American History, University of Texas at Austin. (transcription) (May, 1987)
- ^ Knuth 1974.
- ^ Kernighan & Ritchie 1988, pp. 65–66, 3.8 Goto and Labels.
- ^ a b c Vine 2007, p. 262.
- ^ Geisler 2011.
- ^ Prata 2013.
- ^ a b c d Sahni & Cmelik 1995.
- ^ a b c Andrews 2003.
- ^ McConnell 2004.
- ^ Regehr 2013.
- ^ Roberts 1995.
- ^ Meyer 2009.
- ^ Kozen & Tseng 2008.
- ^ Stack Overflow Questions 2012.
- ^ Pitchford & Tapp 2013.
- ^ Williams 2013.
- ^ ANSI X3.9-1978. American National Standard – Programming Language FORTRAN. American National Standards Institute. Also known as ISO 1539-1980, informally known as FORTRAN 77
- ^ ISO/IEC 1539-1:1997. Information technology – Programming languages – Fortran – Part 1: Base language. Informally known as Fortran 95. There are a further two parts to this standard. Part 1 has been formally adopted by ANSI.
- ^ Barnes 2006.
- ^ Summit 1995.
- ^ a b Torvalds 2016.
- ^ a b Cozens 2004.
- ^ Java Tutorial 2012.
- ^ Gosling & McGilton 1996.
- ^ Brender 2002, pp. 960–965.
- ^ a b Spinellis 2003.
- ^ a b Allain 2019.
- ^ Stroustrup 2012.
- ^ Hoad, Nathan (28 July 2022). "nathanhoad/godot_dialogue_manager". GitHub. Retrieved 3 February 2023.
- ^ Chisnall 2012.
- ^ Contieri 2021.
- ^ Wilkes, Wheeler & Gill 1951.
- ^ Ramshaw 1988.
- ^ Siedersleben 2006.
- ^ a b Steele 1977.
- ^ a b Kelsey, Clinger & Rees 1998.
- ^ , which means that the program jumps to label 20, 30 or 40, in case that i is either less than, equal to or greater than zero.
- ^ Lahey Computer Systems, Inc 2004.
- ^ Microsoft 2021.
- ^ Wehr 1997.
- ^ z/OS 2.5.0 in IBM Documentation 2021.
- ^ a b GCC, the GNU Compiler Collection 2021.
- ^ Fronczak & Lubbers 1974, p. 226.
- ^ The ALTER statement was deemed obsolete in the COBOL 1985 standard and deleted in 2002; see COBOL > Self-modifying code
- ^ Van Tassel 2004.
- ^ Perl syntax manual 2021.
- ^ GOTO for Java 2009.
- ^ Sexton 2012.
- ^ a b Hindle 2004.
- ^ a b Noack et al. 2015.
- ^ Gosling et al. (2005) Unlike C and C++, the Java programming language has no goto statement; identifier statement labels are used with break (§14.15) or continue (§14.16) statements appearing anywhere within the labeled statement. The keywords const and goto are reserved, even though they are not currently used. This may allow a Java compiler to produce better error messages if these C++ keywords incorrectly appear in programs.
- ^ Manual for the Seed7 programming language 2021.
- ^ PHP Manual 2021.
- ^ Wagner 2021.
- ^ "GoTo Statement - Visual Basic | Microsoft Learn". Microsoft Learn. 15 September 2021. Retrieved 25 September 2023.
- ^ The Go Programming Language Specification 2021.
- ^ Galler 1962, pp. 26–28, 197, 211.
References
- Allain, Alex (2019). "When To Use Goto in C". Retrieved 2021-11-14.
- Andrews, Jeremy (13 January 2003). "Linux: Using goto In Kernel Code". Archived from the original on 28 November 2005. Retrieved 2021-11-14.
- ISBN 978-0-321-34078-8.
- Brender, Ronald F. (2002). "The BLISS programming language: a history" (PDF). Software: Practice and Experience. 32 (10): 955–981. S2CID 45466625.
- Chisnall, David (2012). Objective-C Phrasebook. Addison-Wesley Professional. p. 249. ISBN 978-0-321-81375-6.
- Contieri, Maxi (2021-11-02). "Code Smell 100 - GoTo". Maximiliano Contieri - Software Design. Retrieved 2021-11-14.
- Cozens, Simon (2004-04-16). "Good uses of goto". Archived from the original on 2011-03-19.
- S2CID 17469809.
- Dijkstra, Edsger W. On a Somewhat Disappointing Correspondence (EWD-1009) (PDF). E.W. Dijkstra Archive. Center for American History, University of Texas at Austin. (transcription)
- Fronczak, Edward J.; Lubbers, Clark E. (September 1974). MTS, Michigan Terminal System. University of Michigan Computing Center. UOM:39015034770076.
- Galler, Bernard A. (January 1, 1962). The Language of Computers (PDF). McGraw-Hill.
- GCC, the GNU Compiler Collection (2021). "Labels as Values - Using the GNU Compiler Collection (GCC)". Gcc.gnu.org. Retrieved 2021-11-13.
- Geisler, Sandra (2011). C All-in-One Desk Reference For Dummies. John Wiley & Sons. pp. 217–220. ISBN 978-1-118-05424-6.
- GNU Pascal development team (2005). "GNU Pascal Coding Standards". www.gnu-pascal.de. Free Software Foundation. Retrieved 2021-11-10.
- Gosling, James; McGilton, Henry (May 1996). "The Java Language Environment". Oracle.com. Retrieved 2014-07-22.
- Gosling, James; ISBN 0-321-24678-0. Archivedfrom the original on February 14, 2012. Retrieved February 8, 2019.
- GOTO for Java (July 6, 2009). "GOTO for Java". steik. Archived from the original on June 15, 2012. Retrieved April 28, 2012.
- Hindle, Richie (April 1, 2004). "goto for Python". Entrian Solutions. Hertford, UK: Entrian Solutions Ltd. Retrieved 2021-11-10.
- Java Tutorial (2012-02-28). "Branching Statements (The Java Tutorials > Learning the Java Language > Language Basics)". Docs.oracle.com. Retrieved 2021-11-10.
- Kelsey, R.; Clinger, W.; Rees, J.; et al. (August 1998). "Revised5 Report on the Algorithmic Language Scheme". Higher-Order and Symbolic Computation. 11 (1): 7–105. S2CID 14069423.
- ISBN 978-0-13-308621-8.
- S2CID 207630080. Archived from the original(PDF) on 2017-07-17. Retrieved 2017-01-26.
- ISBN 978-3-540-70593-2.
- Lahey Computer Systems, Inc (2004). "Computed GOTO Statement (obsolescent)". Lahey Computer Systems, Inc. Archived from the original on 2016-05-26. Retrieved 2021-11-10.
- Louden, Kenneth C.; Lambert, Kenneth A. (2012). Programming Languages: Principles and Practices. Cengage Learning. p. 422. ISBN 978-1-111-52941-3.
- Manual for the Seed7 programming language (2021). "Features of Seed7". Retrieved 2021-11-10.
{{cite web}}
: CS1 maint: numeric names: authors list (link)
- McConnell, Steve (December 2004). Code Complete: A Practical Handbook of Software Construction, Second Edition (2nd ed.). Microsoft Press. ISBN 978-0735619678.
- Meyer, Bertrand (2009). Touch of Class: Learning to Program Well with Objects and Contracts. Springer Science & Business Media. p. 189. ISBN 978-3-540-92144-8.
- Microsoft (2021). "'On GoTo' and 'On GoSub' statements are no longer supported". Microsoft. Retrieved 2021-11-10.
- Noack, Sebastian; Blank, Douglas; Grainger, Thomas; spacewander (September 19, 2015). "snoack/python-goto: A function decorator, that rewrites the bytecode, to enable goto in Python". GitHub. Retrieved 2021-11-10.
- Perl syntax manual (2021). Goto (Report). Retrieved 2021-11-14.
- PHP Manual (2021). "goto". PHP. Retrieved 2021-11-13.
- Pitchford, Mark; Tapp, Chris (2013-02-25). "MISRA C:2012: Plenty Of Good Reasons To Change". Electronic Design. Retrieved 2014-07-22.
- Prata, Stephen (2013). C Primer Plus. Addison-Wesley. pp. 287–289. ISBN 978-0-13-343238-1.
- Ramshaw, L. (1988). "Eliminating go to's while preserving program structure". Journal of the ACM. 35 (4): 893–920. S2CID 31001665.
- Regehr, John (February 4, 2013). "Use of Goto in Systems Code – Embedded in Academia". blog.regehr.org.
- Roberts, Eric S. (March 1995). "Loop exits and structured programming: reopening the debate". ACM SIGCSE Bulletin. 27 (1): 268–272. .
- Rubin, Frank (March 1987). ""GOTO Considered Harmful" Considered Harmful" (PDF). Communications of the ACM. 30 (3): 195–196. S2CID 6853038. Archived from the original(PDF) on 2009-03-20.
- Sahni, Sartaj; Cmelik, Bob (1995). Software Development in C. Silicon Press. p. 135. ISBN 978-0-929306-16-2.
- Sexton, Alex (2012). "The Summer of Goto | Official Home of Goto.js". Archived from the original on October 25, 2015.
{{cite web}}
: CS1 maint: unfit URL (link)
- Siedersleben, Johannes (2006). "Errors and Exceptions - Rights and Obligations". In Christophe Dony (ed.). Advanced Topics in Exception Handling Techniques. Springer Science & Business Media. p. 277. ISBN 978-3-540-37443-5.
- Spinellis, Diomidis (27 May 2003). Code Reading: The Open Source Perspective. Addison-Wesley Professional. pp. 43–44. ISBN 978-0-672-33370-5.
- Stack Overflow Questions (2012-06-11). "Why "continue" is considered as a C violation in MISRA C:2004?". Stack Overflow. Retrieved 2021-11-10.
- S2CID 9807843.
- Stroustrup, Bjarne (2012-01-09). "Day 1 Keynote - Bjarne Stroustrup: C++11 Style | GoingNative 2012 | Channel 9". Channel9.msdn.com. Retrieved 2021-11-10.
- Summit, Steve (1995). "comp.lang.c FAQ list · Question 17.10". C-faq.com. Retrieved 2021-11-10.
- The Go Programming Language Specification (26 July 2021). "The Go Programming Language Specification - the Go Programming Language".
- Torvalds, Linus (2016). "Linux Kernel Coding Style". The Linux Kernel’s documentation. Retrieved 2021-11-10.
- Van Tassel, Dennie (July 8, 2004). "History of Labels in Programming Languages". Retrieved 4 January 2011.
- Vine, Michael A. (2007). C Programming for the Absolute Beginner. Cengage Learning. ISBN 978-1-59863-634-5.
- Wagner, Bill (2021). "goto statement - C# Reference". docs.microsoft.com. Retrieved 2021-11-09.
- Watt, David Anthony; Findlay, William (2004). Programming language design concepts. John Wiley & Sons. p. 228. ISBN 978-0-470-85320-7.
- Wehr, Jason (1997). "Go to ( assigned )". www.personal.psu.edu/jhm/f90/201.html. Retrieved 2021-11-13.
- Wilkes, Maurice V.; Wheeler, David J.; Gill, Stanley (1951). The Preparation of Programs for an Electronic Digital Computer. Addison-Wesley.
(sometimes called WWG, after its authors' initials) was the first book on computer programming
- Williams, Tom (March 2013). "Checking Rules for C: Assuring Reliability and Safety". RTC Magazine. 22 (3): 12–15. Retrieved 2021-11-10.
- z/OS 2.5.0 in IBM Documentation (2021). "Computed goto statement (IBM extension)". IBM. Retrieved 2021-11-13.
This document describes the syntax, semantics, and IBM z/OS XL C/C++ implementation of the C and C++ programming languages. For a general-purpose C or C++ standard reference, see cppreference.com.
{{cite web}}
: CS1 maint: numeric names: authors list (link)