If your data are recorded with a comma or one or more blanks between data fields, you can use list input to read your data. If you have missing values—that is, unknown values—they must be represented by a period (.) rather than a blank field.

When IML looks for a value, it skips past blanks and tab characters. Then it scans for a delimiter to the value. The delimiter is a blank, a comma, or the end of the record. When the ampersand (&) format modifier is used, IML looks for two blanks, a comma, or the end of the record.

The general form of the INPUT statement for list input is as follows:

where

With list input, IML scans the input lines for values. Consider using list input in the following cases:

List input is the default in several situations. Descriptions of these situations and the behavior of IML follow:

If the end of a record is encountered before IML finds a value, then the behavior is as described by the record overflow options in the INFILE statement discussed in the section Using the INFILE Statement.

When you read with list input, the order of the variables listed in the INPUT statement must agree with the order of the values in the data file. For example, consider the following data:

   Alice    f    10   61   97
   Beth     f    11   64   105
   Bill     m    12   63   110

You can use list input to read these data by specifying the following INPUT statement:

   input name $ sex $ age height weight;

Note: This statement implies that the variables are stored in the order given. That is, each line of data contains a student’s name, sex, age, height, and weight in that order and separated by at least one blank or by a comma.

The alternative to list input is formatted input. An INPUT statement reading formatted input must have a SAS informat after each variable. An informat gives the data type and field width of an input value. Formatted input can be used with pointer controls and format modifiers. Note, however, that neither pointer controls nor format modifiers are necessary for formatted input.

   infile inclass;
   input @1 name $char8. @10 sex $char1. @15 age 2.0
         @20 height 4.1 @25 weight 5.1;

   input @1 name $char8. +1 sex $char1. +4 age 2. +3 height 4.1
         +1 weight 5.1;

You can have the input mechanism search for patterns of text by using the at sign (@) with a character operand. IML starts searching at the current position, advances until it finds the pattern, and leaves the pointer at the position immediately after the found pattern in the input record. For example, the following statement searches for the pattern NAME= and then uses list input to read the value after the found pattern:

   input @ 'NAME=' name $;

If the pattern is not found, then the pointer is left past the end of the record, and the rest of the INPUT statement follows the conventions based on the options MISSOVER, STOPOVER, and FLOWOVER described in the section Using the INFILE Statement. If you use pattern searching, you usually specify the MISSOVER option so that you can control for the occurrences of the pattern not being found.

Notice that the MISSOVER feature enables you to search for a variety of items in the same record, even if some of them are not found. For example, the following statements are able to read in the ADDR variable even if NAME= is not found (in which case, NAME is unvalued):

   infile in1 missover;
   input @1 @ "NAME=" name $
         @1 @ "ADDR=" addr &
         @1 @ "PHONE=" phone $;

The pattern operand can use any characters except for the following:

%

$

[ ]

{ }

<

>

?

*

#

@

^

(backquote)

Each INPUT statement goes to a new record except in the following special cases:

As discussed in the syntax of the INPUT statement, the line pointer operator (/) instructs the input mechanism to go immediately to the next record. For binary (RECFM=N) files, the > directive is used instead of the /.

For character values, the informat determines the way blanks are interpreted. For example, the $CHAR. format reads blanks as part of the whole value, while the BZ. format turns blanks into zeros. See SAS Language Reference: Dictionary for more information about informats.

Missing values in formatted input are represented by blanks or a single period for a numeric value and by blanks for a character value.

Data values are either character or numeric. Input variables always result in scalar (one row by one column) values with type (character or numeric) and length determined by the input format.

End of file is the condition of trying to read a record when there are no more records to read from the file. The consequences of an end-of-file condition are described as follows.

For text files, end of file is encountered first as the end of the last record. The next time input is attempted, the end-of-file condition is raised.

For binary files, end of file can result in the input mechanism returning a record that is shorter than the requested length. In this case IML still attempts to process the record, using the rules described in the section Using the INFILE Statement.

The DO DATA mechanism provides a convenient mechanism for handling end of file.

For example, to read the class data from the external file USER.TEXT.CLASS into a SAS data set, you need to perform the following steps:

Your statements should look as follows:

   filename inclass 'user.text.class';
   infile inclass missover;
   name="12345678";
   sex="1";
   create class  var{name sex age height weight};
   do data;
      input name $ sex $ age height weight;
      append;
   end;
   close class;
   closefile inclass;

Note that the APPEND statement is not executed if the INPUT statement reads past the end of file since IML escapes the loop immediately when the condition is encountered.

If you are familiar with the SAS DATA step, you will notice that the following features are supported differently or are not supported in IML: