How to Have a Program Read Stdin

This commodity is nearly standard I/O file descriptors. For System V streams, run across STREAMS.

In computer programming, standard streams are interconnected input and output communication channels^[1] betwixt a figurer program and its environment when it begins execution. The three input/output (I/O) connections are called standard input (stdin), standard output (stdout) and standard error (stderr). Originally I/O happened via a physically connected organisation console (input via keyboard, output via monitor), simply standard streams abstract this. When a command is executed via an interactive shell, the streams are typically connected to the text terminal on which the crush is running, simply tin can exist changed with redirection or a pipeline. More generally, a child procedure inherits the standard streams of its parent procedure.

Application [edit]

The standard streams for input, output, and error

Users generally know standard streams as input and output channels that handle information coming from an input device, or that write data from the application. The data may exist text with any encoding, or binary data. In many modern systems, the standard error stream of a program is redirected into a log file, typically for error analysis purposes.

Streams may be used to concatenation applications, significant that the output stream of one program can be redirected to exist the input stream to another application. In many operating systems this is expressed past list the application names, separated by the vertical bar grapheme, for this reason ofttimes called the pipeline character. A well-known case is the use of a pagination application, such every bit more than, providing the user control over the display of the output stream on the display.

Groundwork [edit]

In near operating systems predating Unix, programs had to explicitly connect to the appropriate input and output devices. OS-specific intricacies caused this to be a tedious programming chore. On many systems information technology was necessary to obtain control of environment settings, access a local file table, determine the intended data fix, and handle hardware correctly in the case of a punch card reader, magnetic record bulldoze, disk bulldoze, line printer, card punch, or interactive concluding.

One of Unix's several groundbreaking advances was abstract devices, which removed the need for a program to know or care what kind of devices it was communicating with^{[ citation needed ]}. Older operating systems forced upon the programmer a record structure and often non-orthogonal data semantics and device control. Unix eliminated this complexity with the concept of a data stream: an ordered sequence of information bytes which tin be read until the stop of file. A program may besides write bytes equally desired and demand not, and cannot hands declare their count or group.

Another Unix breakthrough was to automatically associate input and output to terminal keyboard and concluding display, respectively, by default^{[ citation needed ]} — the program (and programmer) did admittedly nada to establish input and output for a typical input-process-output program (unless it chose a different paradigm). In contrast, previous operating systems commonly required some—frequently circuitous—job command language to establish connections, or the equivalent burden had to be orchestrated past the plan.^{[ citation needed ]}

