A SAS program is three languages. This engine reads all three.

SAS is not one language. It is a row-at-a-time imperative language, a family of procedure sub-languages, and a text generator that runs before either of them and produces their source. The third one is why this is hard.

%macro extract(region=, months=12);
   %let cutoff = %sysfunc(intnx(month,
       %sysfunc(today()), -&months., E), date9.);
   %let n = 3;
   %do i = 1 %to &n.;
      %let tbl&i. = sales_&region._&i.;
   %end;
   proc sql;
      create table work.summary_&region. as
      select t.customer_id, sum(t.amount) as total
      from connection to oracle
           (select customer_id, amount from ORDERS)
      %do i = 1 %to &n.;
         union all select customer_id from &&tbl&i.
      %end;
      group by t.customer_id
      having calculated total > 0;
   quit;
%mend extract;

SourceFile
└── MacroDefinition extract, 2 MacroArgument
    ├── VariableDeclaration cutoff
    │   └── SystemFunctionCallExpression %sysfunc
    │       └── SystemFunctionCallExpression %sysfunc
    ├── DoStatement i = 1 %to &n
    │   └── VariableDeclaration tbl&i
    └── ⋯ PROC SQL step
        ├── DatasetSpec work.summary_&region
        ├── VariableExpression &&tbl&i — indirect
        └── nativeSQL verbatim, not parsed as SAS

Each of these is a place where a lexer, not a parser, has to make the decision — and each one appears in the regression suite because it appeared in a client’s code first.

%let tbl1 = sales_eu;
%let i = 1;
%put &&tbl&i;   * reads tbl1;

%Let SaveLog = %STR (/ccrm/RM/&env
      /Bankcard/&ProgName..log);

proc sql;
  connect to oracle as ora ('&cred');
  select * from connection to ora
    (select * from dual);
quit;

data orders;
  input sku $ 1-8 @10 qty 3. #2 note $40.;
  datalines;
…

Case is handled by a dedicated case-insensitive fragment grammar rather than by lowercasing the input, so original casing survives into tokens and positions — which matters the moment you want to print a report that quotes the source. DATALINES pushes its own lexer mode, so inline data is never mis-tokenized as code. And a real client export once arrived carrying U+FFFD replacement characters; the lexer has handled that since release 1.5.1.

Most vendor pages have one tier and call it “supported”. SAS does not permit that, because the honest answer differs by construct. Here is the whole surface, sorted by how much structure you actually get.

The twenty-three procedures

On versions we would rather be exact than impressive. There is no SAS standard to conform to: SAS is proprietary and the vendor documentation is the specification, so the engine is modeled on the documented SAS 9.4 language. The language is strongly backward compatible, which means the useful question is not “which release” but “which procedures does this shop actually use”. Run grep -io '^ *proc [a-z]*' over your estate, count the results, and you will know in ten minutes whether the twenty-three cover you.

This is a fair sample of a production SAS program: a macro whose body is not valid SAS on its own, wrapped around a PROC SQL query whose shape is decided at run time. Every construct marked below is exercised by a test in the suite.

%macro extract(region=, months=12);
   %let cutoff = %sysfunc(intnx(month, %sysfunc(today()), -&months., E), date9.);
   %let n = 3;
   %do i = 1 %to &n.;
      %let tbl&i. = sales_&region._&i.;
   %end;

   proc sql;
      create table work.summary_&region. as
      select  t.customer_id,
              sum(t.amount) as total,
              count(*)      as n_orders
      from    connection to oracle
              (select customer_id, amount from ORDERS where dt >= to_date('&cutoff.'))
      %do i = 1 %to &n.;
         union all select customer_id, amount from &&tbl&i.
      %end;
      group by t.customer_id
      having calculated total > 0;
   quit;
%mend extract;

A jar, the documents that explain the tree it produces, a documentation site, and a person to write to. No SAS installation, no server connection, no code leaving your network.

On the Java or Python pages we would send you to the free parser and mean it. Here there is nothing to send you to, and pretending otherwise would be the easiest claim on this page to check.

The method behind the work has a name: read the Chisel Method for how we make parser work estimable, or Parsers and transpilers for the three ways into it.

Six things we would rather tell you now than have you find in week three.