Some Common Options
Option Argument Description
Options which are useful when invoking SAS
dms - Use display manager windows
stdio - Obey UNIX standard input and output
config filename Use filename as configuration file
Options which control output appearance
center - Center output on the page
date - Include today’s date on each page
number - Include page numbers on output
linesize number Print in a width of number columns
pagesize number Go to a new page after number lines
ovp - Show emphasis by overprinting
Options which control data set processing
obs number Process a maximum of number obs.
firstobs number Skip first number observations
replace - Replace permanent data sets?
Application: Rescanning Input
Suppose we have an input file which has a county name on one line
followed by one or more lines containing x and y coordinates of the
boundaries of the county. We wish to create a separate observation,
including the county name, for each set of coordinates.
A segment of the file might look like this:
alameda
-121.55 37.82 -121.55 37.78 -121.55 37.54 -121.50 37.53
-121.49 37.51 -121.48 37.48
amador
-121.55 37.82 -121.59 37.81 -121.98 37.71 -121.99 37.76
-122.05 37.79 -122.12 37.79 -122.13 37.82 -122.18 37.82
-122.20 37.87 -122.25 37.89 -122.27 37.90
calaveras
-121.95 37.48 -121.95 37.48 -121.95 37.49 -122.00 37.51
-122.05 37.53 -122.07 37.55 -122.09 37.59 -122.11 37.65
-122.14 37.70 -122.19 37.74 -122.24 37.76 -122.27 37.79
-122.27 37.83 -122.27 37.85 -122.27 37.87 -122.27 37.90
. . .
Application: Rescanning Input (cont’d)
Note that we don’t know how many observations (or data lines)
belong to each county.
data counties;
length county $ 12 name $ 12;
infile "counties.dat";
retain county;
input name $ @; * hold current line for rescanning;
if indexc(name,’0123456789’) = 0 then do;
county = name;
delete; * save county name, but don’t output;
end;
else do;
x = input(name,12.) * do numeric conversion;
input y @@; * hold the line to read more x/y pairs;
end;
drop name;
run;
Application: Reshaping a Data Set I
Since SAS procedures are fairly rigid about the organization of
their input, it is often necessary to use the data step to change the
shape of a data set. For example, repeated measurements on a
single subject may be on several observations, and we may want
them all on the same observation. In essence, we want to perform
the following transformation:
Subj Time X
1 1 10
1 2 12
· · · Subj X1 X2 · · · Xn
1 n 8 =) 1 10 12 · · · 8
2 1 19 2 19 7 · · · 21
2 2 7
· · ·
2 n 21
Application: Reshaping a Data Set I(cont’d)
Since we will be processing multiple input observations to produce
a single output observation, a retain statement must be used to
remember the values from previous inputs. The combination of a
by statement and first. and last. variables allows us to create
the output observations at the appropriate time, even if there are
incomplete records.
data two;
set one;
by subj;
array xx x1-xn;
retain x1-xn;
if first.subj then do i=1 to dim(xx); xx{i} = .;end;
xx{time} = x;
if last.subj then output;
drop time x;
run;
Application: Reshaping a Data Set II
A similar problem to the last is the case where the data for several
observations is contained on a single line, and it is necessary to
convert each of the lines of input into several observations. Suppose
we have test scores for three different tests, for each of several
subjects; we wish to create three separate observations from each of
these sets of test scores:
data scores;
* assume set three contains id, group and score1-score3;
set three;
array sss score1-score3;
do time = 1 to dim(sss);
score = sss{time};
output;
end;
drop score1-score3;
run;
Output Data Sets
Many SAS procedures produce output data sets containing data
summaries (means, summary, univariate), information about
statistical analyses (reg, glm, nlin, tree) or transformed variables
(standard, score, cancorr, rank); some procedures can produce
multiple output data sets. These data sets can be manipulated just
like any other SAS data sets.
Recall that the statistical functions like mean() and std() can
calculate statistical summaries for variables within an observation;
output data sets are used to calculate summaries of variables over
the whole data set.
When you find that you are looping through an entire data set to
calculate a single quantity which you then pass on to another data
step, consider using an output data set instead.
Using ODS to create data sets
Many procedures use the output delivery system to provide
additional control over the output data sets that they produce. To
find out if ODS tables are available for a particular procedure, use
the following statement before the procedure of interest:
ods trace on;
Each table will produce output similar to the following on the log:
Output Added:
-------------
Name: ExtremeObs
Label: Extreme Observations
Template: base.univariate.ExtObs
Path: Univariate.x.ExtremeObs
-------------
Once the path of a table of interest is located, you can produce a
data set with the ods output statement, specifying the path with
an equal sign followed by the output data set name.
ODS Output Data Set: Example
The univariate procedure provides printed information about
extreme observations, but this information is not available through
the out= data set. To put this information in a data set, first find
the appropriate path by using the ods trace statement, and then
use an ODS statement like the following:
ods output Univariate.x.ExtremeObs=extreme;
proc univariate data=mydata;
var x;
run;
ods output close;
The data set extreme will now contain information about the
extreme values.
Output Data Sets: Example I
It is often useful to have summary information about a data set
available when the data set is being processed. Suppose we have a
data set called new, with a variable x, and we wish to calculate a
variable px equal to x divided by the maximum value of x.
proc summary data=new;
var x;
output out=sumnew max=maxx;
run;
data final;
if _n_ = 1 then set sumnew(keep=maxx);
set new;
px = x / maxx;
run;
The automatic variable n will be 1 for the first observation only;
the single observation in sumnew gets read at this time. The set
new; statement then reads in the original data.
Output Data Sets: Example II
Now suppose we have two classification variables called group and
trtmnt, and we wish to use the maximum value for each
group/trtmnt combination in the transformation. If the data set
had already been sorted, the following statements could be used:
proc summary nway data=new;
class group trtmnt;
var x;
output out=sumnew max=maxx;
run;
data final;
merge new sumnew(keep=maxx);
by group trtmnt;
px = x / maxx;
run;
The nway option limits the output data set to contain observations
for each unique combination of the variables given in the class
statement.
Output Data Sets: Example III
Suppose we have a data set called hdata, consisting of three
variables: hospital, time and score, representing the score of
some medical exam taken at three different times at three different
hospitals, and we’d like to produce a plot with three lines: one for
the means of each of the three hospitals over time. The following
statements could be used:
proc means noprint nway data=hdata;
class hospital time;
var score;
output out=hmeans mean=mscore;
run;
The noprint option suppresses the usual printing which is the
default for proc means. You could acheive similar results using a
by statement instead of a class statement, but the data set would
need to be sorted.
Output Data Sets: Example III(cont’d)
The transformation which the previous program produced can be
thought of as the following:
hospital time score
mercy 1 132
mercy 2 125
. . . hospital time _type_ _freq_ mscore
mercy 1 144 city 1 3 2 146.500
mercy 2 224 city 2 3 2 120.000
county 1 119 city 3 3 2 128.000
county 2 125 =) county 1 3 2 125.500
. . . county 2 3 2 127.000
county 2 129 county 3 3 2 117.000
county 3 113 mercy 1 3 3 131.667
city 1 144 mercy 2 3 2 174.500
city 2 121 mercy 3 3 1 121.000
. . .
city 1 149
city 3 122
The type variable indicates the observations are for a unique
combination of levels of two class variables, while the freq
variable is the number of observations which were used for the
computation of that statistic.
Plotting the Means
The following program produces the graph shown on the right:
symbol1 interpol=join
value=plus;
symbol2 interpol=join
value=square;
symbol3 interpol=join
value=star;
title "Means versus Time";
proc gplot data=hmeans;
plot mscore*time=hospital;
run;
Application: Finding Duplicate Observations II
In a previous example, duplicates were found by using by
processing and first. and last. variables. If the data set were
very large, or not already sorted by id, that program would not be
very efficient. In this case, an output data set from proc freq
might be more useful. Once again, assume the identifier variable is
called id. The following statements will produce a data set with
the id values of the duplicate observations.
proc freq data=old noprint;
tables id/ out=counts(rename = (count = n) keep=id count);
run;
data check;
set counts;
if n > 1;
run;
Note that, even though count is renamed to n, the original variable
name (count) is used on the keep statement.
SAS Macro Language: Overview
At it’s simplest level, the SAS Macro language allows you to assign
a string value to a variable and to use the variable anywhere in a
SAS program:
%let header = "Here is my title";
. . .
proc print ;
var x y z;
title &header;
run;
This would produce exactly the same result as if you typed the
string "Here is my title" in place of &header in the program.
Notice that the substitution is very simple - the text of the macro
variable is substituted for the macro symbol in the program.
SAS Macro Language: Overview (cont’d)
The macro facility can be used to replace pieces of actual programs
by creating named macros:
%macro readsome;
data one;
infile "myfile";
input x y z;
if
%mend;
%readsome x > 1; run;
The final statement is equivalent to typing
data one;
infile "myfile";
input x y z;
if x > 1; run;
Once again, all that is performed is simple text replacement.
SAS Macro Language: Overview (cont’d)
A large part of the macro facility’s utility comes from the macro
programming statements which are all preceded by a percent sign
(%). For example, suppose we need to create 5 data sets, named
sales1, sales2, etc., each reading from a corresponding data file
insales1, insales2, etc.
%macro dosales;
%do i=1 %to 5;
data sales&i;
infile "insales&i";
input dept $ sales;
run;
%end;
%mend dosales;
%dosales;
Note that, until the last line is entered, no actual SAS statements
are carried out; the macro is only compiled.
Defining and Accessing Macro Variables in the Data Step
You can set a macro variable to a value in the data step using the
call symput function. The format is
call symput(name,value);
where name is a string or character variable containing the name of
the macro variable to be created, and value is the value the macro
variable will have.
To access a macro variable in a data step, you can use the symget
function.
value = symget(name);
name is a string or character variable containing the name of the
macro variable to be accessed.
call symput: Example
Suppose we want to put the maximum value of a variable in a title.
The following program shows how.
data new;
retain max -1e20;
set salary end = last;
if salary > max then max = salary;
if last then call symput("maxsal",max);
drop max;
run;
title "Salaries of employees (Maximum = &maxsal)";
proc print data=salary;
run;
Note that no ampersand is used in call symput, but you must use
an ampersand to reference the macro variable later in your
program.
An Alternative to the macro facility
As an alternative to the previous example, we can use the put
statement to write a SAS program, and then use the %include
statement to execute the program. Using this technique, the
following statements recreate the previous example:
proc means data=salary noprint;
var salary;
output out=next max=maxsal;
data _null_;
set next;
file "tmpprog.sas";
put ’title "Salaries of employees (Maximum =’ maxsal ’)";’;
put ’proc print data=salary;’;
put ’run;’;
run;
%include "tmpprog.sas";
Pay special attention to quotes and semicolons in the generated
program.
Another Alternative to the Macro Facility
In addition to writing SAS statements to a file, SAS provides the
call execute function. This function takes a quoted string, a
character variable, or a SAS expression which resolves to a
character variable and then executes its input when the current
data step is completed.
For example, suppose we have a data set called new which contains
a variable called maxsal. We could generate a title statement
containing this value with statements like the following.
data _null_;
set new;
call execute(’title
"Salaries of employees (Maximum = ’|| put(maxsal,6.) || ’)";’);
run;
call execute Example
As a larger example of the use of the call execute function,
consider the problem of reading a list of filenames from a SAS data
set and constructing the corresponding data steps to read the files.
The following program performs the same function as the earlier
macro example.
data _null_;
set files;
call execute(’data ’ || name || ’;’);
call execute(’infile "’|| trim(name) || ’";’);
call execute(’input x y;’);
call execute(’run;’);
run;
Be careful with single and double quotes, and make sure the
generated statements follow the rules of SAS syntax.
Application: Reading a Series of Files
Suppose we have a data set containing the names of files to be read,
and we wish to create data sets of the same name from the data in
those files. First, we use the call symput function in the data step
to create a series of macro variables containing the file names
data _null_;
set files end=last;
n + 1;
call symput("file"||left(n),trim(name));
if last then call symput("num",n);
run;
Since macros work by simple text substitution, it is important that
there are no blanks in either the macro name or value, thus the use
of left and trim
Application: Reading a Series of Files (cont’d)
Now we can write a macro to loop over the previously defined file
names and create the data sets.
%macro readem;
%do i=1 %to #
data &&file&i;
infile "&&file&i";
input x y;
run;
%end;
%mend;
%readem;
Notice that the macro variable is refered to as &&file&i, to force
the macro substitution to be scanned twice. If we used just a single
ampersand, SAS would look for a macro variable called &file.
Macros with Arguments
Consider the following program to print duplicate cases with
common values of the variables a and b in data set one:
data one;
input a b y @@;
datalines;
1 1 12 1 1 14 1 2 15 1 2 19 1 3 15 2 1 19 2 4 16 2 4 12 2 8 18 3 1 19
proc summary data=one nway ;
class a b;
output out=next(keep = a b _freq_ rename=(_freq_ = count));
data dups;
merge one next;
by a b;
if count > 1;
proc print data=dups;
run;
If we had simple way of changing the input data set name and the
list of variables on the by statement, we could write a general
macro for printing duplicates in a data set.
Macros with Arguments (cont’d)
To add arguments to a macro, simply replace the parts of the
program in question with macro variables (beginning with &), and
list the variables in the argument list (without the &).
%macro prntdups(data,by);
proc summary data=&data nway ;
class &by;
output out=next(keep = &by _freq_ rename=(_freq_ = count));
run;
data dups;
merge &data next;
by &by;
if count > 1;
run;
proc print data=dups;
run;
%mend prntdups;
Then the program on the previous slide would be replaced by:
%prntdups(one,a b);
Accessing Operating System Commands
If you need to run an operating system command from inside a
SAS program, you can use the x command. Enclose the command
in quotes after the x, and end the statement with a semicolon. The
command will be executed as soon as it is encountered.
For example, in an earlier program, a file called tmpprog.sas was
created to hold program statements which were later executed. To
remove the file after the statements were executed (on a UNIX
system) you could use the SAS statement:
x ’rm tmpprog.sas’;
Other interfaces to the operating system may be available. For
example, on UNIX systems the pipe keyword can be used on a
filename statement to have SAS read from or write to a process
instead of a file. See the SAS Companion for your operating system
for more details.
Transporting Data Sets
It is sometimes necessary to move a SAS data set from one
computer to another. The internal format of SAS data sets is not
the same on all computers, so to make it possible to transfer data
sets from one computer to another, SAS provides what is known as
a transport format. Whenever you move a SAS data set from one
computer to another, you must first convert it into transport
format.
Keep in mind that SAS data sets are in general readable only by
SAS. Thus, an alternative (or perhaps a backup) method for
transporting data sets is to write them in a human-readable way,
using, for example, put statements. Human-readable files can be
processed by SAS (or some other program), and are generally easier
to move around than SAS transport data sets.
SAS/CONNECT
SAS also provides a product called SAS/CONNECT which lets you
initiate a SAS job on a remote computer from a local SAS display
manager session. It also provides two procedures, proc upload and
proc download to simplify transporting data sets. If
SAS/CONNECT is available on the machines between which the
data set needs to be moved, it may be the easiest way to move the
data set.
SAS/CONNECT must be run from the display manager. When
you connect with the other system, you will be prompted for a
login name and a password (if appropriate). Once you’re
connected, the rsubmit display manager command will submit jobs
to the remote host, even though the log and output will be
managed by the local host.
Creating a Dataset in transport format
proc copy can be used to create a transport format file, but the
critical step is to use the xport keyword in the libname statement.
The specified libname is then the name of the transport format file
which SAS will create, not a directory as is usually the case.
Suppose we wanted to create a SAS transport data file named
move.survey from a SAS data set named save.results.
libname save "/my/sas/dir";
libname move xport "move.survey";
proc copy in=save out=move;
select results;
run;
If you transfer the transport data set using a program like ftp,
make sure that you use binary (image) mode to transfer
the file.
proc transpose
Occasionally it is useful to switch the roles of variables and
observations in a data set. The proc transpose program takes
care of this task.
To understand the workings of proc transpose, consider a data
set with four observations and three variables (x, y and z). Here’s
the transformation proc transpose performs:
Original data Transposed data
X Y Z _NAME_ COL1 COL2 COL3 COL4
12 19 14 X 12 21 33 14
21 15 19 =) Y 19 15 27 32
33 27 82 Z 14 19 82 99
14 32 99
The real power of proc transpose becomes apparent when it’s
used with a by statement.
proc transpose with a by statement
When a by statement is used with proc transpose, a variety of
manipulations which normally require programming can be
acheived automatically.
For example, consider a data set with several observations for each
subject, similar to a previous example:
subj time x
1 1 12
1 2 15
1 3 19
2 1 17
2 3 14
3 1 21
3 2 15
3 3 18
Notice that there is no observation for subject 2 at time 2.
proc transpose with a by statement (cont’d)
To make sure proc transpose understands the structure that we
want in the output data set, an id statement is used to specify
time as the variable which defines the new variables being created.
The prefix= option controls the name of the new variables:
proc transpose data=one out=two prefix=value;
by subj;
id time;
The results are shown below:
subj _NAME_ value1 value2 value3
1 x 12 15 19
2 x 17 . 14
3 x 21 15 18
Notice that the missing value for subject 2, time 2 was handled
correctly.
proc contents
Since SAS data sets cannot be read like normal files, it is important
to have tools which provide information about data sets. proc
print can show what’s in a data set, but it not always be
appropriate. The var and libname windows of the display manager
are other useful tools, but to get printed information or to
manipulate that information, you should use proc contents.
Among other information, proc contents provides the name,
type, length, format, informat and label for each variable in the
data set, as well as the creation date and time and the number of
observations. To use proc contents, specify the data set name as
the data= argument of the proc contents statement; to see the
contents of all the data sets in a directory, define an appropriate
libname for the directory, and provide a data set name of the form
libname. all .
Options for proc contents
The short option limits the output to just a list of variable names.
The position option orders the variables by their position in the
data set, instead of the default alphabetical order. This can be
useful when working with double dashed lists.
The directory option provides a list of all the data sets in the
library that the specified data set comes from, along with the usual
output for the specified data set.
The nods option, when used in conjunction with a data set of the
form libname. all , limits the output to a list of the data sets in
the specified libname, with no output for the individual data sets.
The out= option specifies the name of an output data set to
contain the information about the variables in the specified data
set(s). The program on the next slide uses this data set to write a
human readable version of a SAS data set.
Using the output data set from proc contents
%macro putdat(indata,outfile);
proc contents noprint data=&indata out=fcon; run;
data _null_;
file "tmpprog.sas";
set fcon end=last;
length form $ 8;
if _n_ = 1 then do;
put "data _null_;"/"set &indata;";
put ’file "&outfile";’ / "put " @;
end;
put name @;
if type = 2 then
form = "$"||trim(left(put(length,3.)))||".";
else form = "best12.";
put form @;
if ^last then put "+1 " @;
else put ";" / "run;" ;
run;
%include "tmpprog.sas";
x ’rm tmpprog.sas’;
%mend putdat;
The Display Manager
When SAS is invoked, it displays three windows to help you
interact with your programs and output:
• Program Window - for editing and submitting SAS statements
• Log Window - for viewing and saving log output
• Output Window - for viewing and saving output
Some commands which open other useful windows include:
• assist - menu driven version of SAS
• dir - shows data sets in a library
• var - shows variables in a data set
• notepad - simple text window
• options - view and change system options
• filename - view current filename assignments
• help - interactive help system
• libname - view current libname assignments
Appearance of Display Manager
OUTPUT----------------------------------------------------------------------------------+
|Command ===> |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
LOG-------------------------------------------------------------------------------------+
|File Edit View Locals Globals Help |
| |
| |
|This is version 6.11 of the SAS System. |
| |
| |
|NOTE: AUTOEXEC processing beginning; file is /app/sas611/autoexec.sas. |
| |
|NOTE: SAS initialization used: |
| real time 0.567 seconds |
| cpu time 0.421 seconds |
| |
PROGRAM EDITOR--------------------------------------------------------------------------+
|Command ===> |
| |
|00001 |
|00002 |
|00003 |
|00004 |
|00005 |
|00006 |
|00007 |
|00008 |
|00009 |
|00010 |
+---------------------------------------------------------------------------------------+
Entering Display Manager Commands
You can type display manager commands on the command line of
any display manager window. (To switch from menu bar to
command line select Globals -> Options -> Command line; to
switch back to menu bar, enter the command command.)
You can also enter display manager commands from the program
editor by surrounding them in quotes, and preceding them by dm,
provided that the display manager is active.
Some useful display manager commands which work in any window
include:
• clear - clear the contents of the window
• end - close the window
• endsas - end the sas session
• file "filename" - save contents of the window to filename
• prevcmd - recall previous display manager command
The Program Editor
There are a number of special display manager commands available
in the program editor.
• submit - submit all the lines in the editor to SAS
• subtop - submit the first line in the editor to SAS
• recall - place submitted statements back in the editor
• include "file" - place the contents of file in the editor
• hostedit - on UNIX systems, invoke the editor described in
the editcmd system option
Typing control-x when the cursor is in the program editor toggles
between insert and overwrite mode.
You can close the program window with the display manager
command program off.
Using the Program Editor
There are two types of commands which can be used with the
program editor
• Command line commands are entered in the Command ===>
prompt, or are typed into a window when menus are in effect.
• Line commands are entered by typing over the numbered lines
on the left hand side of the editor window. Many of the line
commands allow you to operate on multiple selected lines of
text.
In addition, any of the editor or other display manager commands
can be assigned to a function or control key, as will be explained
later.
Note: The undo command can be used to reverse the effect of
editing commands issued in the display manager.
Editor Line Commands
Commands followed by <n> optionally accept a number to act on
multiple lines.
Inserting Lines Deleting Lines
i<n> insert after current line d<n> delete lines
ib<n> insert before current line dd block delete
Moving Lines Copying Lines
m<n> move lines c<n> copy lines
mm block move cc block copy
Other Commands
>><n> indent lines <<<n> remove indentation
tc connect text ts split text
Type block commands on the starting and ending lines of the block
and use a b or a command to specify the a line before which or
after which the block should be placed.
Defining Function and Control Keys
You can define function keys, control keys, and possibly other keys
depending on your operating system, through the keys window of
the display manager.
To define a function key to execute a display manager command,
enter the name of the command in the right hand field next to the
key you wish to define.
To define a function key to execute an editor line command, enter
the letter(s) corresponding to the command preceded by a colon (:)
in the right hand field.
To define a function key to insert text into the editor, precede the
text to be inserted with a tilda (~) in the right hand field.
Some display manager commands only make sense when defined
through keys. For example the command home puts the cursor on
the command line of a display manager window.
More on Function Keys
You can define a function key to perform several commands by
separating the commands with a semicolon (;).
Function keys defining display manager commands are executed
before any text which is on the command line. Thus, you can enter
arguments to display manager commands before hitting the
appropriate function key.
To set function keys without using the keys window, use the
display manager keydef command, for example:
keydef f2 rfind
Keys set in this way will only be in effect for the current session.
Cutting and Pasting
If block moves and/or copies do not satisfy your editing needs, you
can cut and paste non-rectangular blocks of text. Using these
commands generally requires that keys have been defined for the
display manager commands mark, cut, and paste, or home.
To define a range of text, issue the mark command at the beginning
and end of the text you want cut or pasted. Then issue the cut
(destructive) or store (non-destructive) command. Finally, place
the cursor at the point to which you want the text moved, and
issue the paste command.
When using cut or store, you can optionally use the append
option, which allows you to build up the contents of the paste
buffer with several distinct cuts or copies, or the buffer=name
option, to create or use a named buffer.
Searching and Changing Text
The display manager provides the following commands for
searching and, in the program editor or notepad, changing text.
These commands include:
• find string - search forward for string
• bfind string - search backward for string
• rfind - repeat previous find command
• change old new - change old to new
• rchange - repeat previous change command
Each of these commands takes a variety of options:
Scope of Search: next, first, last, prev, all
Component of Search: word, prefix, suffix
Case Independence: icase
If there are blanks or special symbols in any of the strings,
surround the entire string in single or double quotes.
Using the Find and Change Commands
• To change every occurence of the string “sam” to “fred”,
ignoring the case of the first string, enter
change sam fred all icase
• To selectively change the word cat to dog, use
change cat dog word
followed by repeated use of rfind, to find the next occurence
of the word, and rchange if a change is desired.
• To count the number of occurences of the word fish, use
find fish all
and the count will be displayed under the command line.
If an area of text is marked (using the display manager mark
command), then search and/or find commands apply only to the
marked region.
Customizing
the Display Manager
Key definitions entered through the keys window are automatically
stored from session to session.
The color display manager command allows you to customize the
colors of various components of SAS windows. The sascolor
window allows you to change colors through a window.
To save the geometry and location of display manager windows,
issue the display manager command wsave from within a given
window, or wsave all to save for all windows.
Key definitions entered through the keys window are automatically
stored from session to session.
The color display manager command allows you to customize the
colors of various components of SAS windows. The sascolor
window allows you to change colors through a window.
To save the geometry and location of display manager windows,
issue the display manager command wsave from within a given
window, or wsave all to save for all windows.
No comments:
Post a Comment