The binary option does not work against IO servers on remote nodes running an older version of Erlang/OTP than R9C.
This module provides an interface to standard Erlang IO servers. The output functions all return ok if they are successful, or exit if they are not.
In the following description, all functions have an optional parameter IoDevice. If included, it must be the pid of a process which handles the IO protocols. Normally, it is the IoDevice returned by file:open/2.
For a description of the IO protocols refer to Armstrong, Virding and Williams, 'Concurrent Programming in Erlang', Chapter 13, unfortunately now very outdated, but the general principles still apply.
io_device() as returned by file:open/2, a process handling IO protocols
colums([IoDevice]) -> {ok,int()} | {error, enotsup}
Types:
IoDevice = io_device()
Retrieves the number of columns of the IoDevice (i.e. the width of a terminal). The function only succeeds for terminal devices, for all other devices the function returns {error, enotsup}
put_chars([IoDevice,] IoData) -> ok
Types:
IoDevice = io_device()
IoData = iodata() -- see erlang(3)
Writes the characters of IoData to the standard output (IoDevice).
Types:
IoDevice = io_device()
Writes new line to the standard output (IoDevice).
get_chars([IoDevice,] Prompt, Count) -> string() | eof
Types:
IoDevice = io_device()
Prompt = atom() | string()
Count = int()
Reads Count characters from standard input (IoDevice), prompting it with Prompt. It returns:
get_line([IoDevice,] Prompt) -> string() | eof
Types:
IoDevice = io_device()
Prompt = atom() | string()
Reads a line from the standard input (IoDevice), prompting it with Prompt. It returns:
setopts([IoDevice,] Opts) -> ok | {error, Reason}
Types:
IoDevice = io_device()
Opts = [Opt]
Opt = binary | list
Reason = term()
Set options for standard input/output (IoDevice). Possible options are:
fun("") -> {yes, "quit", []}; (_) -> {no, "", ["quit"]} end
The binary option does not work against IO servers on remote nodes running an older version of Erlang/OTP than R9C.
Types:
IoDevice = io_device()
Term = term()
Writes the term Term to the standard output (IoDevice).
read([IoDevice,] Prompt) -> Result
Types:
IoDevice = io_device()
Prompt = atom() | string()
Result = {ok, Term} | eof | {error, ErrorInfo}
Term = term()
ErrorInfo -- see section Error Information below
Reads a term Term from the standard input (IoDevice), prompting it with Prompt. It returns:
read(IoDevice, Prompt, StartLine) -> Result
Types:
IoDevice = io_device()
Prompt = atom() | string()
StartLine = int()
Result = {ok, Term, EndLine} | {eof, EndLine} | {error, ErrorInfo, EndLine}
Term = term()
EndLine = int()
ErrorInfo -- see section Error Information below
Reads a term Term from IoDevice, prompting it with Prompt. Reading starts at line number StartLine. It returns:
fwrite(Format) ->
fwrite([IoDevice,] Format, Data) -> ok
format(Format) ->
format([IoDevice,] Format, Data) -> ok
Types:
IoDevice = io_device()
Format = atom() | string() | binary()
Data = [term()]
Writes the items in Data ([]) on the standard output (IoDevice) in accordance with Format. Format contains plain characters which are copied to the output device, and control sequences for formatting, see below. If Format is an atom or a binary, it is first converted to a list with the aid of atom_to_list/1 or binary_to_list/1.
1> io:fwrite("Hello world!~n", []). Hello world! ok
The general format of a control sequence is ~F.P.PadC. The character C determines the type of control sequence to be used, F and P are optional numeric arguments. If F, P, or Pad is *, the next argument in Data is used as the numeric value of F or P.
F is the field width of the printed argument. A negative value means that the argument will be left justified within the field, otherwise it will be right justified. If no field width is specified, the required print width will be used. If the field width specified is too small, then the whole field will be filled with * characters.
P is the precision of the printed argument. A default value is used if no precision is specified. The interpretation of precision depends on the control sequences. Unless otherwise specified, the argument within is used to determine print width.
Pad is the padding character. This is the character used to pad the printed representation of the argument so that it conforms to the specified field width and precision. Only one padding character can be specified and, whenever applicable, it is used for both the field width and precision. The default padding character is ' ' (space).
The following control sequences are available:
2> io:fwrite("|~10.5c|~-10.5c|~5c|~n", [$a, $b, $c]). | aaaaa|bbbbb |ccccc| ok
3> io:fwrite("|~10w|~n", [{hey, hey, hey}]). |**********| ok 4> io:fwrite("|~10s|~n", [io_lib:write({hey, hey, hey})]). |{hey,hey,h| ok
5> T = [{attributes,[[{id,age,1.50000},{mode,explicit}, {typename,"INTEGER"}], [{id,cho},{mode,explicit},{typename,'Cho'}]]}, {typename,'Person'},{tag,{'PRIVATE',3}},{mode,implicit}]. ... 6> io:fwrite("~w~n", [T]). [{attributes,[[{id,age,1.50000},{mode,explicit},{typename, [73,78,84,69,71,69,82]}],[{id,cho},{mode,explicit},{typena me,'Cho'}]]},{typename,'Person'},{tag,{'PRIVATE',3}},{mode ,implicit}] ok 7> io:fwrite("~62p~n", [T]). [{attributes,[[{id,age,1.50000}, {mode,explicit}, {typename,"INTEGER"}], [{id,cho},{mode,explicit},{typename,'Cho'}]]}, {typename,'Person'}, {tag,{'PRIVATE',3}}, {mode,implicit}] ok
8> io:fwrite("Here T = ~62p~n", [T]). Here T = [{attributes,[[{id,age,1.50000}, {mode,explicit}, {typename,"INTEGER"}], [{id,cho}, {mode,explicit}, {typename,'Cho'}]]}, {typename,'Person'}, {tag,{'PRIVATE',3}}, {mode,implicit}] ok
9> io:fwrite("~W~n", [T,9]). [{attributes,[[{id,age,1.50000},{mode,explicit},{typename, ...}],[{id,cho},{mode,...},{...}]]},{typename,'Person'},{t ag,{'PRIVATE',3}},{mode,implicit}] ok
10> io:fwrite("~62P~n", [T,9]). [{attributes,[[{id,age,1.50000}, {mode,explicit}, {typename,...}], [{id,cho},{mode,...},{...}]]}, {typename,'Person'}, {tag,{'PRIVATE',3}}, {mode,implicit}] ok
11> io:fwrite("~.16B~n", [31]). 1F ok 12> io:fwrite("~.2B~n", [-19]). -10011 ok 13> io:fwrite("~.36B~n", [5*36+35]). 5Z ok
14> io:fwrite("~X~n", [31,"10#"]). 10#31 ok 15> io:fwrite("~.16X~n", [-31,"0x"]). -0x1F ok
16> io:fwrite("~.10#~n", [31]). 10#31 ok 17> io:fwrite("~.16#~n", [-31]). -16#1F ok
Returns:
If an error occurs, there is no output. For example:
18> io:fwrite("~s ~w ~i ~w ~c ~n",['abc def', 'abc def', {foo, 1},{foo, 1}, 65]). abc def 'abc def' {foo,1} A ok 19> io:fwrite("~s", [65]). ** exited: {badarg,[{io,format,[<0.22.0>,"~s","A"]}, {erl_eval,do_apply,5}, {shell,exprs,6}, {shell,eval_loop,3}]} **
In this example, an attempt was made to output the single character '65' with the aid of the string formatting directive "~s".
The two functions fwrite and format are identical. The old name format has been retained for backwards compatibility, while the new name fwrite has been added as a logical complement to fread.
fread([IoDevice,] Prompt, Format) -> Result
Types:
IoDevice = io_device()
Prompt = atom() | string()
Format = string()
Result = {ok, Terms} | eof | {error, What}
Terms = [term()]
What = term()
Reads characters from the standard input (IoDevice), prompting it with Prompt. Interprets the characters in accordance with Format. Format contains control sequences which directs the interpretation of the input.
Format may contain:
Examples:
20> io:fread('enter>', "~f~f~f"). enter>1.9 35.5e3 15.0 {ok,[1.90000,3.55000e+4,15.0000]} 21> io:fread('enter>', "~10f~d"). enter> 5.67899 {ok, [5.67800, 99]} 22> io:fread('enter>', ":~10s:~10c:"). enter>: alan : joe : {ok, ["alan", " joe "]}
rows([IoDevice]) -> {ok,int()} | {error, enotsup}
Types:
IoDevice = io_device()
Retrieves the number of rows of the IoDevice (i.e. the height of a terminal). The function only succeeds for terminal devices, for all other devices the function returns {error, enotsup}
scan_erl_exprs(Prompt) ->
scan_erl_exprs([IoDevice,] Prompt, StartLine) -> Result
Types:
IoDevice = io_device()
Prompt = atom() | string()
StartLine = int()
Result = {ok, Tokens, EndLine} | {eof, EndLine} | {error, ErrorInfo, EndLine}
Tokens -- see erl_scan(3)
EndLine = int()
ErrorInfo -- see section Error Information below
Reads data from the standard input (IoDevice), prompting it with Prompt. Reading starts at line number StartLine (1). The data is tokenized as if it were a sequence of Erlang expressions until a final '.' is reached. This token is also returned. It returns:
Example:
23> io:scan_erl_exprs('enter>'). enter>abc(), "hey". {ok,[{atom,1,abc},{'(',1},{')',1},{',',1},{string,1,"hey"},{dot,1}],2} 24> io:scan_erl_exprs('enter>'). enter>1.0er. {error,{1,erl_scan,{illegal,float}},2}
scan_erl_form(Prompt) ->
scan_erl_form([IoDevice,] Prompt, StartLine) -> Result
Types:
IoDevice = io_device()
Prompt = atom() | string()
StartLine = int()
Result = {ok, Tokens, EndLine} | {eof, EndLine} | {error, ErrorInfo, EndLine}
Tokens -- see erl_scan(3)
EndLine = int()
ErrorInfo -- see section Error Information below
Reads data from the standard input (IoDevice), prompting it with Prompt. Starts reading at line number StartLine (1). The data is tokenized as if it were an Erlang form - one of the valid Erlang expressions in an Erlang source file - until a final '.' is reached. This last token is also returned. The return values are the same as for scan_erl_exprs/1,2,3 above.
parse_erl_exprs(Prompt) ->
parse_erl_exprs([IoDevice,] Prompt, StartLine) -> Result
Types:
IoDevice = io_device()
Prompt = atom() | string()
StartLine = int()
Result = {ok, Expr_list, EndLine} | {eof, EndLine} | {error, ErrorInfo, EndLine}
Expr_list -- see erl_parse(3)
EndLine = int()
ErrorInfo -- see section Error Information below
Reads data from the standard input (IoDevice), prompting it with Prompt. Starts reading at line number StartLine (1). The data is tokenized and parsed as if it were a sequence of Erlang expressions until a final '.' is reached. It returns:
Example:
25> io:parse_erl_exprs('enter>'). enter>abc(), "hey". {ok, [{call,1,{atom,1,abc},[]},{string,1,"hey"}],2} 26> io:parse_erl_exprs ('enter>'). enter>abc("hey". {error,{1,erl_parse,["syntax error before: ",["'.'"]]},2}
parse_erl_form(Prompt) ->
parse_erl_form([IoDevice,] Prompt, StartLine) -> Result
Types:
IoDevice = io_device()
Prompt = atom() | string()
StartLine = int()
Result = {ok, AbsForm, EndLine} | {eof, EndLine} | {error, ErrorInfo, EndLine}
AbsForm -- see erl_parse(3)
EndLine = int()
ErrorInfo -- see section Error Information below
Reads data from the standard input (IoDevice), prompting it with Prompt. Starts reading at line number StartLine (1). The data is tokenized and parsed as if it were an Erlang form - one of the valid Erlang expressions in an Erlang source file - until a final '.' is reached. It returns:
All Erlang processes have a default standard IO device. This device is used when no IoDevice argument is specified in the above function calls. However, it is sometimes desirable to use an explicit IoDevice argument which refers to the default IO device. This is the case with functions that can access either a file or the default IO device. The atom standard_io has this special meaning. The following example illustrates this:
27> io:read('enter>'). enter>foo. {ok,foo} 28> io:read(standard_io, 'enter>'). enter>bar. {ok,bar}
There is always a process registered under the name of user. This can be used for sending output to the user.
The ErrorInfo mentioned above is the standard ErrorInfo structure which is returned from all IO modules. It has the format:
{ErrorLine, Module, ErrorDescriptor}
A string which describes the error is obtained with the following call:
apply(Module, format_error, ErrorDescriptor)