data _null_;
   command = 'nslookup 207.255.105.92';
   infile ns1 pipe filevar=command end=eod1;
   do until (eod1);
      input;
      put '(1) ' _infile_;
   end;
   command = 'nslookup 207.255.105.93';
   infile ns2 pipe filevar=command end=eod2;
   do until (eod2);
      input;
      put '(2) ' _infile_;
   end;
   stop;
run;

data _null_;
   do command = 'nslookup 207.255.105.92', 'nslookup 207.255.105.93';
      eod = 0;
      infile nslookup pipe filevar=command end=eod;
      do until (eod);
         input;
         put command ':' _infile_;
      end;
   end;
   stop;
run;

prints

332  data _null_;
333     command = 'nslookup 207.255.105.92';
334     infile ns1 pipe filevar=command end=eod1;
335     do until (eod1);
336        input;
337        put '(1) ' _infile_;
338     end;
339     command = 'nslookup 207.255.105.93';
340     infile ns2 pipe filevar=command end=eod2;
341     do until (eod2);
342        input;
343        put '(2) ' _infile_;
344     end;
345     stop;
346  run;

NOTE: The infile NS1 is:
      Unnamed Pipe Access Device,
      PROCESS=nslookup 207.255.105.92,RECFM=V,
      LRECL=256

(1) Server:  spoke.dcn.davis.ca.us
(1) Address:  168.150.253.2
(1)
(1) Name:    207-255-105-092-dhcp.unt.pa.atlanticbb.net
(1) Address:  207.255.105.92
(1)
NOTE: The infile NS2 is:
      Unnamed Pipe Access Device,
      PROCESS=nslookup 207.255.105.93,RECFM=V,
      LRECL=256

(2) Server:  spoke.dcn.davis.ca.us
(2) Address:  168.150.253.2
(2)
(2) Name:    207-255-105-093-dhcp.unt.pa.atlanticbb.net
(2) Address:  207.255.105.93
(2)
NOTE: 6 records were read from the infile NS1.
      The minimum record length was 0.
      The maximum record length was 51.
NOTE: 6 records were read from the infile NS2.
      The minimum record length was 0.
      The maximum record length was 51.
NOTE: DATA statement used (Total process time):
      real time           0.75 seconds
      cpu time            0.01 seconds


347
348  data _null_;
349     do command = 'nslookup 207.255.105.92', 'nslookup 207.255.105.93';
350        eod = 0;
351        infile nslookup pipe filevar=command end=eod;
352        do until (eod);
353           input;
354           put command ':' _infile_;
355        end;
356     end;
357     stop;
358  run;

NOTE: The infile NSLOOKUP is:
      Unnamed Pipe Access Device,
      PROCESS=nslookup 207.255.105.92,RECFM=V,
      LRECL=256

nslookup 207.255.105.92 :Server:  spoke.dcn.davis.ca.us
nslookup 207.255.105.92 :Address:  168.150.253.2
nslookup 207.255.105.92 :
nslookup 207.255.105.92 :Name:    207-255-105-092-dhcp.unt.pa.atlanticbb.net
nslookup 207.255.105.92 :Address:  207.255.105.92
nslookup 207.255.105.92 :
NOTE: The infile NSLOOKUP is:
      Unnamed Pipe Access Device,
      PROCESS=nslookup 207.255.105.93,RECFM=V,
      LRECL=256

nslookup 207.255.105.93 :Server:  spoke.dcn.davis.ca.us
nslookup 207.255.105.93 :Address:  168.150.253.2
nslookup 207.255.105.93 :
nslookup 207.255.105.93 :Name:    207-255-105-093-dhcp.unt.pa.atlanticbb.net
nslookup 207.255.105.93 :Address:  207.255.105.93
nslookup 207.255.105.93 :
NOTE: 6 records were read from the infile NSLOOKUP.
      The minimum record length was 0.
      The maximum record length was 51.
NOTE: 6 records were read from the infile NSLOOKUP.
      The minimum record length was 0.
      The maximum record length was 51.
NOTE: DATA statement used (Total process time):
      real time           0.75 seconds
      cpu time            0.03 seconds

This code shows how to apply a dynamically defined format in PROC REPORT. In this simplified example, the format will be 10.0 if the variable DECIMALS has a value of 0, 10.1 if DECIMALS has a value of 1, and so forth.

data test (keep=decimals value displayed);
   do i = 1 to 5;
      do decimals = 0 to 3;
         value = ranuni(95605) * 10;
         displayed = value;
         output;
      end;
   end;
   stop;
run;
 
proc report data=test nowindows missing nocenter;
   columns value decimals displayed;
   define _all_ / display;
   compute displayed;
      call define(_col_, 'format', '10.' || put(decimals, z1.0));
   endcomp;
run;

prints:

      value   decimals  displayed
  3.4648784          0          3
  3.3165982          1        3.3
  2.0278367          2       2.03
  8.0749122          3      8.075
  8.1445687          0          8
  7.6102304          1        7.6
  5.2384895          2       5.24
  3.8716015          3      3.872
  5.5787562          0          6
   0.951658          1        1.0
  9.5194012          2       9.52
  6.4120504          3      6.412
  7.6308912          0          8
  1.8146458          1        1.8
  2.6590652          2       2.66
   2.289426          3      2.289
  0.5009372          0          1
  7.2236493          1        7.2
  6.0467117          2       6.05
  2.5131059          3      2.513

This is a simple example of the use of the "hash" or associative array object in the SAS version 9 data step. This example doesn't accomplish anything except demonstrate the syntax.

data test;
   length outname $5.;
   do outname = 'one', 'two', 'three';
      do i = 1 to 5;
         random = ranuni(95605);
         output;
      end;
   end;
run;

data _null_;

   if _n_ = 1 then 
      do;
      length outname $5.;
      length i random 8.;
      /* Read TEST data set */
      declare hash test(dataset: 'test');
      /* Define OUTNAME as key and I, RANDOM as data for hash object */
      test.defineKey('outname', 'i', 'random');
      test.defineData('outname', 'i', 'random');
      test.defineDone();
      /* avoid uninitialized variable notes */
      call missing(outname, i, random);
      end;

   /* Create output data set from hash object */
   rc = test.output(dataset: 'work.out');
   stop;

*****; run;

proc print data=work.out;
run;

prints

Obs    outname    i     random

  1     three     2    0.64121
  2     one       4    0.80749
  3     three     1    0.95194
  4     one       2    0.33166
  5     three     3    0.76309
  6     one       5    0.81446
  7     two       5    0.09517
  8     one       3    0.20278
  9     three     4    0.18146
 10     two       1    0.76102
 11     two       3    0.38716
 12     three     5    0.26591
 13     two       4    0.55788
 14     one       1    0.34649
 15     two       2    0.52385

This code writes to an in-memory array using the PUT statement. Although there ought to be a builtin way to do this (there was in the data step language's model, PL/I), there's not. This provides a workaround.

The general idea is create a memory buffer using FILE and INFILE with SHAREBUFFERS; when the file is written to, the value of the automatic variable _INFILE_ is set. You can then copy _INFILE_ to a member of your array. Only one actual I/O operation takes place, because everything is buffered.

The same technique works for a single variable; this example uses an array because that's what I needed when I created the original code.

filename buffer catalog 'work.io.buffer.source' lrecl=100 recfm=f;

data _null_;
   file buffer lrecl=100 recfm=f;
   put ' ';
run;

options stimer fullstimer;

data _null_;

   array claims (1000) $100. _temporary_ (1000 * ' ');

   infile buffer sharebuffers lrecl=100 recfm=f;
   file buffer;

   input @@;  /* Make sure buffer exists */

   do i = 1 to 1000;
      put @1 'a b c ' i comma6.0 @@;
      claims(i) = _infile_;
   end;

   file log; 

   do i = 1 to 5, 996 to 1000;
      put i= claims{i}=;      
   end;

   stop;

run;

See also the documentation for the _INFILE_ and _FILE_ variables. On some cases, _FILE_ will be all you need.

If you want to sort a field in a case-insensitive way (for use by humans, not computers), there are several ways you can do it.

options nocenter nodate nonumber;
data test;
infile cards;
input sometext $8.;
cards;
abcd
ABCD
aBcD
efgh
EFGH
111
a
Z
A
z
;;;; run;

proc sort data=test out=test_default;
   by sometext;
run;

title 'Default Sort Order';
proc print data=test_default;
run;

proc sort data=test out=test_lat1_lcs
          sortseq=lat1_lcs; 
   by sometext;
run;

title 'lat1_lcs Sort Order';
proc print data=test_lat1_lcs;
run;

proc sql;
   create table test_sql as
      select   *
      from     test
      order    by upcase(sometext);
quit;

title 'SQL Sort Order';
proc print data=test_sql;
run;

The result:

Default Sort Order

Obs    sometext

  1      111
  2      A
  3      ABCD
  4      EFGH
  5      Z
  6      a
  7      aBcD
  8      abcd
  9      efgh
 10      z

lat1_lcs Sort Order

Obs    sometext

  1      111
  2      a
  3      A
  4      abcd
  5      ABCD
  6      aBcD
  7      efgh
  8      EFGH
  9      Z
 10      z

SQL Sort Order

Obs    sometext

  1      111
  2      A
  3      a
  4      aBcD
  5      abcd
  6      ABCD
  7      EFGH
  8      efgh
  9      z
 10      Z

In this case, the last two sorts produce the same result. On an EBCDIC system, however, they would be different because of differences between ASCII encoding and EBCDIC encoding. Also, the first sort would produce different results on the two systems.

It's hard to think of a good practical application for this code, but maybe one will come up. It shows the use of the file information functions in PROC SQL to write a flat file.

data test;
   input @1 value $8.;
cards;
abc
defg
hijklmno
;;;;

proc sql;

   select   F.filename_rc, 
            F.file_id, 
            D.value,
            fput  (f.file_id, 'value=' || value) as fput_rc, 
            fwrite(f.file_id) as fwrite_rc
   from
           (select   filename('myfile', 'c:\temp\myfile.txt') as filename_rc,
                     fopen('myfile', 'O', 256, 'v') as file_id
            from     test (obs=1)
            ) as F
   right join
            test as D
   on       1=1
   ;

quit;      

data _null_;
   infile 'c:\temp\myfile.txt';
   input;
   put 'INFO: myfile.txt: ' _infile_;
run;

prints in the log:

NOTE: The infile 'c:\temp\myfile.txt' is:
      File Name=c:\temp\myfile.txt,
      RECFM=V,LRECL=256

INFO: myfile.txt: value=abc
INFO: myfile.txt: value=defg
INFO: myfile.txt: value=hijklmno
NOTE: 3 records were read from the infile 'c:\temp\myfile.txt'.
      The minimum record length was 14.
      The maximum record length was 14.

On SAS-L, 2/22/2005, Laughing Beggar asked about counting the occurence of strings in variables:

These 3 must be easy, but I am forced to defer to the wisdom of the group. My data set has, say, ten character variables. Each variable can have a text value that starts with a letter of the aplhabet and is then followed by some numbers (eg A24.6). What I want to do is count the number of times a string starting with eg "A" appears (1) in the dataset, (2) for each record and (3) in each variable. I also need to do this for all the other letters of the alphabet. So for (2), for example, I'd like a new variable created for each letter of the alphabet that has the count of the number of times that letter appears as the leading character in the string across the ten variables. All hints gratefully accepted. SAS V8.02, WIN-XP.

Arrays are one solution to this problem.

The code can probably be made simpler, but something like this will do it:

data test;
   infile cards;
   input (var1-var5) ($);
   cards;
A1 B1 A1 Z2 C1
A1 A1 A1 A1 A1
B1 B2 A1 T2 D1
B1 B2 B3 B4 Z5
;;;;

data colcounts (keep= c1_c1-c1_c26  c2_c1-c2_c26  
                      c3_c1-c3_c26  c4_c1-c4_c26  
                      c5_c1-c5_c26)
     rowcounts (keep= r1-r26)
     dscounts  (keep=d1-d26);
   retain alpha 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';  
   drop alpha;

   set test end=end;

   array vars var1-var5;
   array letters_in_dataset{26} d1-d26;
   array letters_in_columns{5, 26} c1_c1-c1_c26  
                                   c2_c1-c2_c26
                                   c3_c1-c3_c26
                                   c4_c1-c4_c26
                                   c5_c1-c5_c26;
   array letters_in_row{26} r1-r26;

   do p = 1 to 26;
      letters_in_row{p} = 0;
   end;

   do v = 1 to 5;
      do p = 1 to 26;
         letters_in_dataset(p) + (vars{v} =: substr(alpha, p, 1));
         letters_in_row(p) + (vars{v} =: substr(alpha, p, 1));
         letters_in_columns(v, p) + (vars{v} =: substr(alpha, p, 1));
      end;
   end;

   output rowcounts;

   if end then 
      output colcounts dscounts;

run;
;

From Richard de Venezia, slightly modified:

data abc;

   group = 1;

   idx = '1'; x = 1.1;
   idy = 'a'; y = 10.10;
   output;

   idx = '2'; x = 2.2;
   idy = 'b'; y = 11.11;
   output;

   idx = '3'; x = 3.3;
   idy = 'c'; y = 13.13;
   output;

run;

proc report nowindows data=abc;
  columns group (idx, x) (idy, y);
  define group / display group;
  define idx / across ;
  define idy / across ;
  define x / sum;
  define y / sum;
run;

I'm not a fan of PROC TRANSPOSE; there's almost nothing it can do that I can't do in a data step or PROC SQL. But back in August of 2004 on SAS-L, Michael Murff proposed a use of PROC TRANSPOSE which even I would support:

proc transpose data=sasuser.iris (obs=0)
               out=xnames (keep=_name_);
    var _all_;
run;

I added "obs=0" to the original proposal to speed processing, and Ya Huang added "var _all_" to get all variables, not just numeric ones.

This example was written in response in a question on SAS-L. Someone wanted to know how to force a line split within an cell. As it happens, the mechanism to do that is the same mechanism used to make part of the output bold or in a different font - ODS.

This should work for RTF and PDF output in SAS 8.2 and later (maybe earlier, but I can't check), and for HTML in 9.1.3 (but HTML in 8.2 doesn't work right).

data x;                                                                                                                                 
  text1='hello';                                                                                                                        
  text2='everyone';                                                                                                                     
  output;                                                                                                                               
run;                                                                                                                                    
                                                                                                                                        
ods listing close;                                                                                                                      
ods rtf file='h:\temp\test.rtf';                                                                                                        
ods pdf file='h:\temp\test.pdf';                                                                                                        
ods escapechar='^';                                                                                                                     
                                                                                                                                        
proc report data=x nowindows missing;                                                                                                   
  column text1 text2 text;                                                                                                              
  define text1-text2 / noprint;                                                                                                         
  define  text / computed;                                                                                                              
  compute text / character length=200;                                                                                                  
     text = '^S={font_face=courier font_weight=bold}' || text1
            || ' ^n^S={font_face=times font_style=italic}' || text2;                 
  endcomp;                                                                                                                              
run;                                                                                                                                    
                                                                                                                                        
ods rtf close;                                                                                                                          
ods pdf close;                                                                                                                          
ods listing;                                                                                                                            

The key here is the use of style directives. ^S tells SAS that style information will follow, and ^n means "insert a line break".

One of my interests lately has been in figuring out ways to create master/detail (invoice/lineitem, etc.) reports in SAS. I've concentrated on what can be done in base SAS.

Although it's not a base product, SAS/Intrnet also has a way to produce master/detail reports - the htmSQL processor. It takes an HTML page marked up with special tags and expands the tags using data from SAS. This is typically done though a web server, but if you have SAS/Intrnet licensed you can use the module outside of the web. You can produce only HTML (or other text-based output), but even so this has the potential to be a powerful tool for certain uses. This usage is documented, but I haven't seen a usage in the wild, so I'm posting an example.

I haven't done anything at all fancy with the HTML; it's just the bare minimum. Also, this doesn't show the hoops I had to jump through to get all the file permissions set right, but they would be site-dependent anyway.

%let htmsqlpgm = /opt/nethome1/datawebapps/sas-cgi/htmSQL;

/**** Set up data ****/
options compress=no nocenter nodate nonumber;

libname me '/usr/users/hamiltja';

data me.Invoices;

  infile cards;

  input @1  Invoice_Num   3.
        @5  Customer      $14.
        @20 Invoice_Date  date9.;

  format Invoice_Date worddatx12.;

cards;
101 Hugo Furst     01Jan2004
102 Freida Peeples 15Jan2004
103 Al E. Loohah   30Jan2004
;;;;

data items;

  infile cards;

  length Item $17.;

  input @1  Item  $10.
        @12 Cost  10.2;

  format cost comma10.2;

cards;
Widget     12.00
Gadget     10.00
Frammet    36.00
Gizmo      50.37
Whatsit    100.00
ItsIts     1.00
Thingie    37.56
Sprocket   13.00
Geehaws    5.76
HooHaas    22.22
DingDing   37.54
Thing      79.43
HoopyDoopy 40.01
Mairsy     67.66
Doat       77.21
Doesy      85.31
Divy       49.37
;;;;

data me.LineItems;

  keep Invoice_Num Line_Num Item Cost;

  set me.invoices (keep=invoice_num);

  length size1-size5 $6.;
  length item $30.;

  array sizes{5} size1-size5 (' ' 'Small' 'Medium' 'Large' 'Jumbo');

  Line_Num = 0;

  do i = 1 to 6;
     if ranuni(95819) > .2 then
        do;
        set items (rename=(Item=ItemName Cost=ItemCost))point=i;
        do j = 1 to 5;
           if ranuni(40324) > .2 then
              do;
              size = sizes(j);
              item = catx(' ', size, itemname);
              cost = itemcost * j;
              line_num + 1;
              output;
              end;
        end;
        end;
  end;

run;

proc datasets library=me nolist;
  modify LineItems;
     index create Invoice_Num;
run; quit;

/**** The Real Work ****/

/* Create a file containing the htmSQL we want to use. */

filename hsql '/usr/users/hamiltja/batchweb.hsql';

data _null_;
  infile cards;
  file hsql;
  input;
  put _infile_;
cards4;
<html>
  <body>
  <h1>Invoices and Items</h1>

  {query server="mtshrtst"}
  {library sqlname="invoice" path="/usr/users/hamiltja"}

  {sql}
  select   Invoice_Num,
           Customer,
           Invoice_Date
  from     invoice.invoices
  order    by invoice_num
  {/sql}

  {eachrow}
     <h2>Invoice {&INVOICE_NUM} for {&CUSTOMER} dated {&INVOICE_DATE}</h2>

     {sql}
     select   Line_Num,
              Item,
              Cost
     from     invoice.lineitems
     where    invoice_num = {&INVOICE_NUM}
     order    by line_num
     {/sql}

     <table border="1">
        <tr>{label var="{&sys.colname[*]}" 
                         before="<th>" 
                         between="</th><th>" 
                         after="</th>"}</tr>
        {eachrow}
        <tr>{&{&sys.colname[*]}
                      before="<td>" 
                      between="</td><td>" 
                      after="</td>"}</tr> {/eachrow}
     <table>
  {/eachrow}

  {/query}

  </body>
</html>
;;;;

filename htmsql pipe 
         "&HTMSQLPGM. /usr/users/hamiltja/batchweb.hsql '_debug=0'";
filename webout '/usr/users/hamiltja/batchweb.html';


/* Run program through pipe.  Throw away first four lines of output, */
/* which contain header information used by browsers.                                                                         */
data _null_;
  file webout;
  infile htmsql lrecl=1024 firstobs=4;
  input;
  put _infile_;
run;

Here's the first part of the output, with extraneous blank lines deleted:

<html>

  <body>

  <h1>Invoices and Items</h1>

     <h2>Invoice      101 for Hugo Furst dated 01JAN2004  </h2>
     <table border="1">
        <tr><th>Line_Num</th><th>item</th><th>cost</th></tr>
        <tr><td>       1</td><td>Widget</td><td>      12</td></tr>
        <tr><td>       2</td><td>Small Widget</td><td>      24</td></tr>
        <tr><td>       3</td><td>Medium Widget</td><td>      36</td></tr>
        <tr><td>       4</td><td>Small Gadget</td><td>      20</td></tr>

Here's how I would use the macro in an htmSQL page. The page is designed to display arbitrary data sets (for a particular data set, I could just hard code everything), and assumes that variables LIBRARY and TABLE have been passed as parameters. I'm not showing the queery statement or surrounding HTML here:

{sql}
select   resolve('%mtprivatizesqlvars(data={&LIBRARY}.{&TABLE})') 
            as selectstring length=32000
from     dictionary.columns
where    libname = upcase('{&LIBRARY}') 
         and upcase(memname) = upcase('{&TABLE}') 
         and memtype = 'DATA'
         and varnum = 1
{/sql}

{sql}
select    {&SELECTSTRING}
from     {&LIBRARY}.{&TABLE}
{/sql}

<table border="1">
   <tr><th>Name</th>{&SYS.COLNAME[*] before="<th>" between="</th><th>" after="</th>"}</tr>
   <tr><th>Label</th>{label var="{&SYS.COLNAME[*]}" before="<th>" between="</th><th>" after="</th>"}</tr>
  {eachrow}
   <tr><th>{&SYS.QROW}</th>{&{&SYS.COLNAME[*]} before="<td>" between="</td><td>" after="</td>"}</tr>
  {/eachrow}
</table>

The first block of code captures the output of the mtprivatizesql macro into an htmSQL variable. The macro must have been stored in a macro search path known to the htmSQL processor. The key here is the use of the RESOLVE function, which returns the results of evaluating a string. I'm assuming a reasonable number of variables (something which is under my control), so the results will fit into the selectstring length of 32,000 bytes. By the way, this doesn't work in SAS 8.2, where you'll get only the first 200 characters of the result.

The second block of code selects the records to display.

The third block of code displays the records. I've chosen to display two header lines, the first showing the variable names and the second showing the variable labels.

By the way, there are other checks, not shown, which prevent the end user from changing the URL to display an arbitrary table anywhere on the system.

A Simple Example of PROC COMPUTAB

data example;

   input year sales cost;

cards;

1988  83  52

1989 106  85

1990 120 114

;;;; run;



ods listing;


proc computab data=example;
   columns y1988 y1989 y1990 total;
   rows sales cost gprofit pctprofit;

   gprofit = sales - cost;

   y1988 = (year = 1988);
   y1989 = (year = 1989);
   y1990 = (year = 1990);

   col: total = y1988 + y1989 + y1990;

   row: pctprofit = gprofit / cost * 100;

*****; run;

filename cmds temp;

data _null_;
   file cmds recfm=v;
   infile datalines;
   input;
   put _infile_;
datalines;
verbose
open ftp.excursive.com
user nogood nogood
ascii on
get index.html
quit
;;;;

/* Windows */
filename ftp pipe "type %SYSFUNC(pathname(cmds)) | ftp -i -n";
/* Unix */
*filename ftp pipe "cat %SYSFUNC(pathname(cmds)) | ftp -i -n";

data _null_;
   retain errfound 1.;
   infile ftp end=end;
   input;
   put 'INFO: ' _infile_;
   if _infile_ =: '226 Transfer completed' then 
      errfound = 0;
   if end and errfound then 
      do;
      put 'ER' 'ROR: FTP failed.';
      *abort abend 12;
      end;
   return;
run;

/* Create pseudo-observation numbers, restarted at each break.  */

options ls=64;
options nodate;
title ' ';

proc report
        data=sasuser.iris
        headskip split='\'
        colwidth=12
        nowindows;

   column species seq sepallen sepalwid;

   define species  / order      'Species\--';
   define seq      / computed   'Seq\--';
   define sepallen / order      'Sepal Length\--';
   define sepalwid / sum        'Sepal Width\--';

   compute seq;
      if species ne ' ' and _break_ eq ' ' then
         obs_no = 1;
      else
         obs_no + 1;
      seq = obs_no;
   endcomp;

   break after species / page;

*****; run;

filename dane url
'http://www.parkiet.com:80/dane/danesesji/bazytxt/akcje/zywiec.zip'
         proxy='http://slcpx01:8080';

filename zipcopy  "d:\temp\zywiec.zip";
filename zipfile  SASZIPAM "d:\temp\zywiec.zip";

data _null_;
   nbyte=-1;
   infile dane nbyte=nbyte recfm=s;
   input;
   file zipcopy recfm=n;
   put _infile_;
run;

data _null_;
   infile zipfile(ZYWIEC.txt);
   input;
   put _infile_;
   if _n_ > 10 then stop;
run;

data test;
   infile cards;
   input phone $14.;
cards;
(916) 555-1234
9165551234
916-555-1234
916 555-1234
916 555 1234
916 5551234
916555123499
1234
5551212
555-1212
(916) 555-HELP
;;;;

data validate;
   set test;
   pattern = translate(phone, '000000000', '123456789');
   if pattern in ('(000) 000-0000', '0000000000', '000-000-0000', 
                  '000 000-0000', '000 000 0000', '000 0000000') then 
      valid = '1';
   else
      valid = '0';

   put (_all_) (=);

run;

data hat (compress=no pointobs=no);
   do x = -5 to 5 by .25;
      do y = -5 to 5 by .25;
         z = sin(sqrt(x*x + y*y));
         output;
      end;
   end;
run;

proc template;
   define statgraph myhat;
      layout gridded;
         surfaceplot x=x y=y z=z;
      endlayout;
   end;
run;

ods graphics on;
ods pdf file='c:\temp\hat.pdf' notoc;

data _null_;
   set hat;
   file print ods=(template="myhat");
   put _ods_;
run;

ods pdf close;

produces a PDF file containing an image.

Counting words in a string using SAS regular expression functions

data _null_;
   retain rx;
   infile cards eof=eof;
   input @1 string $char30.;

   if _n_ = 1 then
      do;
      rx = rxparse('" "* ((~" "+ " "+) #1)*');
      put @1 'Words'
          @7 'String';
      end;

   call rxsubstr(rx, string || ' ', pos, len, score);

   put @1  score   5.0-r
       @7  string  $char30.;

return;

EOF:

      put 'end of data';
      call rxfree(rx);

cards4;
123456789012345678901234567890
String
oneword
 oneword
two words
three words here
  big gaps a   b  c          d
a*b*c=d

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
;;;;

Here's a method of using "infile magic" to parse the value of the &SYSPARM macro variable, which is valued by setting the SYSPARM system option, typically on the command line or in JCL when you start SAS.

options sysparm='value=37.2 start=01jan2006, end=01mar2006';

data _null_;
   retain repeats 2.;
   infile cards;
   informat start end date9.;
   input @;
   _infile_ = translate(symget('sysparm'), ' ', ',');
   input start= end= value= repeats=; 
   format start end date9.;
   put (_all_) (=);
   stop;
cards;

;;;; 

prints:

start=01JAN2006 end=01MAR2006 value=37.2 repeats=2

A few comments:

• The separator has to be a blank for named input. Commas are translated into blanks because under MVS a comma will appear in the value of SYSPARM if you use JCL continuation when specifying SYSPARM. This will, of course, present difficulties if you need to have a comma in one of your values.
• You can assign a default value to a parameter by establishing its value before the INPUT statement. In this case, I used the RETAIN statement to set the value.
• The parameters can appear in any order. Unfortunately, you can't tell (without reparsing the data) which order they did appear in.
• If you include in SYSPARM a variable which does not appear in the INPUT statement, you'll get a note in the log and _ERROR_ will be set to 1.
• In real life, you'd want to save the values somewhere, either in a SAS data set or with CALL SYMPUT/SYMPUTX.