Since Unix provided standard streams, the Unix C runtime surround was obliged to support it besides. As a result, most C runtime environments (and C's descendants), regardless of the operating organization, provide equivalent functionality.

Standard input (stdin) [edit]

Standard input is a stream from which a program reads its input data. The program requests data transfers by use of the read operation. Not all programs require stream input. For instance, the dir and ls programs (which display file names contained in a directory) may take control-line arguments, just perform their operations without any stream data input.

Unless redirected, standard input is inherited from the parent process. In the case of an interactive shell, that is usually associated with the keyboard.

The file descriptor for standard input is 0 (nix); the POSIX <unistd.h> definition is STDIN_FILENO; the respective C <stdio.h> variable is FILE* stdin; similarly, the C++ <iostream> variable is std::cin.

Standard output (stdout) [edit]

Standard output is a stream to which a program writes its output data. The programme requests data transfer with the write performance. Not all programs generate output. For case, the file rename command (variously called mv, move, or ren) is silent on success.

Unless redirected, standard output is inherited from the parent process. In the instance of an interactive trounce, that is usually the text terminal which initiated the program.

The file descriptor for standard output is i (one); the POSIX <unistd.h> definition is STDOUT_FILENO; the corresponding C <stdio.h> variable is FILE* stdout; similarly, the C++ <iostream> variable is std::cout.

Standard error (stderr) [edit]

Standard fault is another output stream typically used by programs to output error messages or diagnostics. It is a stream independent of standard output and can be redirected separately. This solves the semi-predicate problem, assuasive output and errors to be distinguished, and is analogous to a function returning a pair of values – meet Semi-predicate problem: Multi valued return. The usual destination is the text last which started the program to provide the best chance of being seen fifty-fifty if standard output is redirected (so not readily observed). For instance, output of a program in a pipeline is redirected to input of the side by side program, but errors from each program still get straight to the text concluding.

It is acceptable and normal to directly standard output and standard error to the same destination, such as the text terminal. Letters announced in the same social club every bit the program writes them, unless buffering is involved. For instance, in common situations the standard error stream is unbuffered merely the standard output stream is line-buffered; in this instance, text written to standard error later may appear on the terminal earlier, if the standard output stream buffer is not still full.

The file descriptor for standard error is defined past POSIX as 2 (two); the <unistd.h> header file provides the symbol STDERR_FILENO;^[2] the respective C <stdio.h> variable is FILE* stderr. The C++ <iostream> standard header provides two variables associated with this stream: std::cerr and std::clog, the former being unbuffered and the latter using the same buffering machinery as all other C++ streams.

Bourne-style shells allow standard error to be redirected to the aforementioned destination that standard output is directed to using

          2>&1        

csh-way shells allow standard mistake to be redirected to the aforementioned destination that standard output is directed to using

          >&        

Standard error was added to Unix in the 1970s after several wasted phototypesetting runs concluded with error messages beingness typeset instead of displayed on the user's final.^[3]

Timeline [edit]

1950s: Fortran [edit]

Fortran has the equivalent of Unix file descriptors: Past convention, many Fortran implementations use unit numbers UNIT=5 for stdin, UNIT=vi for stdout and UNIT=0 for stderr. In Fortran-2003, the intrinsic ISO_FORTRAN_ENV module was standardized to include the named constants INPUT_UNIT, OUTPUT_UNIT, and ERROR_UNIT to portably specify the unit numbers.

                        ! FORTRAN 77 example            PROGRAM                        MAIN            INTEGER                        NUMBER            READ            (            UNIT            =            v            ,            *            )            NUMBER            WRITE            (            Unit of measurement            =            half-dozen            ,            '(A,I3)'            )            ' NUMBER IS: '            ,            NUMBER            Stop          

                        ! Fortran 2003 example            program                        main            utilise                        iso_fortran_env            implicit none                                    integer            ::            number            read            (            unit            =            INPUT_UNIT            ,            *            )            number            write            (            unit            =            OUTPUT_UNIT            ,            '(a,i3)'            )            'Number is: '            ,            number            end program          

1960: ALGOL 60 [edit]

ALGOL threescore was criticized for having no standard file access.^{[ commendation needed ]}

1968: ALGOL 68 [edit]

ALGOL 68's input and output facilities were collectively referred to equally the transput.^[4] Koster coordinated the definition of the transput standard. The model included three standard channels: stand up in, stand out, and stand back.

Example

# ALGOL 68 instance # primary:( Existent number; getf(stand in,($g$,number)); printf(($"Number is: "g(6,4)"OR "$,number)); # OR # putf(stand up out,($" Number is: "g(half dozen,4)"!"$,number)); newline(stand up out) )
Input:	Output:
three.14159	Number is: +iii.142 OR Number is: +3.142!

1970s: C and Unix [edit]

In the C programming language, the standard input, output, and mistake streams are attached to the existing Unix file descriptors 0, ane and 2 respectively.^[v] In a POSIX surround the <unistd.h> definitions STDIN_FILENO, STDOUT_FILENO or STDERR_FILENO should be used instead rather than magic numbers. File pointers stdin, stdout, and stderr are besides provided.

Ken Thompson (designer and implementer of the original Unix operating arrangement) modified sort in Version five Unix to accept "-" as representing standard input, which spread to other utilities and became a part of the operating arrangement as a special file in Version 8. Diagnostics were part of standard output through Version 6, subsequently which Dennis M. Ritchie created the concept of standard error.^[6]

1995: Java [edit]

In Coffee, the standard streams are referred to by System.in (for stdin), Organization.out (for stdout), and System.err (for stderr).^[7]

                        public            static            void            main            (            String            args            []            )            {            effort            {            BufferedReader            br            =            new            BufferedReader            (            new            InputStreamReader            (            Organisation            .            in            ));            String            south            =            br            .            readLine            ();            double            number            =            Double            .            parseDouble            (            s            );            Organization            .            out            .            println            (            "Number is:"            +            number            );            }            catch            (            Exception            eastward            )            {            System            .            err            .            println            (            "Error:"            +            e            .            getMessage            ());            }            }          

2000s: .Internet [edit]

In C# and other .Cyberspace languages, the standard streams are referred to by System.Console.In (for stdin), System.Console.Out (for stdout) and System.Console.Error (for stderr).^[8] Basic read and write capabilities for the stdin and stdout streams are also accessible straight through the class System.Console (e.one thousand. System.Console.WriteLine() tin can be used instead of System.Console.Out.WriteLine()).

System.Panel.In, System.Console.Out and System.Panel.Fault are System.IO.TextReader (stdin) and System.IO.TextWriter (stdout, stderr) objects, which simply permit access to the underlying standard streams on a text basis. Full binary access to the standard streams must be performed through the Organization.IO.Stream objects returned by System.Console.OpenStandardInput(), System.Console.OpenStandardOutput() and System.Panel.OpenStandardError() respectively.

                        // C# example            public            static            int            Principal            (            string            []            args            )            {            try            {            string            southward            =            System            .            Console            .            In            .            ReadLine            ();            double            number            =            double            .            Parse            (            s            );            System            .            Console            .            Out            .            WriteLine            (            "Number is: {0:F3}"            ,            number            );            return            0            ;            // If Parse() threw an exception            }            grab            (            ArgumentNullException            )            {            System            .            Console            .            Fault            .            WriteLine            (            "No number was entered!"            );            }            take hold of            (            FormatException            )            {            Arrangement            .            Console            .            Mistake            .            WriteLine            (            "The specified value is not a valid number!"            );            }            catch            (            OverflowException            )            {            System            .            Panel            .            Error            .            WriteLine            (            "The specified number is too large!"            );            }            return            -            1            ;            }          

                        ' Visual Basic .NET instance            Public            Function            Main            ()            Equally            Integer            Try            Dim            s            Every bit            Cord            =            System            .            Console            .            [            In            ]            .            ReadLine            ()            Dim            number            As            Double            =            Double            .            Parse            (            due south            )            System            .            Console            .            Out            .            WriteLine            (            "Number is: {0:F3}"            ,            number            )            Return            0            ' If Parse() threw an exception            Take hold of            ex            As            System            .            ArgumentNullException            Arrangement            .            Console            .            [            Error            ]            .            WriteLine            (            "No number was entered!"            )            Catch            ex2            As            System            .            FormatException            Organisation            .            Console            .            [            Fault            ]            .            WriteLine            (            "The specified value is not a valid number!"            )            Catch            ex3            As            Organization            .            OverflowException            System            .            Panel            .            [            Fault            ]            .            WriteLine            (            "The specified number is likewise big!"            )            End            Try            Render            -            1            Stop            Function          

When applying the System.Diagnostics.Process class one can use the instance properties StandardInput, StandardOutput, and StandardError of that course to access the standard streams of the procedure.

2000 - : Python (two or 3) [edit]

The post-obit example shows how to redirect the standard input both to the standard output and to a text file.

                                    #!/usr/bin/env python                        import            sys                        # Save the current stdout so that we tin revert sys.stdout                        # subsequently nosotros complete our redirection                        stdin_fileno            =            sys            .            stdin                        stdout_fileno            =            sys            .            stdout                        # Redirect sys.stdout to the file                        sys            .            stdout            =            open up            (            'myfile.txt'            ,            'w'            )                        ctr            =            0                        for            inps            in            stdin_fileno            :                        ctrs            =            str            (            ctr            )                        # Prints to the redirected stdout ()                        sys            .            stdout            .            write            (            ctrs            +            ") this is to the redirected --->"            +            inps            +            '            \n            '            )                        # Prints to the actual saved stdout handler                        stdout_fileno            .            write            (            ctrs            +            ") this is to the actual  --->"            +            inps            +            '            \n            '            )                        ctr            =            ctr            +            1                        # Shut the file                        sys            .            stdout            .            close            ()                        # Restore sys.stdout to our onetime saved file handler                        sys            .            stdout            =            stdout_fileno          

GUIs [edit]

Graphical user interfaces (GUIs) don't e'er make employ of the standard streams; they do when GUIs are wrappers of underlying scripts and/or console programs, for instance the Synaptic package managing director GUI, which wraps apt commands in Debian and/or Ubuntu. GUIs created with scripting tools like Zenity and KDialog past KDE project^[9] make apply of stdin, stdout, and stderr, and are based on unproblematic scripts rather than a complete GUI programmed and compiled in C/C++ using Qt, GTK, or other equivalent proprietary widget framework.

The Services menu, as implemented on NeXTSTEP and Mac OS X, is as well analogous to standard streams. On these operating systems, graphical applications can provide functionality through a organization-broad menu that operates on the current option in the GUI, no matter in what application.

Some GUI programs, primarily on Unix, still write debug data to standard error. Others (such as many Unix media players) may read files from standard input. Popular Windows programs that open up a separate console window in addition to their GUI windows are the emulators pSX and DOSBox.

GTK-server can use stdin as a communication interface with an interpreted programme to realize a GUI.

The Common Lisp Interface Director paradigm "presents" GUI elements sent to an extended output stream.

Run into also [edit]

• Redirection (computing)
• Stream (computing)
• Input/output
• C file input/output
• SYSIN and SYSOUT
• Standard streams in OpenVMS

References [edit]

1. ^ D. M. Ritchie, "A Stream Input-Output System", AT&T Bell Laboratories Technical Journal, 68(8), Oct 1984.
2. ^ "<unistd.h>". The Open Grouping Base of operations Specifications Issue 6—IEEE Std 1003.1, 2004 Edition. The Open Group. 2004.
3. ^ Johnson, Steve (2013-12-eleven). "[TUHS] Graphic Systems C/A/T phototypesetter" (Mailing list). Archived from the original on 2020-09-25. Retrieved 2020-eleven-07 .
4. ^ Revised Report on the Algorithmic Language Algol 68, Edited by A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck, C.H.A. Koster, One thousand. Sintzoff, C.H. Lindsey, L.G.L.T. Meertens and R.G. Fisker, http://www.softwarepreservation.org/projects/ALGOL/study/Algol68_revised_report-AB.pdf, Section ten.iii
5. ^ "Stdin(iii): Standard I/O streams - Linux homo page".
6. ^ McIlroy, M. D. (1987). A Research Unix reader: annotated excerpts from the Developer's Manual, 1971–1986 (PDF) (Technical report). CSTR. Bell Labs. 139.
7. ^ "Organisation (Coffee Platform SE 7)". Retrieved 20 July 2012.
8. ^ "C# Reference Source, .NET Framework 4.vii.ane, mscorlib, Panel course". referencesource.microsoft.com . Retrieved 2017-12-ten .
9. ^ Kißling, Kristian (2009). "Adding graphic elements to your scripts with Zenity and KDialog". Linux Magazine . Retrieved 2021-04-eleven .

Sources [edit]

• "Standard Streams", The GNU C Library
• KRONOS ii.1 Reference Transmission, Control Data Corporation, Part Number 60407000, 1974
• NOS Version 1 Applications Programmer's Instant, Command Data Corporation, Part Number 60436000, 1978
• Level 68 Introduction to Programming on MULTICS, Honeywell Corporation, 1981
• Evolution of the MVS Operating Arrangement, IBM Corporation, 1981
• Lions' Commentary on UNIX Sixth Edition, John Lions, ISBN 1-57398-013-7, 1977
• Panel Grade, .NET Framework Grade Library, Microsoft Corporation, 2008

External links [edit]

• Standard Input Definition - past The Linux Information Project
• Standard Output Definition - by The Linux Data Project
• Standard Error Definition - past The Linux Information Projection

couchjoiny1968.blogspot.com

Source: https://en.wikipedia.org/wiki/Standard_streams

Share this post