# regression tests for the POSIX grep utilitiy

export LC_ALL=C

KEEP "*.[pd]at"

function DATA

{

typeset f

integer i

typeset -i8 n

for f

do test -f $f && continue

case $f in

big.dat)for ((i = 0; i <= 10000; i++))

do print $i

done

;;

chars.dat)

for ((n = 1; n < 256; n++))

do if ((n != 10))

then eval c=\$\'\\${n#8#}\'

print -r -- "$c"

fi

done

;;

g1.dat) cat <<'!'

.xxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

!

;;

g4.dat) cat <<'!'

1 ZIPPORI, Israel

/usr/spool/ap/88/07/15/a0471: Israel-MonaLisa

1 ZERIFIN, Israel

/usr/spool/ap/88/05/17/a0823: Israel-Baez

1 ZEPHYRHILLS, Fla.

/usr/spool/ap/88/04/27/a0963: HelicopterEscape

1 ZENICA, Yugoslavia

/usr/spool/ap/88/07/13/a0814: Yugoslavia

1 ZAP, N.D.

/usr/spool/ap/88/03/13/a0776: CoalStrike

1 ZAMBRANO, Honduras

/usr/spool/ap/88/03/24/a0512: Honduras-Soldiers

1 ZACHARY, La.

/usr/spool/ap/88/04/05/a0745: Brites

1 YUCCA VALLEY, Calif.

/usr/spool/ap/88/08/26/a0624: BRF--SoCalQuake

1 YORKVILLE, Ill.

/usr/spool/ap/88/08/31/a0687: ReformedStudent

1 YORK, Maine

/usr/spool/ap/88/10/09/a0772: SeaSearches

1 YENAN, China

/usr/spool/ap/88/02/24/a0419: China-Yenan

1 YELOWSTONE NATIONAL PARK, Wyo.

/usr/spool/ap/88/09/15/a0792: Dukakis

1 YEADON, Pa.

/usr/spool/ap/88/05/14/a0689: Brites

1 YATTA, Occupied West Bank

/usr/spool/ap/88/10/29/a0417: Israel-Undercover

1 YASSIHOYUK, Turkey

/usr/spool/ap/88/09/09/a0423: MidasTomb

1 YAPHANK, N.Y.

/usr/spool/ap/88/05/10/a0686: Brites

1 YAMOUSSOUKRO, Ivory Coast

/usr/spool/ap/88/09/25/a0635: Africa-UN

!

;;

g5.dat) cat <<'!'

com 1037117850

com -113451303

com -253844186

com -591640727

com -192085666

com 875206176

com -688908411

com 116220732

com -815364609

com 393021566

com -197586762

com -979497332

com 580876342

com 857752251

com -282427433

com 440265772

com 903702654

com 377371259

com -790446649

com -407893353

com 601447097

com 311585929

com -990601410

com 273028495

com -421520583

com -620551282

com -768217422

com 722547274

com 313902943

com -729597068

com 306062132

com 773754585

com -678639313

com -345701409

com -290065002

com -974307104

com 1047184566

com 210828681

com 108982822

com 68031245

com -1047141482

com 227569703

com -530798398

com -822779044

com 440691738

com 624275796

com 843073732

com 228971433

com 258376249

com -308161170

com -995590232

com 856677272

com 132296249

com 633658628

com 25935234

com -1063085400

com 148654970

com -824172925

com -659459669

com 196909720

com -393774825

com 736667556

com 674673107

com 1007653812

com -261383312

com 263123663

com -946595190

com -396442

com -506832213

com 149702652

com -937852087

com -500943193

com -288026147

com -653808189

com 801559288

com -653395420

com -405217270

com -749529781

com 965720542

com 396739912

com 250804267

com 1058925867

com 121948720

com 129329115

com -503214654

com 758365427

com -569717820

com 191932303

com 1041195498

com -178872661

com 719024931

com 389365053

com -695930677

com -720993320

com 659352079

com -445359373

com -405581235

com -495515453

com -861910553

com -35979929

com 1056535300

com 188042833

com -220408267

com -766533595

com 718865736

com -614647852

com 637296265

com 607439702

com -996163547

com -354301843

com 187216170

com -524246340

com 165453004

com -922340816

com -392313676

com 933400965

com -357455062

com 876069330

com 619850004

com 34785127

com -204461692

com -1021142281

com 261505948

com 713447396

com -264424205

com -757624021

com -697742264

com -67902535

com 813305897

com 611213298

com 810009586

com -351033158

com -757580248

com -754765998

com 96550293

com 818835421

com 625544984

com -301866740

com -363940120

com 196940655

com -990799410

com -650380493

com -823008037

com 229313079

com 480371766

com 934025272

com -223072319

com 481173087

com 101019846

com -954562179

com -267806909

com 1004678320

com 267997081

com -691653747

com 821221633

com 11472834

com -852175935

com 145665121

com 636788309

com -38553220

com -594562227

com 893269786

com -515632420

com -504118519

com -795555924

com -896489800

com 381679431

com 451163332

com 945690716

com -474968721

com -181646048

com -477705084

com 179336691

com 944752723

com -106013482

com 295161509

com -1026918852

com -1008494120

com -368542058

com 6153383

com 269567191

com 221084616

com -1015567145

com 326752359

com -253427460

com -990923267

com -745673545

com -772482393

com 12783572

com 695087221

com 782623860

com 239322275

com -920492686

com -461345191

com 304590436

com -141131273

com -1024267294

com -289620401

com -495626460

com 948528218

com 87006518

com 395454722

com 577392034

com 814343604

com 497169207

com -567127307

com 764271483

com -866721319

com -387005272

com -501938820

com 567881079

com 453665993

com -790328887

com 390097892

com 141055035

com 990378016

com -730626518

com 732985962

com -286073373

com 22747858

com -326949321

com 1022500944

com 905679100

com -448120658

com 363118089

com 819248817

com -691522154

com 59581781

com -450349154

com -729823626

com 646115018

com -65922779

com -373376656

com 1004572328

com 466654801

com 128208377

com 958497476

com 22952708

com -822443770

com 689913706

com 726815914

com -128674860

com 779809535

com -316931412

com -1025891272

com 4804418

com 309313283

com 536922264

com -876904372

com 700688221

com 186984467

com 791829735

com 237211732

com 515173384

com -911728294

com -783718602

com 160345621

com -716237348

com -185346360

com -634816499

com -845917397

com 460946577

com 777785415

com -579223277

com -127944050

com -351414763

com -1006508563

com 934284417

com -414601720

com -328845777

com 701421432

com -680992028

com 444048798

com -277796693

com -1014985030

com 213438258

com -863232710

com -236044310

com -593324426

com -269273068

com -163992668

com -1026411186

com 537134594

com 321391768

com -872419201

com -795875760

com 373186979

com 616631783

com -567696334

com 554407297

com 723377442

com 1062001538

com 152160308

com 43834651

com 902450760

com -390697289

com 431114551

com -851289267

com 454377388

com 470923853

com -950885734

com -313255930

com -388083168

com -267037738

com -601696282

com -848277038

com 745209391

com -423687675

com 646585818

com -613632730

com 151442994

com 868010020

com -589969477

com 756495308

com 482257575

com -546245706

com -56416295

com -922688644

com -927591869

com -193091648

com 505183574

com -696294953

com -676843648

com -458233039

com 1016060900

com 235279194

com 255314418

com 821562352

com 677435672

com -137977226

com -296008805

com -284837634

com 992052324

com 848130900

com -612135722

com -242663012

com 40910582

com -633235255

!

;;

g6.pat) cat <<'!'

^Aconv\(

^Cconv\(

^Uconv\(

^bconv\(

^begrewrite\(

^bi_bread\(

^bi_close\(

^bi_open\(

^bi_rand\(

^bi_read\(

^bi_write\(

^bltinval\(

^compattype\(

^compile\(

^concat\(

^constants\(

^curproc\(

^dclformals\(

^declare\(

^decref\(

^dump\(

^dupgen\(

^dupnode\(

^econv\(

^elemrewr\(

^emalloc\(

^emit\(

^emitconst\(

^emitspace\(

^eqtype\(

^erealloc\(

^errflush\(

^error\(

^etypeof\(

^etypeoft\(

^execute\(

^exits\(

^fileline\(

^freenode\(

^gen\(

^genfreeauto\(

^halt\(

^here\(

^iconv\(

^idnode\(

^idump\(

^istart\(

^istopscope\(

^length\(

^lerror\(

^lexinit\(

^lfileline\(

^lgen\(

^lookup\(

^mconv\(

^mk\(

^mkcheck\(

^nargs\(

^nconv\(

^ndump\(

^new\(

^newc\(

^newfile\(

^newi\(

^newl\(

^panic\(

^patch\(

^popscope\(

^pprint\(

^printable\(

^processes\(

^procinit\(

^proglocals\(

^pushscope\(

^pushval\(

^recrewrite\(

^rerror\(

^rpanic\(

^run\(

^scopedecrefgen\(

^setprog\(

^tconv\(

^topofstack\(

^topscope\(

^type\(

^typeinit\(

^typeof\(

^typeoftid\(

^warn\(

^yylex\(

^yyparse\(

!

;;

g8.dat) cat <<'!'

b

ba

!

;;

g12.dat)cat <<'!'

AAA n

AAAS n

Aaron n

AAU n

AAUP d

AAUW d

ABA n

Ababa pc

aback d

abacus n

abaft d

abalone n

abandon v,er,va

abase v,er,va

abash v,er,va

abate v,er,va

abattoir n

abbe n

abbess n

abbey n

abbot n

Abbott n

abbreviate v,ion

abc n

abdicate v,ion,va

abdomen n

abdominal a

abduct v,ion

Abe pc

abeam d

abed d

Abel pc

Abelian pc

Abelson n

Aberdeen pc

Abernathy n

aberrant n,a

aberrate v,ion

abet v,va,ms

abettor n

abeyant a

abhor v,er,ms

abhorrent a

abide v,er

Abidjan pc

Abigail pc

abject a,ion

abjuration n

abjure v,er

ablate v,ion

ablaut n

ablaze d

able v,a,comp,va

abloom d

ablution n

ABM n

abnegate v,ion

Abner pc

abnormal n,a

aboard d

abode n

abolish v,er,va

abolition n,na

abolitionary n

abominable a

abominate v,ion

aboriginal n,a

aborigine n

aborning d

abort v,er,ion

abortifacient n

abound vi

about d,nopref

above d

aboveboard d

aboveground d

abovementioned d

abracadabra n

abrade v,er,va

Abraham n

Abram n

Abramson n

abrasion n,na

abreact v,ion

abreast d

abridge v,er,va

abridgment n

abroad d

abrogate v,ion

abrupt a,ion

abscess n,v

abscissa n

abscissae d

abscission n

abscond v,er

absent v,a

absentee n

absenteeism n

absentia n

absentminded a

absinthe n

absolute n,a,na

absolution n

absolve v,er

absorb v,er,va

absorbent a

absorption n,na

abstain v,er

abstemious a

abstention n

abstinent a

abstract n,v,a,er,ion

abstruse a

absurd a,na

abuilding d

abundant a

abuse n,v,er,va

abusive a

abut v,er,va,ms

abysmal a

abyss n

abyssal a

Abyssinia pc

AC d

acacia n

academe pc,na

academia pc

academic n,na

academician n

academy n

Acadia pc

acanthus n

Acapulco pc

accede v

accelerando d

accelerate v,ion

accelerometer n

accent n,v,na

accentual a

accentuate v,ion

accept v,er,va

acceptant a

acceptor n

access n,v

accessible a,in

accession n,v,na

accessory n,na

accident n,a

accidental a

accipiter n

acclaim n,v,er

acclamation n

acclimate n,v,ion

acclimatize v,er,ion

accolade n

accommodate v,ion

accompaniment n

accompanist n

accompany v,na

accompli d

accomplice n

accomplish v,er,va

accord n,v

accordant a

accordion n,na

accost v

account n,v,va

accountant n,a,na

Accra pc

accredit v,va

accreditation n

accrete v

accretion n,na

accretionary n

accrual a

accrue v,va

acculturate v,ion

accumulate v,ion

accuracy n,in

accurate a,in

accursed a

accusation n,na

accusatory d

accuse v,er

accustom v

ace n,v,nopref

acentric d

acerb a

acerbic a

acetaldehyde n

acetate n

acetic d

acetone n

acetyl n,na

acetylene n

ache n,v,er

achieve v,er,va

Achilles pc

aching a

achondrite n,na

achromatic a

acid n,a

acidic d

acidify v,er,ion

acidimeter n,na

acidulous a

Ackerman n

Ackley n

acknowledge v,va

acknowledgeable d

ACLU pc

ACM pc

acme pc

acne n

acolyte n

acorn n

acoustic n,a

acoustician n

acoustoelectric a,na

acoustooptic n,a,na

acquaint v

acquaintance n,na

acquiesce v

acquiescent a

acquire v,va

acquisition n,na

acquit v,ms

acquittal n

acre n

acreage pc

acrid a

acrimonious a

acrimony n

acrobat n

acrobatic n,na

acrolein n

acronym n

acrophobia n

acropolis n

across d

acrostic a

acrylate n

acrylic n

ACS pc

act n,v,ion,va

Actaeon pc

actinic na

actinide n

actinium n

actinometer n,na

activate v,ion,in

activism pc

Acton n

actress n

actual a,na

actuarial a

actuary n

actuate v,ion

acuity n

acumen n

acupuncture n

acute a

acyclic a

acyl n

ad n

Ada pc

adage n

adagio n

Adair pc

Adam pc

adamant a

adamantine a

Adams n

Adamson n

adapt v,er,ion,va

adaptation n,na

adaptive a

adaptor n

add v,er,va

addend n

addenda pc

addendum pc

addict n,v,ion

Addis pc

Addison n

addition n,na

addle v

address n,v,er,na,va

addressee n

Addressograph pc

adduce v,er,va

Adelaide pc

Adele pc

Adelia pc

Aden pc

adenoid n,na

adenoma n

adenosine n

adept n,a

adequacy n,in

adequate a,in

adhere v

adherent n,a

adhesion n,na

adiabatic n

adieu n

adipose a

Adirondack n

adjacent a

adjectival a

adjective n,a

adjoin v

adjoint n

adjourn v,va

adjudge v

adjudicate v,ion

adjunct n,a,ion

adjuration n

adjure v

adjust v,er,va

adjutant n,a

Adkins n

Adler n

administer v

administrable d

administrate v,ion

administratrix d

admiral n

admiralty n

admiration n

admire v,er,va

admissible a,in

admission n,na

admit v,er,ms

admittance n

admix v

admixture n

admonish v,er,va

admonition n

admonitory a

ado d,nopref

adobe n,er

adolescent n,a

Adolph pc

Adolphus pc

Adonis pc

adopt v,er,ion,va

adoration n

adore v,er,va

adorn v,er,va

adrenal n,a

adrenaline n

Adrian pc

Adriatic pc

Adrienne pc

adrift d

adroit a,comp

adsorb v,va

adsorbate n

adsorbent n

adsorption n,na

adulate v,ion

adult n,a

adulterant n

adulterate v,ion

adulterer n

adulteress n

adulterous a

adultery n

adumbrate v,ion

advance v,er,va

advantage n,v

advantageous a

advection n,na

advent n,na

adventitial a

adventitious a

adventure n,v,er,na

adventuresome a

adventuress n

adventurous a

adverb n

adverbial a

adversary n,a

adverse a

advert n,v

advertent a,in

advertise v,er,va

advice pc

advise v,er,va

advisee n

advisor n,y

advocacy n

advocate v,ion

adz n

adze n

Aegean pc

aegis n

Aeneas pc

Aeneid pc

aeolian d

Aeolus pc

aerate v,a,ion,va

aerial n,a,na

aerie n

Aerobacter pc

aerobatic n

aerobic n,na

aerodynamic n,na

aeronautic n,na

aerosol n,na

aerospace n

Aeschylus pc

aesthete n

aesthetic n,na

afar d

affable a,va

affair n

affect n,v,ion,va

affectation n

affectionate a

afferent a

affiance n,v

affidavit n

affiliate n,v,ion

affine n,ed,a

affinity n

affirm v,va

affirmation n,na

affix v,va

affixation n

afflatus n

afflict v,er,ion

affluent n,a

afford v,va

afforest v

afforestation n

affray n,v

affright n,v

affront n,v

afghan n

Afghanistan pc

aficionado n

afield d

afire d

AFL d

aflame d

afloat d

aflutter d

afoot d

aforementioned d

aforesaid d

aforethought d

afoul d

afraid d

afresh d

Africa pc

Afrikaner pc

afro n

aft er

afterbirth n

afterburner n

afterdeck n

aftereffect n

afterglow n

afterimage n

afterlife n

aftermath pc

aftermost pc

afternoon n

aftershock n

aftertaste n

afterthought n

afterward n

afterworld n

again d,nopref

against d,nopref

Agamemnon pc

agamic a

agape d

agar n,nopref

agate n,nopref

Agatha pc

agave n

age n,v

Agee n

agelong d

agenda pc,na

agendum pc

agent n,a

agglomerate v,ion

agglutinate v,ion

agglutinin n

aggrade v

aggravate v,ion

aggregate n,v,a,ion

aggression n,na

aggressor n

aggrieve v

aghast d

agile a

agitate v,ion

agitprop pc

agleam d

agley d

aglitter d

aglow d

Agnes pc

Agnew n

agnomen n

agnostic n,na

ago d,nopref

agog d

agon n

agone na

agony n

agora n

agoraphobia n

agouti n

agrarian n,na

agree v,va

agreeable a

agreeing d

agribusiness n

Agricola pc

agricultural a,na

agriculture n,na

agrimony n

agronomist n

agronomy n,na

aground d

ague n

Agway pc

ah n,nopref

Ahab pc

ahead d

ahem d

Ahmadabad pc

ahoy d

aid n,v,er,nopref

Aida pc

aide n,nopref

Aiken pc

ail n,v,nopref

ailanthus pc

Aileen pc

aileron n

ailment n

aim n,v

ain't d

Ainu n

air n,v,man,y

airborne d

airbrush n,v

Airbus n

aircraft n

airdrop n,v,va

Aires pc

airfare n

airfield n

airflow n

airfoil n

airframe n

airhead n

airlift n,v

airline n,er

airlock n

airmail n,v

airmass n

airpark n

airport n

airscrew n

airsick a

airspace n

airspeed n

!

;;

g6.dat) cat <<'!'

#include "alloc.h"

#include <libc.h>

char *

emalloc(unsigned long n)

{

char *p;

p=malloc((unsigned)n);

if(p==0){

warn("out of memory; exiting");

exits("out of memory");

}

return p;

}

char *

erealloc(char *p, unsigned long n)

{

p=realloc(p, (unsigned)n);

if(p==0){

warn("out of memory; exiting");

exits("out of memory");

}

return p;

}

#include "alloc.h"

#include "word.h"

#include "store.h"

#include "comm.h"

#include <libc.h>

/*

* Push constants

*/

ipushconst(Proc *proc)

{

*proc->sp++=(SWord)*++proc->pc;

return 1;

}

ipush_2(Proc *proc)

{

*proc->sp++=-2;

return 1;

}

ipush_1(Proc *proc)

{

*proc->sp++=-1;

return 1;

}

ipush0(Proc *proc)

{

*proc->sp++=0;

return 1;

}

ipush1(Proc *proc)

{

*proc->sp++=1;

return 1;

}

ipush2(Proc *proc)

{

*proc->sp++=2;

return 1;

}

ipush3(Proc *proc)

{

*proc->sp++=3;

return 1;

}

ipush4(Proc *proc)

{

*proc->sp++=4;

return 1;

}

ipush5(Proc *proc)

{

*proc->sp++=5;

return 1;

}

ipush6(Proc *proc)

{

*proc->sp++=6;

return 1;

}

ipush7(Proc *proc)

{

*proc->sp++=7;

return 1;

}

ipush8(Proc *proc)

{

*proc->sp++=8;

return 1;

}

ipush9(Proc *proc)

{

*proc->sp++=9;

return 1;

}

ipush10(Proc *proc)

{

*proc->sp++=10;

return 1;

}

/*

* Binary operators

*/

ige(Proc *proc)

{

--proc->sp;

proc->sp[-1]=proc->sp[-1]>=proc->sp[0];

return 1;

}

ile(Proc *proc)

{

--proc->sp;

proc->sp[-1]=proc->sp[-1]<=proc->sp[0];

return 1;

}

ine(Proc *proc)

{

--proc->sp;

proc->sp[-1]=proc->sp[-1]!=proc->sp[0];

return 1;

}

ieq(Proc *proc)

{

--proc->sp;

proc->sp[-1]=proc->sp[-1]==proc->sp[0];

return 1;

}

igt(Proc *proc)

{

--proc->sp;

proc->sp[-1]=proc->sp[-1]>proc->sp[0];

return 1;

}

ilt(Proc *proc)

{

--proc->sp;

proc->sp[-1]=proc->sp[-1]<proc->sp[0];

return 1;

}

iadd(Proc *proc)

{

--proc->sp;

proc->sp[-1]+=proc->sp[0];

return 1;

}

isub(Proc *proc)

{

--proc->sp;

proc->sp[-1]-=proc->sp[0];

return 1;

}

imul(Proc *proc)

{

long l0, l1, l;

--proc->sp;

l0=proc->sp[-1];

l1=proc->sp[0];

l=l0*l1;

if(l1 && l/l1 != l0)

rerror("product overflow");

proc->sp[-1]=l;

return 1;

}

idiv(Proc *proc)

{

--proc->sp;

if(proc->sp[0]==0)

rerror("zero divide");

proc->sp[-1]/=proc->sp[0];

return 1;

}

imod(Proc *proc)

{

--proc->sp;

if(proc->sp[0]==0)

rerror("zero modulo");

proc->sp[-1]%=proc->sp[0];

return 1;

}

iand(Proc *proc)

{

--proc->sp;

proc->sp[-1]&=proc->sp[0];

return 1;

}

ior(Proc *proc)

{

--proc->sp;

proc->sp[-1]|=proc->sp[0];

return 1;

}

ixor(Proc *proc)

{

--proc->sp;

proc->sp[-1]^=proc->sp[0];

return 1;

}

ilsh(Proc *proc)

{

--proc->sp;

proc->sp[-1]<<=proc->sp[0];

return 1;

}

irsh(Proc *proc)

{

--proc->sp;

proc->sp[-1]>>=proc->sp[0];

return 1;

}

imax(Proc *proc)

{

SWord l;

l=*--proc->sp;

if(l>proc->sp[-1])

proc->sp[-1]=l;

return 1;

}

/*

* Unary operators

*/

ineg(Proc *proc)

{

proc->sp[-1]=-proc->sp[-1];

return 1;

}

inot(Proc *proc)

{

proc->sp[-1]=~proc->sp[-1];

return 1;

}

ilnot(Proc *proc)

{

proc->sp[-1]=!proc->sp[-1];

return 1;

}

iref(Proc *proc)

{

Store *s=(Store *)*--proc->sp;

*proc->sp++=s->ref-1;

decref(&s);

return 1;

}

ilen(Proc *proc)

{

Store *s=(Store *)*--proc->sp;

*proc->sp++=s->len;

decref(&s);

return 1;

}

/*

* String comparison: put value of strcmp() on stack

*/

istrcmp(Proc *proc)

{

int cmp;

Store *s1, *s2;

s1=(Store *)proc->sp[-2];

s2=(Store *)proc->sp[-1];

cmp=strcmp((char *)s1->data, (char *)s2->data);

decref(&s1);

decref(&s2);

proc->sp--;

proc->sp[-1]=cmp;

return 1;

}

/*

* Print

*/

iprintint(Proc *proc)

{

pprint(proc, "%ld", *--proc->sp);

return 1;

}

iprintnewline(Proc *proc)

{

pprint(proc, "\n");

return 1;

}

iprintblank(Proc *proc)

{

pprint(proc, " ");

return 1;

}

iprintunit(Proc *proc)

{

pprint(proc, "(unit)");

return 1;

}

iprintchar(Proc *proc)

{

pprint(proc, "%c", *--proc->sp);

return 1;

}

pprint(proc, fmt, a, b, c, d, e)

Proc *proc;

char *fmt;

{

char buf[1024];

long n;

n=sprint(buf, fmt, a, b, c, d, e);

if(proc->prbuf==0){

proc->prbuf=emalloc(64+n);

proc->maxprbuf=64+n;

proc->nprbuf=0;

}

if(n+proc->nprbuf+1>proc->maxprbuf){

proc->prbuf=erealloc(proc->prbuf, proc->maxprbuf+64+n);

proc->maxprbuf+=64+n;

}

strcpy(proc->prbuf+proc->nprbuf, buf);

proc->nprbuf+=n;

}

/*

* Stack management

*/

ipop(Proc *proc)

{

--proc->sp;

return 1;

}

ipopptr(Proc *proc)

{

decref((Store **)(proc->sp-1));

--proc->sp;

return 1;

}

idup(Proc *proc)

{

proc->sp++;

proc->sp[-1]=proc->sp[-2];

return 1;

}

idupptr(Proc *proc)

{

proc->sp++;

proc->sp[-1]=proc->sp[-2];

((Store *)(proc->sp[-1]))->ref++;

return 1;

}

#include "node.h"

#include "symbol.h"

#include "alloc.h"

#include "word.h"

#include "store.h"

#include "comm.h"

#include "inst.h"

#include <libc.h>

#define FNS

#include "lib.h"

#undef FNS

#define C 0x40000000

#define I 0x20000000

#define F 0x10000000

#define M(x) ((x)&~(C|I|F))

long call0[]={ /* plain function, 0 arguments */

I+Ipushfp, C+0, F, I+Iret, C+0*WS, I+Idone, 0

};

long call1[]={ /* plain function, 1 argument */

I+Ipushfp, C+0, F, I+Iret, C+1*WS, I+Idone, 0

};

long call2[]={ /* plain function, 2 arguments */

I+Ipushfp, C+0, F, I+Iret, C+2*WS, I+Idone, 0

};

long call3[]={ /* plain function, 3 arguments */

I+Ipushfp, C+0, F, I+Iret, C+3*WS, I+Idone, 0

};

long call4[]={ /* plain function, 4 arguments */

I+Ipushfp, C+0, F, I+Iret, C+4*WS, I+Idone, 0

};

long call5[]={ /* plain function, 5 arguments */

I+Ipushfp, C+0, F, I+Iret, C+5*WS, I+Idone, 0

};

long call2_0[]={/* two-step function, 0 arguments */

I+Ipushfp, C+0, F+0, F+1, I+Iret, C+0*WS, I+Idone, 0

};

struct{

char *name;

int (*fn[3])();

int nargs;

long *template;

}bltin[]={

#include "lib.h"

0, {0, 0, 0}, 0, 0,

};

bltinlookup(char *s)

{

int i;

for(i=0; bltin[i].name; i++)

if(strcmp(s, bltin[i].name)==0)

return i;

error("%s not a builtin", s);

return -1;

}

long

bltinval(char *name, Node *t)

{

int i, nargs, len;

long *template, *p;

Store *s;

SWord *d;

if(t->o.t!=TProg)

error("builtin %s not a function", name);

i=bltinlookup(name);

nargs=bltin[i].nargs;

if(nargs!=length(t->l)) /* necessary but not sufficient */

error("wrong #args to builtin %s: %d (should be %d)", name, length(t->l), nargs);

template=bltin[i].template;

p=template;

for(len=0; *p; p++)

len++;

s=(Store *)emalloc(SHSZ+len*LWS);

s->ref=1;

s->type=Sprog;

s->sbits=0;

s->len=len;

d=s->data;

for(p=template; *p; p++)

if(*p&C)

*d++=(SWord)M(*p);

else if(*p&I)

*d++=(SWord)insttab[M(*p)].fp;

else if(*p&F)

*d++=(SWord)bltin[i].fn[M(*p)];

return (long)s;

}

Store *

mk(type, len)

{

Store *s;

if(type==Sstruct)

len++;

s=(Store *)emalloc(SHSZ+len*LWS);

s->ref=1;

s->type=type;

if(type==Sstruct){

s->sbits=1;

s->data[0]=0;

}else

s->sbits=0;

s->len=len;

return s;

}

#include "node.h"

#include "symbol.h"

#include "alloc.h"

#include "ydefs.h"

#include "word.h"

#include "store.h"

#include "comm.h"

#include "inst.h"

#include "errjmp.h"

#include <libc.h>

long resultloc;

long returnloc;

Node *formals;

long autooffset;

extern int bflag;

extern int cflag;

extern int nscope;

extern Node arychartype;

compile(n) /* called from parser only */

Node *n;

{

extern long autooffset;

Errjmp x;

n=constants(n);

if(cflag){

fileline();

fprint(2, "constants:\n");

dump(n, 0);

}

errsave(x);

if(errmark()){

autooffset=0;

freenode(n);

errrest(x);

errjmp();

}

istart();

gen(n, 0);

freenode(n);

errrest(x);

}

gen(Node *n, int retain)

{

int i;

if(n==0)

return;

switch(n->t){

case NArrayref:

arygen(n->l, n->r, 0, 0L);

if(!retain)

popgen(n->l->o.s->val->type->r);

return;

case NBecome:

if(n->l->t==NCall && !bflag){

callgen(n->l, Ibecome);

return;

}

gen(n->l, 1);

n=n->r;

if(n->o.t==TID)

n=typeoftid(n);

switch(n->o.t){

case TInt:

case TChar:

emit(Istoreauto);

emitconst(-LWS*(3+length(formals)));

break;

case TArray:

case TChan:

case TProg:

case TStruct:

emit(Istoreptrauto);

emitconst(-LWS*(3+length(formals)));

break;

case TUnit:

break;

default:

panic("can't compile %t become", n->o.t);

}

scopedecrefgen();

trlrgen();

return;

case NBegin:

callgen(n->l, Ibegin);

return;

case NCall:

callgen(n, Icall);

if(!retain)

popgen(etypeoft(n->l)->r);

return;

case NDecl:

case NDeclsc:

declare(n, 0, 0, 1);

return;

case NExpr:

switch(n->o.i){

case GE:

i=Ige;

Binop:

gen(n->l, 1);

gen(n->r, 1);

if(eqtype(etypeof(n->l), &arychartype)){

emit(Istrcmp);

constgen(0L);

}

emit(i);

Popit:

if(!retain)

emit(Ipop);

return;

case LE:

i=Ile;

goto Binop;

case NE:

i=Ine;

goto Binop;

case EQ:

i=Ieq;

goto Binop;

case '>':

i=Igt;

goto Binop;

case '<':

i=Ilt;

goto Binop;

case '+':

i=Iadd;

goto Binop;

case '-':

i=Isub;

goto Binop;

case '*':

i=Imul;

goto Binop;

case '/':

i=Idiv;

goto Binop;

case '%':

i=Imod;

goto Binop;

case '&':

i=Iand;

goto Binop;

case '|':

i=Ior;

goto Binop;

case '^':

i=Ixor;

goto Binop;

case LSH:

i=Ilsh;

goto Binop;

case RSH:

i=Irsh;

goto Binop;

case ANDAND:

condgen(n->l, n->r, Ijmptrue, Ijmpfalse, 0L, 1L, retain);

return;

case OROR:

condgen(n->l, n->r, Ijmpfalse, Ijmptrue, 1L, 0L, retain);

return;

case PRINT:

gen(n->l, 1);

printgen(n->l);

emit(Isprint);

if(!retain)

emit(Iprint);

return;

case SND:

gen(n->l, 1);

constgen((long)Cissnd);

emit(Icommset1);

emit(Icommcln1);

gen(n->r, 1);

if(isptrtype(etypeoft(n->l)->r))

emit(Isndptr);

else

emit(Isnd);

if(!retain)

popgen(etypeof(n));

return;

case RCV:

gen(n->l, 1);

constgen(0L); /* not Cissnd */

emit(Icommset1);

emit(Icommcln1);

return;

case '=':

gen(n->r, 1);

if(retain)

dupgen(etypeof(n->r), 1);

lgen(n->l);

return;

case LEN:

gen(n->l, 1);

emit(Ilen);

goto Popit;

case REF:

if(isptrtype(etypeof(n->l))){

gen(n->l, 1);

emit(Iref);

}else

constgen(1L);

goto Popit;

case DEF:

if(retain && n->l->t==NID && isinttype(etypeof(n->l))){

constgen(1L);

return;

}

/*

* don't really need to call lgen1, which will uniquify our

* array for us, but it does no harm, and it's easy.

*/

lgen1(n->l, Idefauto, Idef, Idefary);

goto Popit;

case UMINUS:

gen(n->l, 1);

emit(Ineg);

goto Popit;

case '~':

gen(n->l, 1);

emit(Inot);

goto Popit;

case '!':

gen(n->l, 1);

emit(Ilnot);

goto Popit;

case INC:

lgen1(n->l, Iincauto, Iinc, Iincary);

goto Popit;

case DEC:

lgen1(n->l, Idecauto, Idec, Idecary);

goto Popit;

default:

panic("can't compile %e expression", n->o.i);

}

case NExprlist:

/*

* This is an arg or element list; first is pushed last

*/

gen(n->r, 1);

gen(n->l, 1);

return;

case NID:

if(!retain)

return;

switch(typeof(n)->o.t){

case TInt:

case TChar:

if(n->o.s->val->isauto){

emit(Ipushauto);

emitconst(n->o.s->val->store.off);

}else{

emit(Ipush);

emitconst((long)&n->o.s->val->store.l);

}

return;

case TProg:

case TArray:

case TChan:

case TStruct:

if(n->o.s->val->isauto){

emit(Ipushptrauto);

emitconst(n->o.s->val->store.off);

}else{

emit(Ipushptr);

emitconst((long)&n->o.s->val->store.l);

}

return;

case TUnit:

if(retain)

constgen(0L);

return;

case TType:

lerror(n, "attempt to evaluate type variable %m", n);

default:

panic("can't compile type %t", n->o.s->val->type->o.t);

}

case NIf:

ifgen(n);

return;

case NList:

gen(n->l, 0);

gen(n->r, 0);

return;

case NLoop:

loopgen(n);

return;

case NMk:

mkgen(n->l, n->r);

return;

case NNum:

if(retain)

constgen(n->o.l);

return;

case NProg:

if(retain)

proggen(n->l, n->r);

return;

case NResult:

gen(n->l, 1);

emit(Ijmp);

emitconst((long)(resultloc-here()-1)*WS);

return;

case NScope:

pushscope();

if(nscope==1){

int nauto;

autooffset=0;

emit(Ipushfp);

nauto=here();

emitconst(0L);

gen(n->l, 0);

patch((int)nauto, autooffset);

}else

gen(n->l, 0);

scopedecrefgen();

popscope();

return;

case NSelect:

selgen(n->l);

return;

case NSmash:{

Value *vl, *vr;

vl=n->l->o.s->val;

vr=n->r->o.s->val;

if(vr->type->o.t==TType){

freenode(vl->type);

vl->type=dupnode(vr->type);

return;

}

gen(n->r, 1);

/*

* Free old values; tricky: push as int, pop as ptr

*/

if(isptrtype(vl->type)){

if(vl->isauto){

emit(Ipushauto);

emitconst(vl->store.off);

}else{

emit(Ipush);

emitconst((long)&vl->store.l);

}

emit(Ipopptr);

}

if(vl->isauto){

emit(Istoreauto);

emitconst(vl->store.l);

return;

}

emit(Istore);

emitconst((long)&vl->store.l);

return;

}

case NString:

if(retain){

Store *s;

s=(Store *)emalloc(SHSZ+strlen(n->o.c)+1);

strcpy((char *)(s->data), n->o.c);

s->ref=1;

s->len=strlen(n->o.c);

s->type=Sarychar;

emit(Ipushdata);

emitconst((long)s);

}

return;

case NStructref:

arygen(n->l, n->r, 1, n->o.l);

return;

case NSwitch:

switchgen(n->l, n->r);

return;

case NUnit:

if(retain)

constgen(0L);

return;

case NVal:

valgen(n->l);

if(!retain)

popgen(n->o.n);

return;

}

panic("can't compile node %n", n->t);

return;

}

arygen(Node *a, Node *i, int isstr, long off)

{

int ptr, ischar;

if(isstr){

ptr=isptrtype(i);

constgen(off);

ischar=0;

}else{

Node *t=etypeoft(a)->r;

ptr=isptrtype(t);

gen(i, 1);

ischar=t->o.t==TChar;

}

if(a->t!=NID){

gen(a, 1);

emit(ptr? Ipusharyptrexpr :

(ischar? Ipusharycharexpr :Ipusharyexpr));

}else if(a->o.s->val->isauto){

emit(ptr? Ipusharyptrauto :

(ischar? Ipusharycharauto :Ipusharyauto));

emitconst(a->o.s->val->store.off);

}else{

emit(ptr? Ipusharyptr :

(ischar? Ipusharychar :Ipushary));

emitconst((long)&a->o.s->val->store.l);

}

}

lgen(Node *n)

{

switch(n->t){

case NID:

switch(typeof(n)->o.t){

case TChar:

if(n->o.s->val->isauto){

emit(Istorecharauto);

emitconst(n->o.s->val->store.off);

return;

}

emit(Istorechar);

emitconst((long)&n->o.s->val->store.l);

return;

case TInt:

case TUnit:

if(n->o.s->val->isauto){

emit(Istoreauto);

emitconst(n->o.s->val->store.off);

return;

}

emit(Istore);

emitconst((long)&n->o.s->val->store.l);

return;

case TArray:

case TChan:

case TProg:

case TStruct:

if(n->o.s->val->isauto){

emit(Istoreptrauto);

emitconst(n->o.s->val->store.off);

return;

}

emit(Istoreptr);

emitconst((long)&n->o.s->val->store.l);

return;

default:

panic("lgen: ID type %t", n->o.s->val->type->o.t);

return;

}

case NArrayref:

gen(n->r, 1);

goto Genref;

case NStructref:

constgen(n->o.l);

Genref:

lgen1(n->l, Ipushuniqauto, Ipushuniq, Ipushuniqary);

emit(Istoreary);

return;

default:

panic("lgen: lvalue node %n", n->t);

}

}

/*

* n is a compound object about to be assigned into

*/

lgen1(Node *n, int Iauto, int Ivar, int Iary)

{

switch(n->t){

case NID:

if(n->o.s->val->isauto){

emit(Iauto);

emitconst(n->o.s->val->store.off);

return;

}

emit(Ivar);

emitconst((long)&n->o.s->val->store.l);

return;

case NArrayref:

gen(n->r, 1);

goto Genref;

case NStructref:

constgen(n->o.l);

Genref:

lgen1(n->l, Ipushuniqauto, Ipushuniq, Ipushuniqary);

emit(Iary);

return;

default:

panic("lgen1: lvalue node %n", n->t);

}

}

ifgen(Node *n)

{

int loc1, loc2;

gen(n->o.n, 1);

emit(Ijmpfalse);

loc1=here();

emit(0);

gen(n->l, 0);

if(n->r==0){

patch(loc1, (long)(here()-loc1-1)*WS);

return;

}

emit(Ijmp);

loc2=here();

emit(0);

patch(loc1, (long)(here()-loc1-1)*WS);

gen(n->r, 0);

patch(loc2, (long)(here()-loc2-1)*WS);

return;

}

valgen(Node *n)

{

int loc1, loc2;

int orl;

emit(Ijmp);

loc1=here();

emitconst(0L);

orl=resultloc;

resultloc=here();

emit(Ijmp);

loc2=here();

emitconst(0L);

patch(loc1, (long)(here()-loc1-1)*WS);

gen(n, 1);

emit(Ivalnoresult);

patch(loc2, (long)(here()-loc2-1)*WS);

resultloc=orl;

}

loopgen(Node *n)

{

int loc0, loc1, loc2;

if(n->o.i){ /* enter loop at top, so jump to body */

emit(Ijmp);

loc0=here();

emit(0);

}

gen(n->r->l, 0); /* left expr */

if(n->r->r){ /* jump to condition */

emit(Ijmp);

loc1=here();

emit(0);

}

if(n->o.i)

patch(loc0, (here()-loc0-1)*LWS);

loc2=here();

gen(n->l, 0); /* body */

gen(n->r->o.n, 0); /* right expr */

if(n->r->r){

patch(loc1, (here()-loc1-1)*LWS);

gen(n->r->r, 1);

emit(Ijmptrue);

}else

emit(Ijmp);

emitconst((loc2-here()-1)*LWS);

}

condgen(Node *l, Node *r, Inst i1, Inst i2, long t1, long t2, int retain)

{

int loc1, loc2, loc3;

gen(l, 1);

emit(i1);

loc1=here();

emit(0);

loc2=here();

if(retain)

constgen(t1);

emit(Ijmp);

loc3=here();

emit(0);

patch(loc1, (long)(here()-loc1-1)*WS);

gen(r, 1);

emit(i2);

emitconst((long)(loc2-here()-1)*WS);

if(retain)

constgen(t2);

patch(loc3, (long)(here()-loc3-1)*WS);

}

callgen(Node *n, int callinst)

{

Node *pt;

pt=etypeof(n->l);

/*

* Space for result

*/

constgen(0L);

/*

* Args

*/

gen(n->r, 1);

/*

* Call

*/

emit(Ipushconst);

if(n->l->t==NID)

emitconst((long)n->l->o.s->name);

else{

char buf[128];

char *p;

sprint(buf, "prog(){call on line %d}", n->line);

p=emalloc((unsigned long)strlen(buf)+1);

strcpy(p, buf);

emitconst((long)p);

}

gen(n->l, 1);

switch(callinst){

case Icall:

emit(Icall);

return;

case Ibegin:

constgen(LWS*(1+1+length(pt->l))); /* result+procname+args */

emit(Ibegin);

return;

case Ibecome:

constgen(LWS*(1+1+length(pt->l))); /* result+procname+args */

scopedecrefgen();

fdecrefgen(formals, -3L*WS);

emit(Ibecome);

if(formals)

emitconst(length(formals)*LWS);

else

emitconst(0L);

return;

}

panic("callgen");

}

selgen(Node *n)

{

int tbl, i;

long l;

int ends[200];

selchangen(n);

l=length(n);

constgen(l);

emit(Icommset);

emit(Icommcln);

if(l>(sizeof ends/sizeof ends[0]))

panic("selgen table too small");

tbl=here();

emitspace(l);

i=0;

seltblgen(n, tbl, ends, &i);

for(i=0; i<l; i++)

patch(ends[i], (long)(here()-ends[i]-1)*WS);

}

selchangen(Node *n)

{

long flags;

if(n->t==NList){

selchangen(n->l);

selchangen(n->r);

return;

}

if(n->t!=NCase)

panic("selchangen");

n=n->l->l;

if(n->o.t=='=')

n=n->r; /* n is now RCV or SND */

flags=0;

if(n->o.t==SND)

flags|=Cissnd;

n=n->l; /* n is now channel */

if(n->t==NArraycom){

flags|=Cisary;

n=n->l;

}else if(etypeoft(n)->o.t==TArray)

flags|=Cisary;

gen(n, 1);

constgen(flags);

}

seltblgen(Node *n, int tbl, int *ends, int *ip)

{

Node *c, *s, *l, *t;

if(n->t==NList){

/* chans are eval'ed from the top, so table is backwards */

seltblgen(n->r, tbl, ends, ip);

seltblgen(n->l, tbl, ends, ip);

return;

}

if(n->t!=NCase)

panic("seltblgen");

if(n->l->t==NList)

error("sorry, empty cases not implemented");

patch(tbl+*ip, (long)(here()-tbl)*WS);

c=n->l->l; /* communication */

s=n->r; /* statement */

l=0;

if(c->o.t=='='){

l=c->l; /* lvalue */

c=c->r;

}

if(c->o.t==SND){

gen(c->r, 1);

if(isptrtype(etypeoft(c->l)->r))

emit(Isndptr);

else

emit(Isnd);

}

c=c->l; /* channel expression */

/*

* The value is still on the stack; save it or toss it

*/

if(l)

lgen(l);

else if(c->t==NArraycom){

t=etypeoft(c->l)->r;

if(t->o.t==TID)

t=typeoftid(t);

popgen(t->r);

}else

popgen(etypeoft(c)->r);

if(c->t==NArraycom){ /* save array index */

if(c->r)

lgen(c->r);

else

emit(Ipop);

}

gen(s, 0);

emit(Ijmp);

ends[*ip]=here();

(*ip)++;

emitconst(0L);

}

switchgen(Node *s, Node *e)

{

int isptr, out;

isptr=isptrtype(etypeof(e));

gen(e, 1);

emit(Ijmp);

emitconst(2*LWS);

emit(Ijmp); /* each case jumps to here to get out */

out=here();

emitconst(0L);

switchgen1(s, isptr, out-1);

/* pop leftover value if no case matched */

if(isptr)

emit(Ipopptr);

else

emit(Ipop);

patch(out, (here()-out-1)*LWS);

}

switchgen1(Node *s, int isptr, int out)

{

Node *e;

int loc;

if(s->t==NList){

switchgen1(s->l, isptr, out);

switchgen1(s->r, isptr, out);

return;

}

if(s->t!=NCase)

panic("switchgen1");

if(s->r==0)

error("sorry; can't fold cases together yet");

if(s->l->t==NDefault)

loc=-1;

else{

e=s->l->l;

if(isptr){ /* string */

emit(Idupptr);

gen(e, 1);

emit(Istrcmp);

constgen(0L);

}else{

emit(Idup);

gen(e, 1);

}

emit(Ieq);

emit(Ijmpfalse);

loc=here();

emitconst(0L);

}

if(isptr)

emit(Ipopptr);

else

emit(Ipop);

gen(s->r, 0);

emit(Ijmp);

emitconst((out-here()-1)*LWS);

if(loc!=-1)

patch(loc, (here()-loc-1)*LWS);

}

popgen(Node *t)

{

if(isptrtype(t))

emit(Ipopptr);

else if(isinttype(t) || t->o.t==TUnit)

emit(Ipop);

else

panic("popgen %t\n", t->o.t);

}

genfreeauto(Symbol *s)

{

if(!s->val->isauto)

panic("genfreeauto");

if(isptrtype(s->val->type)){

emit(Idecrefauto);

emitconst(s->val->store.off);

}

}

printgen(Node *n)

{

Node *t;

if(n==0)

return;

if(n->t==NExprlist){

printgen(n->l);

printgen(n->r);

return;

}

t=etypeoft(n);

switch(t->o.t){

case TArray:

case TChan:

case TProg:

case TStruct:

emit(Iprintary);

break;

case TChar:

emit(Iprintchar);

break;

case TInt:

emit(Iprintint);

break;

case TUnit:

emit(Iprintunit);

break;

default:

panic("printgen: bad type %t", t->o.t);

}

}

proggen(Node *t, Node *n)

{

int or;

Node *of;

Errjmp s;

Store *p;

long len, loc;

long nauto, oao;

extern int (*prog[])();

oao=autooffset;

or=returnloc;

of=formals;

autooffset=0;

returnloc=0;

formals=t->l;

errsave(s);

if(errmark()){

returnloc=or;

formals=of;

autooffset=oao;

errrest(s);

errjmp();

}

loc=here();

pushscope();

dclformals(t->l);

autooffset=0;

emit(Ipushfp);

nauto=here();

emitconst(0L);

gen(n, 0);

trlrgen();

patch((int)nauto, autooffset);

popscope();

errrest(s);

autooffset=oao;

returnloc=or;

formals=of;

len=here()-loc+1;

p=(Store *)emalloc(SHSZ+len*LWS);

memcpy((char *)(p->data), (char *)(prog+loc), len*LWS);

p->ref=1;

p->len=len;

p->type=Sprog;

setprog(loc);

emit(Ipushdata);

emitconst((long)p);

}

trlrgen()

{

if(returnloc){

emit(Ijmp);

emitconst((long)(returnloc-here()-1)*WS);

return;

}

returnloc=here();

fdecrefgen(formals, -3L*WS);

emit(Iret);

if(formals)

emitconst(length(formals)*LWS);

else

emitconst(0L);

}

fdecrefgen(Node *types, long offset)

{

if(types==0)

return 0;

if(types->t==NList){

offset=fdecrefgen(types->l, offset);

return fdecrefgen(types->r, offset);

}

if(types->t!=NFormal)

panic("fdecrefgen");

types=types->r;

if(isptrtype(types)){

emit(Idecrefauto);

emitconst(offset);

}

return offset-WS;

}

dupgen(Node *t, int n)

{

while(n--)

emit(isptrtype(t)? Idupptr : Idup);

}

mkgen(Node *t, Node *v)

{

switch(t->o.t){

case TChar:

case TInt:

case TUnit:

if(v)

gen(v, 1);

else

constgen(0L);

return;

case TID:

mkgen(typeoftid(t), v);

return;

case TChan:

if(v)

gen(v, 1);

else{

constgen((long)(sizeof(Chan)-sizeof(Store)));

mallocgen(t);

}

return;

case TArray:

if(v==0){

gen(t->l, 1);

mallocgen(t);

return;

}

gen(v, 1);

if(v->t!=NExprlist && eqtype(t, etypeof(v)))

return;

if(v->t==NString)

constgen((long)strlen(v->o.c));

else

constgen((long)length(v));

emit(Idup);

if(t->l)

gen(t->l, 1);

else

constgen(0L);

emit(Imax);

mallocgen(t);

if(t->r->o.t==TChar){

if(v->t==NString)

emit(Imemcpychar);

else

emit(Imemcpycharint);

}else

emit(Imemcpy);

return;

case TProg:

if(v==0){

v=new(NProg, dupnode(t), (Node *)0, (Node *)0);

gen(v, 1);

freenode(v);

return;

}

gen(v, 1);

return;

case TStruct:

if(v==0){

mallocgen(t);

return;

}

gen(v, 1);

if(v->t!=NExprlist && eqtype(t, etypeof(v)))

return;

constgen((long)length(v));

mallocgen(t);

emit(Imemcpystruct);

return;

default:

panic("mkgen: bad type %t", t->o.t);

}

}

mallocgen(Node *t)

{

switch(t->o.t){

case TArray:

t=t->r;

if(t->o.t==TID)

t=typeoftid(t);

if(isptrtype(t)){

constgen((long)Saryptr);

emit(Imalloc);

}else if(t->o.t==TInt || t->o.t==TUnit){

constgen((long)Saryint);

emit(Imalloc);

}else if(t->o.t==TChar)

emit(Imallocarychar);

else

panic("mallocgen array of %t", t->o.t);

return;

case TStruct:{

int pos=0;

long bits=0;

t=t->l;

elembitsgen(t, &pos, &bits);

if(pos)

constgen(bits);

constgen((long)length(t));

emit(Imallocstruct);

return;

}

case TChan:

constgen((long)Schan);

emit(Imalloc);

return;

}

panic("mallocgen of %t", t->o.t);

}

elembitsgen(Node *t, int *pos, long *bits)

{

int i;

if(t->t==NList){

elembitsgen(t->l, pos, bits);

elembitsgen(t->r, pos, bits);

return;

}

if(t->t!=NElem)

panic("elembitsgen %n", t->t);

for(i=length(t); --i>=0; ){

if(*pos==BPW){

constgen(*bits);

*pos=0;

*bits=0;

}

if(isptrtype(t->r))

*bits|=1L<<*pos;

(*pos)++;

}

}

constgen(long l)

{

if(l<-2 || l>10){

emit(Ipushconst);

emitconst(l);

return;

};

switch((int)l){

case -2:

emit(Ipush_2);

break;

case -1:

emit(Ipush_1);

break;

case 0:

emit(Ipush0);

break;

case 1:

emit(Ipush1);

break;

case 2:

emit(Ipush2);

break;

case 3:

emit(Ipush3);

break;

case 4:

emit(Ipush4);

break;

case 5:

emit(Ipush5);

break;

case 6:

emit(Ipush6);

break;

case 7:

emit(Ipush7);

break;

case 8:

emit(Ipush8);

break;

case 9:

emit(Ipush9);

break;

case 10:

emit(Ipush10);

break;

default:

panic("constgen");

}

}

printable(Node *n)

{

if(n==0)

return 0;

switch(n->t){

case NExpr:

return n->o.t!='=';

case NArrayref:

case NCall:

case NID:

case NMk:

case NNum:

case NProg:

case NString:

case NStructref:

case NUnit:

case NVal:

return 1;

}

return 0;

}

#include "alloc.h"

#include "node.h"

#include "symbol.h"

#include "ydefs.h"

#include "word.h"

#include "store.h"

#include <libc.h>

Node *doconst();

extern int Cflag;

Node *

constants(Node *n)

{

if(n==0)

return 0;

if(Cflag)

return n;

switch(n->t){

case NArrayref:

if(isconst(n))

return doconst(n);

break;

case NArraycom:

break;

case NBecome:

break;

case NBegin:

break;

case NCall:

break;

case NCase:

break;

case NDecl:

n->r=constants(n->r);

n->o.n=constants(n->o.n);

declare(n, 0, 0, 0);

return n;

case NDeclsc:

break;

case NDefault:

return n;

case NElem:

n->r=constants(n->r);

return n;

case NExpr:

switch(n->o.i){

case GE:

case LE:

case NE:

case EQ:

case '>':

case '<':

case '+':

case '-':

case '*':

case '/':

case '%':

case '&':

case '|':

case '^':

case ANDAND:

case OROR:

case LSH:

case RSH:

if(isconst(n->l) && isconst(n->r))

return doconst(n);

break;

case DEF:

case REF:

case LEN:

case UMINUS:

case '~':

case '!':

if(isconst(n->l))

return doconst(n);

break;

case PRINT:

case RCV:

case SND:

case INC:

case DEC:

break;

case '=':

break;

default:

fprint(2, "can't const expression %e\n", n->o.i);

return n;

}

break;

case NExprlist:

break;

case NFormal:

n->r=constants(n->r);

return n;

case NLabel:

break;

case NID:

if(isconst(n))

return doconst(n);

break;

case NIf:

n->l=constants(n->l);

n->r=constants(n->r);

n->o.n=constants(n->o.n);

if(isconst(n->o.n)){

Node *m;

gen(n->o.n, 1);

execute();

if(topofstack()){

m=n->l;

n->l=0;

}else{

m=n->r;

n->r=0;

}

freenode(n);

return m;

}

return n;

case NList:

break;

case NLoop:

break;

case NLoopexpr:

n->o.n=constants(n->o.n);

break;

case NMk:

break;

case NNum:

return n;

case NProg:

pushscope();

dclformals(n->l->l);

n->r=constants(n->r);

popscope();

return n;

case NResult:

break;

case NScope:

pushscope();

n->l=constants(n->l);

popscope();

return n;

case NSelect:

break;

case NSmash:

return n;

case NString:

return n;

case NSwitch:

break;

case NStructref:

if(isconst(n))

return (n);

break;

case NType:

break;

case NUnit:

break;

case NVal:

if(isconst(n->l))

return doconst(n);

break;

default:

fprint(2, "can't const node %n\n", n->t);

return n;

}

n->l=constants(n->l);

n->r=constants(n->r);

return n;

}

isconst(Node *n)

{

if(n==0)

return 1;

switch(n->t){

case NArrayref:

return isconst(n->l) && isconst(n->r);

case NCall:

return 0;

case NExpr:

switch(n->o.i){

case GE:

case LE:

case NE:

case EQ:

case '>':

case '<':

case '+':

case '-':

case '*':

case '/':

case '%':

case '&':

case '|':

case '^':

case ANDAND:

case OROR:

case LSH:

case RSH:

return isconst(n->l) && isconst(n->r);

case DEF:

case LEN:

case UMINUS:

case '~':

case '!':

return isconst(n->l);

case REF:

case '=':

case RCV:

case SND:

case INC:

case DEC:

return 0;

}

fprint(2, "can't isconst expression %e", n->o.i);

return 0;

case NID:

return n->o.s->val->scope==0 && (n->o.s->val->stclass&SCconst);

case NIf:

return isconst(n->o.n) && isconst(n->l) && isconst(n->r);

case NList:

return 0;

case NLoop:

return 0;

case NNum:

return 1;

case NResult:

return isconst(n->l);

case NScope:

return isconst(n->l);

case NString:

return 1;

case NStructref:

return isconst(n->l);

case NVal:

return isconst(n->l);

case NUnit:

return 1;

}

fprint(2, "can't isconst node %n\n", n->t);

return 0;

}

Node *

doconst(Node *n)

{

Node *t;

if(n->t==NNum || n->t==NString || n->t==NUnit)

return n; /* already const */

t=etypeoft(n);

switch(t->o.t){

case TChar:

case TInt:

gen(n, 1);

freenode(n);

execute();

return new(NNum, (Node *)0, (Node *)0, (Node *)topofstack());

case TUnit:

return new(NUnit, (Node *)0, (Node *)0, (Node *)0);

case TArray:

if(t->r->o.t==TChar){

Store *s;

char *c;

gen(n, 1);

freenode(n);

execute();

s=(Store *)topofstack();

c=emalloc(s->len+1);

strncpy(c, (char *)s->data, (int)s->len);

return newc(NString, (Node *)0, (Node *)0, c);

}

return n;

}

return n;

}

#include "alloc.h"

#include "word.h"

#include "store.h"

#include "comm.h"

#include <libc.h>

extern int pflag;

/*

* Jumps

*/

ijmp(Proc *proc)

{

SWord l;

l=(SWord)*++proc->pc;

proc->pc+=l/WS;

return 1;

}

ijmpfalse(Proc *proc)

{

SWord l;

l=(SWord)*++proc->pc;

if(*--proc->sp==0)

proc->pc+=l/WS;

return 1;

}

ijmptrue(Proc *proc)

{

SWord l;

l=(SWord)*++proc->pc;

if(*--proc->sp!=0)

proc->pc+=l/WS;

return 1;

}

ivalnoresult(Proc *proc)

{

rerror("val produces no result");

return 0;

}

/*

* Progs

*

* Layout of a stack frame

*

* sp:

* automatics

* fp: old fp

* old pc

* symbol

* arg1

* arg2

* ...

* result

*/

iret(Proc *proc)

{

SWord nargs;

nargs=(SWord)(proc->pc[1]);

proc->sp=(SWord *)proc->fp+1;

proc->fp=(SWord *)*--proc->sp;

proc->pc=(int (**)())*--proc->sp;

proc->sp-=(sizeof(char *)+nargs)/WS;

if(proc->pc==0){

if(pflag)

fprint(2, "%d halts\n", proc->procnum);

halt(proc);

return 0;

}

return 1;

}

ibecome(Proc *proc)

{

int nargs;

int (**newpc)();

SWord oldfp, oldpc, *oldresultaddr, *newresultaddr;

Store *s;

nargs=*--proc->sp/LWS;

nargs+=2; /* includes result and sym; add pc, fp */

s=(Store *)*--proc->sp;

if(--(s->ref)==0)

rpanic("ibecome ref==0");

newpc=((int (**)())s->data);

oldfp=proc->fp[0];

oldpc=proc->fp[-1];

*proc->sp++=oldpc;

*proc->sp++=oldfp;

oldresultaddr=proc->fp-3-(long)(*++proc->pc)/LWS;

newresultaddr=proc->sp-nargs;

memcpy((char *)oldresultaddr, (char *)newresultaddr, LWS*nargs);

/* args in place. do the call by hand, jmp to pushfp */

proc->sp=oldresultaddr+(nargs-2);

*proc->sp++=oldpc;

proc->fp=(SWord *)oldfp;

proc->pc=newpc-1;

return 1;

}

ipushfp(Proc *proc)

{

int nauto;

*proc->sp=(SWord)proc->fp;

proc->fp=proc->sp++;

nauto=((SWord)*++proc->pc)/WS;

while(nauto--)

*proc->sp++=0;

if(proc->sp>=&proc->stack[NSTACK])

rerror("stack overflow");

return 1;

}

icall(Proc *proc)

{

int (**newpc)();

Store *s;

s=(Store *)*--proc->sp;

if(--(s->ref)==0)

rpanic("icall ref==0");

newpc=((int (**)())s->data);

*proc->sp++=(SWord)proc->pc;

proc->pc=newpc-1;

return 1;

}

#include "node.h"

#include "symbol.h"

#include "alloc.h"

#include "ydefs.h"

#include "word.h"

#include "store.h"

#include <libc.h>

extern int nscope;

declare(Node *n, int stclass, int dotypchk, int docomp)

{

extern int iflag;

if(n==0)

return;

if(n->t==NList){

declare(n->l, stclass, dotypchk, docomp);

declare(n->r, stclass, dotypchk, docomp);

return;

}

if(n->t==NDeclsc){

declare(n->l, n->o.i, dotypchk, docomp);

return;

}

if(dotypchk)

type(n->o.n, 0);

if(n->r==0){

if(n->o.n==0)

panic("declare: no type");

if(n->o.n->t==NMk && n->o.n->l==0)

lerror(n, "can't derive type in declaration");

n->r=dupnode(etypeof(n->o.n));

}

if(dotypchk){

type(n->r, 0);

if(n->o.n){

/*

* Make it a mk

*/

if(n->o.n->t!=NMk)

n->o.n=new(NMk, (Node *)0, n->o.n, (Node *)0);

/*

* Default type for mk

*/

if(n->o.n->l==0)

n->o.n->l=dupnode(n->r);

else if(!compattype(n->r, n->o.n->l))

lerror(n, "type clash in declaration (%t %t)\n",

n->r->o.t, etypeof(n->o.n)->o.t);

mkcheck(n->o.n->l, n->o.n->r);

}

}

if(docomp && n->o.n){

if(dotypchk) /* top level declaration */

n->o.n=constants(n->o.n);

gen(n->o.n, 1);

dupgen(n->r, length(n->l)-1);

}else

docomp=0;

dcl(n->l, n->r, stclass, n->o.n, docomp);

if(n->o.n && docomp && nscope==0){

if(iflag)

idump();

execute();

}

}

dcl(id, typ, stclass, val, docomp)

Node *id, *typ, *val;

{

if(id->t==NList){

dcl(id->l, typ, stclass, val, docomp);

dcl(id->r, typ, stclass, val, docomp);

return;

}

if(typ->o.t==TID && typ->l->o.s->val->type->o.t!=TType)

error("%m not a type", typ->l);

if(id->t!=NID)

panic("dcl not ID");

pushval(id->o.s, dupnode(typ));

if(stclass&SCbltin)

id->o.s->val->store.l=bltinval(id->o.s->name, typ);

if(docomp)

lgen(id);

id->o.s->val->stclass=stclass;

}

/*

* To compile this

* rec {

* x : chan of T = f(x,y);

* y : chan of T = g(x,y);

* };

* convert it to this

* x : chan of T = mk();

* y : chan of T = mk();

* x1 : chan of T = f(x,y);

* y1 : chan of T = g(x,y);

* x <- x1;

* y <- y1;

* toss x1, y1;

* where the operator x <- x1 means copy the representation of x1 into x.

*

* rec type T: struct of { t:T; };

*

* is handled similarly.

*/

Node *

op1(Node *n)

{

Node *m;

if(n->t==NDeclsc){

m=op1(n->l);

return newi(NDeclsc, m, (Node *)0, n->o.i);

}

if(n->r==0){

if(n->o.n && (n->o.n->t==NProg || (n->o.n->t==NMk && n->o.n->l)))

n->r=dupnode(n->o.n->l);

else

lerror(n, "can't deduce type for rec decl");

}else if(n->r->o.t==TType){

m=newi(NType, (Node *)0, (Node *)0, n->r->l->o.t);

m=new(NDecl, dupnode(n->l), m, (Node *)0);

return m;

}

m=new(NMk, dupnode(n->r), (Node *)0, (Node *)0);

m=new(NDecl, dupnode(n->l), dupnode(n->r), m);

return m;

}

Node *

op2(Node *n)

{

Node *m;

char s[Namesize+2];

if(n->t==NDeclsc){

m=op2(n->l);

return newi(NDeclsc, m, (Node *)0, n->o.i);

}

if(n->l->t==NList)

error("no identifier lists in rec's, please");

strcpy(s+1, n->l->o.s->name);

s[0]='*';

m=new(NDecl, idnode(lookup(s, ID)), dupnode(n->r), dupnode(n->o.n));

return m;

}

Node *

op3(Node *n)

{

Node *m;

char s[Namesize+2];

if(n->t==NDeclsc)

return op3(n->l);

if(n->l->t==NList)

error("no lists in rec's, please");

strcpy(s+1, n->l->o.s->name);

s[0]='*';

m=new(NSmash, idnode(lookup(s+1, ID)), idnode(lookup(s, ID)), (Node *)0);

return m;

}

Node *

rewr(Node *n, Node *(*f)())

{

if(n->t==NList)

return new(NList, rewr(n->l, f), rewr(n->r, f), (Node *)0);

return (*f)(n);

}

recrewrite(Node *n)

{

Node *n1, *n2, *n3;

n1=rewr(n->l, op1);

n2=rewr(n->l, op2);

n3=rewr(n->l, op3);

freenode(n->l);

n->t=NList;

n->r=n3;

n->l=new(NList, n1, n2, (Node *)0);

ndump(n);

}

/*

*

* To compile this

*

* prog(a:int){

* begin prog(b:int){ f(a, b); }(b);

* }

*

* convert it to this

*

* prog(a:int){

* begin prog(b:int, a:int){ f(a, b); }(b, a);

* }

*

*/

Node *begf;

Node *bega;

int fscope;

int progerr;

proglocals(Node *n)

{

progerr=1;

pushscope();

fscope=nscope;

begf=n->l->l;

bega=0;

dclformals(begf);

progid(n->r);

popscope();

}

begrewrite(Node *n)

{

progerr=0;

pushscope();

fscope=nscope;

begf=n->l->l->l;

bega=n->r;

dclformals(begf);

progid(n->l->r);

popscope();

n->l->l->l=begf;

n->r=bega;

}

addformal(Node *n)

{

Node *nf;

if(!alreadyformal(n, begf)){

nf=new(NFormal, dupnode(n), dupnode(n->o.s->val->type), (Node *)0);

if(begf)

begf=new(NList, begf, nf, (Node *)0);

else

begf=nf;

nf=dupnode(n);

if(bega)

bega=new(NExprlist, bega, nf, (Node *)0);

else

bega=nf;

}

}

alreadyformal(Node *n, Node *f)

{

if(f==0)

return 0;

if(f->t==NList)

return alreadyformal(n, f->l) || alreadyformal(n, f->r);

return strcmp(n->o.s->name, f->l->o.s->name)==0;

}

progid(Node *n)

{

if(n==0)

return;

switch(n->t){

case NArrayref:

case NArraycom:

case NBecome:

case NBegin:

case NCall:

case NCase:

break;

case NDecl:

progid(n->r);

progid(n->o.n);

declare(n, 0, 0, 0);

return;

case NDeclsc:

case NDefault:

break;

case NElem:

return;

case NExpr:

case NExprlist:

case NFormal:

break;

case NID:

if(n->o.s->val)

if(0<n->o.s->val->scope && n->o.s->val->scope<fscope){

if(progerr)

lerror(n, "%m not in an accessible scope", n);

addformal(n);

}

return;

case NLabel:

case NList:

case NLoop:

break;

case NLoopexpr:

progid(n->o.n);

break;

case NIf:

progid(n->o.n);

break;

case NMk:

break;

case NNum:

return;

case NProg:

pushscope();

dclformals(n->l->l);

progid(n->r);

popscope();

return;

case NResult:

break;

case NScope:

pushscope();

progid(n->l);

popscope();

return;

case NSelect:

break;

case NSmash:

return; /* ?? */

case NString:

return;

case NSwitch:

case NStructref:

break;

case NType:

break;

case NUnit:

return;

case NVal:

break;

default:

fprint(2, "can't progid node %n\n", n->t);

return;

}

progid(n->l);

progid(n->r);

}

#include "nodenames.h"

#include "typenames.h"

#include "errjmp.h"

#include "node.h"

#include "symbol.h"

#include "ydefs.h"

#include <libc.h>

lerror(Node *n, char *s, a, b, c, d, e, f)

{

lfileline(n->line);

fprint(2, s, a, b, c, d, e, f);

if(s[strlen(s)-1]!='\n')

fprint(2, "\n");

errflush();

errjmp();

}

error(char *s, a, b, c, d, e, f)

{

fileline();

fprint(2, s, a, b, c, d, e, f);

if(s[strlen(s)-1]!='\n')

fprint(2, "\n");

errflush();

errjmp();

}

rerror(char *s, a, b, c, d, e, f)

{

fileline();

fprint(2, s, a, b, c, d, e, f);

fprint(2, "\n");

processes(0);

errflush();

errjmp();

}

warn(char *s, a, b, c, d, e, f)

{

fileline();

fprint(2, "warning: ");

fprint(2, s, a, b, c, d, e, f);

fprint(2, "\n");

}

panic(char *s, a, b, c, d, e, f)

{

fileline();

fprint(2, "internal error: ");

fprint(2, s, a, b, c, d, e, f);

fprint(2, "\n");

abort();

}

rpanic(char *s, a, b, c, d, e, f)

{

fileline();

processes(0);

fprint(2, "internal error: ");

fprint(2, s, a, b, c, d, e, f);

fprint(2, "\n");

abort();

}

bconv(int *o, int f1, int f2)

{

extern int printcol;

while(printcol<*o-8)

strconv("\t", f1, f2);

strconv(" "+(8-(*o-printcol)), f1, f2);

return sizeof(int);

}

nconv(int *o, int f1, int f2)

{

if(*o<0 || sizeof(Ntypename)/sizeof(Ntypename[0])<=*o)

strconv("mystery node", f1, f2);

else

strconv(Ntypename[*o], f1, f2);

return sizeof(int);

}

tconv(int *o, int f1, int f2)

{

if(*o<0 || sizeof(Ttypename)/sizeof(Ttypename[0])<=*o)

strconv("mystery type", f1, f2);

else

strconv(Ttypename[*o], f1, f2);

return sizeof(int);

}

char bufx[128][10];

int bufno=9;

char *

prbuf(){

if(++bufno==10)

bufno=0;

return bufx[bufno];

}

econv(int *o, int f1, int f2)

{

char *buf=prbuf();

char *x;

int t=*o;

if(t<128 && strchr("+-*/%|&^~?!><=", t))

sprint(buf, "%c", t);

else{

switch(t){

case GE:

x=">=";

break;

case LE:

x="<=";

break;

case NE:

x="!=";

break;

case EQ:

x="==";

break;

case ANDAND:

x="&&";

break;

case OROR:

x="||";

break;

case REF:

x="ref";

break;

case LEN:

x="len";

break;

case UMINUS:

x="unary -";

break;

case RCV:

x="rcv";

break;

case SND:

x="send";

break;

case LSH:

x="<<";

break;

case RSH:

x=">>";

break;

case DEC:

x="--";

break;

case INC:

x="++";

break;

default:

x="mystery expression";

break;

}

strcpy(buf, x);

}

strconv(buf, f1, f2);

return sizeof(int);

}

mconv(int *o, int f1, int f2)

{

char *buf=prbuf();

Node *n=(Node *)*o;

switch(n->t){

!

;;

g7.dat) cat <<'!'

#pragma prototyped

#include "sed.h" /* define sed stuff */

Text retemp; /* holds a rewritten regex, without delimiter */

int

recomp(Text *rebuf, Text *t, int sub)

{

static int lastre;

int code;

int c;

int n;

if(!(c = *t->w) || c == '\n' || !(n = *(t->w + 1)) || n == '\n')

syntax("unterminated regular expression");

else if (c != n) {

assure(rebuf, sizeof(regex_t));

if (code = regcomp((regex_t*)rebuf->w,(char*)t->w,reflags|REG_DELIMITED|REG_MUSTDELIM|((reflags&REG_LENIENT)?0:REG_ESCAPE)))

badre((regex_t*)rebuf->w,code);

lastre = rebuf->w - rebuf->s;

t->w += ((regex_t*)rebuf->w)->re_npat;

rebuf->w += sizeof(regex_t);

} else if(rebuf->w == rebuf->s)

syntax("no previous regular expression");

else {

if (sub) {

assure(rebuf, sizeof(regex_t));

if (code = regdup(readdr(lastre), (regex_t*)rebuf->w))

badre((regex_t*)rebuf->w,code);

lastre = rebuf->w - rebuf->s;

rebuf->w += sizeof(regex_t);

}

t->w += 2;

}

return lastre;

}

void

reerror(regex_t* re, int code)

{

if(code && code != REG_NOMATCH) {

char buf[UCHAR_MAX+1];

regerror(code, re, buf, sizeof(buf));

error(3, "regular expression execution error: %s", buf);

}

}

int

reexec(regex_t* re, char* s, size_t n, size_t nmatch, regmatch_t* match, int flags)

{

int code;

if((code = regnexec(re, s, n, nmatch, match, flags)) && code != REG_NOMATCH)

reerror(re, code);

return code;

}

int

substitute(regex_t *re, Text *data)

{

int n;

regmatch_t matches[10];

if(reexec(re, (char*)data->s, data->w - data->s, elementsof(matches), matches, 0))

return 0;

if(n = regsubexec(re, (char*)data->s, elementsof(matches), matches)) {

reerror(re, n);

return 0;

}

n = re->re_sub->re_len;

assure(data, n+1);

memcpy(data->s, re->re_sub->re_buf, n+1);

data->w = data->s + n;

return 1;

}

!

;;

pat.dat)for ((i = 900; i <= 1000; i++))

do print $i

done

;;

x.dat) print x

;;

y.dat) print y

;;

xyz.dat)print x

print y

print z

;;

AB.dat|BC.dat)

print $f

;;

esac > $f

done

}

TEST 01 '-q, -v combinations'

EXEC -q . /dev/null

OUTPUT -

EXIT '[12]'

EXEC -q -v . /dev/null

EXEC -q -v .

INPUT - 'x'

EXEC -q .

EXIT 0

TEST 02 'BRE, ERE, -x, -v, -e sanity'

DO DATA big.dat

EXEC '^10*$' big.dat

OUTPUT - $'1\n10\n100\n1000\n10000'

EXEC -x '10*' big.dat

EXEC -x -e '10*' big.dat

EXEC -E '^1(00)*0?$' big.dat

EXEC -x '[^[:digit:]]*[[=1=]][[.0.]]\{0,\}' big.dat

EXEC -E -x '[^[:digit:]]*[[=1=]][[.0.]]{0,}' big.dat

EXEC -E -e $'^1((0)\\2)*$' -e $'^10((0)\\2)*$' big.dat

EXEC -E -e $'^1((0)\\2)*$\n^10((0)\\2)*$' big.dat

EXEC -E -e $'^1((0)\\2)*$|^10((0)\\4)*$' big.dat

EXEC -e $'^1\\(\\(0\\)\\2\\)*$' -e $'^10\\(\\(0\\)\\2\\)*$' big.dat

EXEC -e $'^1\\(\\(0\\)\\2\\)*$\n^10\\(\\(0\\)\\2\\)*$' big.dat

EXEC -e '^1\(\(0\)\2\)*$' -e '^10\(\(0\)\2\)*$' big.dat

EXEC -x -e '1\(\(0\)\2\)*' -e '10\(\(0\)\2\)*' big.dat

EXEC -E -v '[2-9]|1.*1|^0' big.dat

EXEC -E -x '1(0{0,2}){1,2}' big.dat

EXEC -E '1*^10*$' big.dat

EXEC -E -x 'a.|b'

INPUT - $'a\nb\nab\nba'

OUTPUT - $'b\nab'

EXEC 'state.var.folder'

INPUT - $'XXXXXXXXXXXXXXXXXXXXXXX\nfolder state.var.folder'

OUTPUT - $'folder state.var.folder'

EXEC 'XXXXXX'

INPUT - $'..XXXXXX'

OUTPUT - $'..XXXXXX'

EXEC -v /usr/include

INPUT - $'aaa\n/usr/include/signal.h\nzzz'

OUTPUT - $'aaa\nzzz'

EXEC -E -e $'(abc)' -e $'(def)\\1'

INPUT - $'abc\ndefdef'

OUTPUT - $'abc\ndefdef'

EXEC -E -e $'(abc)\n(def)\\1'

EXEC -E -e $'(abc)|(def)\\2'

EXEC -v 1

INPUT - $'a\n'

OUTPUT - $'a\n'

EXEC -v 12

EXEC -v 123

EXEC -v 1234

EXEC -v 123

INPUT -n - $'x\n\nx'

OUTPUT - $'x\n\nx'

EXEC -v 123

INPUT - $'x\n\nx'

EXEC -v 123

INPUT - $'x\n\nx\n'

OUTPUT - $'x\n\nx\n'

EXEC -v 1

INPUT - $''

OUTPUT - $''

EXEC -v 12

EXEC -v 123

EXEC -v 1234

TEST 03 'data chars except \0 \n'

DO DATA chars.dat

EXEC -c . chars.dat

OUTPUT - 254

EXEC -c -e '' chars.dat

EXEC -c -e $'\na' chars.dat

EXEC -c -e $'a\n' chars.dat

EXEC -c -e $'a\n' chars.dat

EXEC -c -e 'a' chars.dat

OUTPUT - 1

EXEC -c -x '' chars.dat

EXIT 1

OUTPUT - 0

EXEC -E -c -x '' chars.dat

TEST 04 'char class on data chars except \0 \n'

DO DATA chars.dat

EXEC -c '[[:alnum:]]' chars.dat

OUTPUT - 62

EXEC -c -i '[[:alnum:]]' chars.dat

EXEC -c '[[:alpha:]]' chars.dat

OUTPUT - 52

EXEC -c '[[:blank:]]' chars.dat

OUTPUT - 2

EXEC -c '[[:cntrl:]]' chars.dat

OUTPUT - 31

EXEC -c '[[:digit:]]' chars.dat

OUTPUT - 10

EXEC -c '[[:graph:]]' chars.dat

OUTPUT - 94

EXEC -c '[[:lower:]]' chars.dat

OUTPUT - 26

EXEC -c '[[:upper:]]' chars.dat

EXEC -c '[[:print:]]' chars.dat

OUTPUT - 95

EXEC -c '[[:punct:]]' chars.dat

OUTPUT - 32

EXEC -c '[[:space:]]' chars.dat

OUTPUT - 5

EXEC -c '[[:xdigit:]]' chars.dat

OUTPUT - 22

EXEC -c -i '[[:alpha:]]' chars.dat

OUTPUT - 52

EXEC -c -i '[[:lower:]]' chars.dat

EXEC -c -i '[[:upper:]]' chars.dat

TEST 05 '-f, -F, big pattern'

DO DATA big.dat pat.dat

DO { cp big.dat INPUT ;}

EXEC -c -f pat.dat

OUTPUT - 1902

EXEC -c -E -fpat.dat

EXEC -c -F -fpat.dat

EXEC -v -c -f pat.dat

OUTPUT - 8099

EXEC -v -c -F -fpat.dat

EXEC -v -c -E -fpat.dat

EXEC -c -x -fpat.dat

OUTPUT - 101

EXEC -c -x -F -f pat.dat

EXEC -c -x -E -f pat.dat

EXEC -v -c -x -fpat.dat

OUTPUT - 9900

EXEC -v -c -x -F -f pat.dat

EXEC -v -c -x -E -f pat.dat

TEST 06 '-f, -F, big pattern'

DO DATA big.dat

EXEC -n '\(.\)\(.\)\2\1' big.dat

IGNORE OUTPUT

DO cp OUTPUT out

EXEC -c . out

OUTPUT - 91

DO cp out INPUT

EXEC -l . out

OUTPUT - out

EXEC -l .

OUTPUT - '(standard input)'

EXEC -l . big.dat big.dat

OUTPUT - $'big.dat\nbig.dat'

EXEC -l . /dev/null big.dat big.dat /dev/null

EXEC -q -l . big.dat big.dat

OUTPUT -

EXEC -c . big.dat big.dat

OUTPUT - $'big.dat:10001\nbig.dat:10001'

EXEC -c . /dev/null

OUTPUT - 0

EXIT 1

EXEC -v -l . big.dat big.dat

OUTPUT -

TEST 07 '-h, -H'

DO DATA x.dat xyz.dat

EXEC z x.dat xyz.dat

OUTPUT - $'xyz.dat:z'

EXEC -h z x.dat xyz.dat

OUTPUT - $'z'

EXEC -H z xyz.dat

OUTPUT - $'xyz.dat:z'

TEST 08 'exit status, -s, -q, -e, -c, -l combinations'

IGNORE OUTPUT ERROR

DO DATA x.dat AB.dat BC.dat

DO for opt in -e -c -l

do

EXEC $opt . /dev/null

EXIT 1

EXEC -q $opt . /dev/null

EXIT 1

EXEC $opt .

INPUT - x

EXIT 0

EXEC -q $opt .

INPUT - x

EXIT 0

EXEC $opt . not_a_file

EXIT '[!01]'

EXEC -q $opt . not_a_file

EXIT 1

EXEC -s $opt . not_a_file

EXIT 2

EXEC -q -s $opt . not_a_file

EXIT 1

EXEC -s $opt . x.dat not_a_file

EXIT 2

EXEC -q -s $opt . x.dat not_a_file

EXIT 0

EXEC -q -s $opt . not_a_file x.dat

EXIT 0

done

EXEC -l A AB.dat BC.dat

OUTPUT - $'AB.dat'

EXIT 0

EXEC -L C AB.dat BC.dat

EXEC -v -l C AB.dat BC.dat

EXEC -l C AB.dat BC.dat

OUTPUT - $'BC.dat'

EXEC -L A AB.dat BC.dat

EXEC -v -l A AB.dat BC.dat

EXEC -l B AB.dat BC.dat

OUTPUT - $'AB.dat\nBC.dat'

EXEC -L Z AB.dat BC.dat

EXEC -l Z AB.dat BC.dat

OUTPUT -

EXIT 1

EXEC -L B AB.dat BC.dat

TEST 09 'file not found'

DIAGNOSTICS

DO DATA x.dat y.dat

EXEC y nope.dat

EXIT 2

EXEC -F -f nope.dat x.dat

EXIT 2

EXEC -F -f nope.dat -f x.dat xyz.dat

EXIT 2

EXEC y x.dat nope.dat y.dat

OUTPUT - $'y.dat:y'

EXIT 2

TEST 10 'simple gre tests from Andrew Hume'

EXEC -q $'a'

INPUT - $'a'

OUTPUT -

EXEC -q $'a'

INPUT - $'ba'

EXEC -q $'a'

INPUT - $'bab'

EXEC -q $'.'

INPUT - $'x'

EXEC -q $'.'

INPUT - $'xxx'

EXEC -q $'.a'

INPUT - $'xa'

EXEC -q $'.a'

INPUT - $'xxa'

EXEC -q $'.a'

INPUT - $'xax'

EXEC -q $'$'

INPUT - $'x'

EXEC -q $'$'

INPUT - $''

EXEC -q $'.$'

INPUT - $'x'

EXEC -q $'a$'

INPUT - $'a'

EXEC -q $'a$'

INPUT - $'ba'

EXEC -q $'a$'

INPUT - $'bbba'

EXEC -q $'^'

INPUT - $'x'

EXEC -q $'^'

INPUT - $''

EXEC -q $'^'

INPUT - $'^'

EXEC -q $'^a$'

INPUT - $'a'

EXEC -q $'^a.$'

INPUT - $'ax'

EXEC -q $'^a.$'

INPUT - $'aa'

EXEC -q $'^$'

INPUT - $''

EXEC -q $'^.a'

INPUT - $'xa'

EXEC -q $'^.a'

INPUT - $'xaa'

EXEC -q $'^.*a'

INPUT - $'a'

EXEC -q $'^.*a'

INPUT - $'xa'

EXEC -q $'^.*a'

INPUT - $'xxxxxxa'

EXEC -q -E $'^.+a'

INPUT - $'xa'

EXEC -q -E $'^.+a'

INPUT - $'xxxxxxa'

EXEC -q $'a*'

INPUT - $''

EXEC -q $'a*'

INPUT - $'a'

EXEC -q $'a*'

INPUT - $'aaaa'

EXEC -q $'a*'

INPUT - $'xa'

EXEC -q $'a*'

INPUT - $'xxxx'

EXEC -q $'aa*'

INPUT - $'a'

EXEC -q $'aa*'

INPUT - $'aaa'

EXEC -q $'aa*'

INPUT - $'xa'

EXEC -q $'\\$'

INPUT - $'x$'

EXEC -q $'\\$'

INPUT - $'$'

EXEC -q $'\\$'

INPUT - $'$x'

EXEC -q $'\\.'

INPUT - $'.'

EXEC -q -G $'.^$'

INPUT - $'a^'

EXEC -q -G $'^x$'

INPUT - $'x'

EXEC -q -G $'a\\$'

INPUT - $'a$'

EXEC -q -G $'\\(ab\\)$'

INPUT - $'cab'

EXEC -q -G $'\\(ab\\)$'

INPUT - $'ab'

EXEC -q -E $'xr+y'

INPUT - $'xry'

EXEC -q -E $'xr+y'

INPUT - $'xrry'

EXEC -q -E $'xr+y'

INPUT - $'xrrrrrry'

EXEC -q -E $'xr?y'

INPUT - $'xy'

EXEC -q -E $'xr?y'

INPUT - $'xry'

EXEC -q -E $'a(bc|def)g'

INPUT - $'abcg'

EXEC -q -E $'a(bc|def)g'

INPUT - $'adefg'

EXEC -q $'[0-9]'

INPUT - $'1'

EXEC -q $'[0-9]'

INPUT - $'567'

EXEC -q $'[0-9]'

INPUT - $'x0y'

EXEC -q $'[^0-9]'

INPUT - $'abc'

EXEC -q $'[^0-9]'

INPUT - $'x0y'

EXEC -q -E $'x[0-9]+y'

INPUT - $'x0y'

EXEC -q -E $'x[0-9]+y'

INPUT - $'x23y'

EXEC -q -E $'x[0-9]+y'

INPUT - $'x12345y'

EXEC -q -E $'x[0-9]?y'

INPUT - $'xy'

EXEC -q -E $'x[0-9]?y'

INPUT - $'x1y'

EXEC -q -i $'X'

INPUT - $'x'

EXEC -q -x $'read'

INPUT - $'read'

EXEC -q -xF $'read'

INPUT - $'read'

EXEC -q -F $'read'

INPUT - $'read'

EXEC -q -F $'read'

INPUT - $'xy read'

EXEC -q -F $'read'

INPUT - $'x read y'

EXEC -q -F $'read'

INPUT - $'xread'

EXEC -q -F $'read'

INPUT - $'readx'

EXEC -q $'[.]de..'

INPUT - $'.dexx'

EXEC -q $'[.]de..'

INPUT - $'.deyyy'

EXEC -q -G $'^|s'

INPUT - $'|sec'

EXEC -q -G $'..B'

INPUT - $'CDAB'

EXEC -q -G $'$.*tt.*\\$'

INPUT - $'$tt$'

EXEC -q -E $'^([a-z]+)\\1$'

INPUT - $'vivi'

EXEC -q -E $'([a-z]+)\\1'

INPUT - $'vivi'

EXEC -q -E $'([a-z]+)\\1'

INPUT - $'vivify'

EXEC -q -E $'([a-z]+)\\1'

INPUT - $'revivi'

EXEC -q -G $'\\(....\\).*\\1'

INPUT - $'beriberi'

EXEC -q -E $'(....).*\\1'

INPUT - $'beriberi'

EXEC -q $'^$'

INPUT - $''

EXEC -q -G $'^$'

INPUT - $''

EXEC -q $'[ab]\\{2\\}k'

INPUT - $'abk'

EXEC -q $'[ab]\\{2\\}k'

INPUT - $'xyaak'

EXEC -q $'[ab]\\{2\\}k'

INPUT - $'zabak'

EXEC -q $'[ab]\\{2,\\}d'

INPUT - $'abd'

EXEC -q $'[ab]\\{2,\\}d'

INPUT - $'abababad'

EXEC -q $'q[ab]\\{2,4\\}d'

INPUT - $'qabd'

EXEC -q $'q[ab]\\{2,4\\}d'

INPUT - $'qababd'

EXEC -q $'q[ab]\\{2,4\\}d'

INPUT - $'qaaad'

EXEC -q -E $'a[]]b'

INPUT - $'a]b'

EXEC -q -G $'a[]]b'

INPUT - $'a]b'

EXEC -q -E $'a[^]b]c'

INPUT - $'adc'

EXEC -q -G $'a[^]b]c'

INPUT - $'adc'

EXEC -q -i $'angel[^e]'

INPUT - $'angelo'

EXEC -q -i $'angel[^e]'

INPUT - $'ANGELH'

EXEC -q -G $'^[^-].*>'

INPUT - $'abc>'

EXEC -q -i $'^[A-Z]'

INPUT - $'abc'

EXEC -q -i $'^[A-Z]'

INPUT - $'ABC'

EXEC -q -i $'^[^A-Z]'

INPUT - $'123'

EXEC -q -G $'|abc'

INPUT - $'|abc'

EXEC -q -G $'\\(ac*\\)c*d[ac]*\\1'

INPUT - $'acdacaaa'

EXEC -q -E $'(ac*)c*d[ac]*\\1'

INPUT - $'acdacaaa'

EXEC -q -E $'ram|am'

INPUT - $'am'

EXEC -q -E $'[a-za-za-za-za-za-za-za-za-za-z]'

INPUT - $'for this line'

EXEC -q $'[a-za-za-za-za-za-za-za-za-za-z]'

INPUT - $'for this line'

EXEC -q -E $'[a-za-za-za-za-za-za-za-za-z]'

INPUT - $'but watch out'

EXEC -q $'[a-za-za-za-za-za-za-za-za-z]'

INPUT - $'but watch out'

EXEC -q -E $'[ ]*([^ ]+)[ ]*'

INPUT - $'foo'

EXEC -q -E $'[ ]*([^ ]+)[ ]*'

INPUT - $'foo '

EXEC -q -E $'[ ]*([^ ]+)[ ]*([(].*[)])?'

INPUT - $'foo'

EXEC -q -E $'[ ]*([^ ]+)[ ]*([(].*[)])?'

INPUT - $'foo '

EXEC -q -E $'((foo)|(bar))!bas'

INPUT - $'bar!bas'

EXEC -q -E $'((foo)|(bar))!bas'

INPUT - $'foo!bar!bas'

EXEC -q -E $'((foo)|(bar))!bas'

INPUT - $'bar!bas'

EXEC -q -E $'((foo)|(bar))!bas'

INPUT - $'foo!bar!bas'

EXEC -q -E $'((foo)|bar)!bas'

INPUT - $'bar!bas'

EXEC -q -E $'((foo)|bar)!bas'

INPUT - $'foo!bar!bas'

EXEC -q -E $'(foo|(bar))!bas'

INPUT - $'bar!bas'

EXEC -q -E $'(foo|(bar))!bas'

INPUT - $'foo!bar!bas'

EXEC -q -E $'^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$'

INPUT - $'bar!bas'

EXEC -q -E $'^[abf][0-9][0-9][0-9]([0-9]|(\\[[0-9]+\\]))'

INPUT - $'b051[89]'

EXEC -q -E $'^[abf][0-9][0-9][0-9]([0-9]|(\\[[0-9]+\\]))'

INPUT - $'b0123'

EXEC -q $'a'

INPUT - $''

EXIT 1

EXEC -q $'a'

INPUT - $'x'

EXEC -q $'a'

INPUT - $'xxxxx'

EXEC -q $'.'

INPUT - $''

EXEC -q $'.a'

INPUT - $'a'

EXEC -q $'.a'

INPUT - $'ab'

EXEC -q $'.a'

INPUT - $''

EXEC -q $'.$'

INPUT - $''

EXEC -q $'a$'

INPUT - $'ab'

EXEC -q $'a$'

INPUT - $'x'

EXEC -q $'a$'

INPUT - $''

EXEC -q $'^a$'

INPUT - $'xa'

EXEC -q $'^a$'

INPUT - $'ax'

EXEC -q $'^a$'

INPUT - $'xax'

EXEC -q $'^a$'

INPUT - $''

EXEC -q $'^a.$'

INPUT - $'xa'

EXEC -q $'^a.$'

INPUT - $'aaa'

EXEC -q $'^a.$'

INPUT - $'axy'

EXEC -q $'^a.$'

INPUT - $''

EXEC -q $'^$'

INPUT - $'x'

EXEC -q $'^$'

INPUT - $'^'

EXEC -q $'^.a'

INPUT - $'a'

EXEC -q $'^.a'

INPUT - $''

EXEC -q $'^.*a'

INPUT - $''

EXEC -q -E $'^.+a'

INPUT - $''

EXEC -q -E $'^.+a'

INPUT - $'a'

EXEC -q -E $'^.+a'

INPUT - $'ax'

EXEC -q $'aa*'

INPUT - $'xxxx'

EXEC -q $'aa*'

INPUT - $''

EXEC -q $'\\$'

INPUT - $''

EXEC -q $'\\$'

INPUT - $'x'

EXEC -q $'\\.'

INPUT - $'x'

EXEC -q $'\\.'

INPUT - $''

EXEC -q -G $'.^$'

INPUT - $''

EXEC -q -G $'.^$'

INPUT - $'a^$'

EXEC -q -G $'^x$'

INPUT - $'yx'

EXEC -q -G $'^x$'

INPUT - $'xy'

EXEC -q -G $'a\\$'

INPUT - $'a'

EXEC -q -G $'\\(ab\\)$'

INPUT - $'ab$'

EXEC -q -E $'xr+y'

INPUT - $'ry'

EXEC -q -E $'xr+y'

INPUT - $'xy'

EXEC -q -E $'xr?y'

INPUT - $'xrry'

EXEC -q -E $'a(bc|def)g'

INPUT - $'abc'

EXEC -q -E $'a(bc|def)g'

INPUT - $'abg'

EXEC -q -E $'a(bc|def)g'

INPUT - $'adef'

EXEC -q -E $'a(bc|def)g'

INPUT - $'adeg'

EXEC -q $'[0-9]'

INPUT - $'abc'

EXEC -q $'[0-9]'

INPUT - $''

EXEC -q $'[^0-9]'

INPUT - $'1'

EXEC -q $'[^0-9]'

INPUT - $'567'

EXEC -q $'[^0-9]'

INPUT - $''

EXEC -q -E $'x[0-9]+y'

INPUT - $'0y'

EXEC -q -E $'x[0-9]+y'

INPUT - $'xy'

EXEC -q -E $'x[0-9]?y'

INPUT - $'x23y'

EXEC -q -x $'read'

INPUT - $'xy read'

EXEC -q -x $'read'

INPUT - $'x read y'

EXEC -q -x $'read'

INPUT - $'xread'

EXEC -q -x $'read'

INPUT - $'readx'

EXEC -q -xF $'read'

INPUT - $'xy read'

EXEC -q -xF $'read'

INPUT - $'x read y'

EXEC -q -xF $'read'

INPUT - $'xread'

EXEC -q -xF $'read'

INPUT - $'readx'

EXEC -q $'[.]de..'

INPUT - $'.de'

EXEC -q $'[.]de..'

INPUT - $'.dex'

EXEC -q -G $'^|s'

INPUT - $'sec'

EXEC -q -G $'..B'

INPUT - $'ABCD'

EXEC -q -E $'^([a-z]+)\\1$'

INPUT - $'vivify'

EXEC -q -E $'([a-z]+)\\1'

INPUT - $'vovify'

EXEC -q -E $'([a-z]+)\\1'

INPUT - $'viv'

EXEC -q $'[ab]\\{2\\}k'

INPUT - $'zad'

EXEC -q $'[ab]\\{2\\}k'

INPUT - $'bq'

EXEC -q $'[ab]\\{2\\}k'

INPUT - $'abq'

EXEC -q $'[ab]\\{2,\\}d'

INPUT - $'ad'

EXEC -q $'[ab]\\{2,\\}d'

INPUT - $'ababaq'

EXEC -q $'q[ab]\\{2,4\\}d'

INPUT - $'qad'

EXEC -q $'q[ab]\\{2,4\\}d'

INPUT - $'qababad'

EXEC -q -i $'angel[^e]'

INPUT - $'angel'

EXEC -q -i $'angel[^e]'

INPUT - $'ANGEL'

EXEC -q -i $'angel[^e]'

INPUT - $'angele'

EXEC -q -i $'angel[^e]'

INPUT - $'ANGELE'

EXEC -q -G $'^[^-].*>'

INPUT - $'-a>'

EXEC -q -i $'^[^A-Z]'

INPUT - $'abc'

EXEC -q -i $'^[^A-Z]'

INPUT - $'ABC'

EXEC -q -G $'|abc'

INPUT - $'abc'

EXEC -q -x $'.|..'

INPUT - $'abc'

TEST 11 'complex gre tests from Andrew Hume'

DO DATA g1.dat g4.dat g5.dat g6.pat g6.dat g8.dat g12.dat

EXEC -xF $'defg\nabcd'

INPUT - $'x\nabcd\nabcde\neabcd\ndefg\nxdefg\ndefgx\nabcd defg'

OUTPUT - $'abcd\ndefg'

EXEC abc

INPUT - 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaxyz

abc'

OUTPUT - 'abc'

EXEC -E 'pm|xdhu'

INPUT - $'/p1/usr/bin/pmxpc:

\t pm.sl\t2.94

\t xdhu.sl\t1.8

\t/lib/crt1.o.sl 1.1 4.0 01/15/86 12744 AT&T-SF

\t/usr/include/stdio.h.sl 1.1 4.0 01/15/86 4140 AT&T-SF

\t/usr/include/ctype.h.sl 1.1 4.0 01/15/86 45671 AT&T-SF

\t/usr/include/string.h.sl 1.1 4.0 01/15/86 51235 AT&T-SF

\t/usr/include/signal.h.sl 1.1 4.0 01/15/86 34302 AT&T-SF

\t/usr/include/sys/signal.h.sl 1.5 3.2 09/02/87 33640 AT&T-SF

\t/usr/include/sys/types.h.sl 1.3 3.1 06/02/86 48113 AT&T-SF

\t/usr/include/sys/stat.h.sl 1.3 3.0 12/19/85 41824

\t/usr/include/termio.h.sl 1.1 4.0 01/15/86 29141 AT&T-SF'

OUTPUT - $'/p1/usr/bin/pmxpc:

\t pm.sl\t2.94

\t xdhu.sl\t1.8'

EXEC -v : g4.dat

OUTPUT - $' 1 ZIPPORI, Israel

1 ZERIFIN, Israel

1 ZEPHYRHILLS, Fla.

1 ZENICA, Yugoslavia

1 ZAP, N.D.

1 ZAMBRANO, Honduras

1 ZACHARY, La.

1 YUCCA VALLEY, Calif.

1 YORKVILLE, Ill.

1 YORK, Maine

1 YENAN, China

1 YELOWSTONE NATIONAL PARK, Wyo.

1 YEADON, Pa.

1 YATTA, Occupied West Bank

1 YASSIHOYUK, Turkey

1 YAPHANK, N.Y.

1 YAMOUSSOUKRO, Ivory Coast'

EXEC '^com ' g5.dat

SAME OUTPUT g5.dat

EXEC -E -f g6.pat g6.dat

OUTPUT - $'emalloc(unsigned long n)

erealloc(char *p, unsigned long n)

pprint(proc, fmt, a, b, c, d, e)

bltinval(char *name, Node *t)

mk(type, len)

compile(n)\t/* called from parser only */

gen(Node *n, int retain)

lgen(Node *n)

genfreeauto(Symbol *s)

dupgen(Node *t, int n)

printable(Node *n)

constants(Node *n)

declare(Node *n, int stclass, int dotypchk, int docomp)

recrewrite(Node *n)

proglocals(Node *n)

begrewrite(Node *n)

lerror(Node *n, char *s, a, b, c, d, e, f)

error(char *s, a, b, c, d, e, f)

rerror(char *s, a, b, c, d, e, f)

warn(char *s, a, b, c, d, e, f)

panic(char *s, a, b, c, d, e, f)

rpanic(char *s, a, b, c, d, e, f)

bconv(int *o, int f1, int f2)

nconv(int *o, int f1, int f2)

tconv(int *o, int f1, int f2)

econv(int *o, int f1, int f2)

mconv(int *o, int f1, int f2)'

EXEC '^[^`]*`[^`]*$'

INPUT - $'if [ `cat $HISTFILE | lct` -gt "$HISTMAXL" ]

for i in `ls [0-9]*# | egrep \'^[0-9]+##?$\' | sed -e \'s/#*$//\'`

do case "`ps -lx$i" in ?*);; *) rm -f ${i}# ${i}##;; esac

NBRFILES=`ls -f $pubdir/jbk | fgrep -vi -x \'.

..\'|lct`'

OUTPUT - $'do case "`ps -lx$i" in ?*);; *) rm -f ${i}# ${i}##;; esac

NBRFILES=`ls -f $pubdir/jbk | fgrep -vi -x \'.

..\'|lct`'

EXEC -F -x -f g8.dat g8.dat

SAME OUTPUT g8.dat

EXEC -F -f g8.dat

INPUT - $'aba\ncad\nbad\nacb'

OUTPUT - $'aba\nbad\nacb'

EXEC -v '^\.x' g1.dat

OUTPUT -

EXIT 1

EXEC -xvF -f g12.dat g12.dat

EXEC -xvF -f INPUT

INPUT - $'at\nhematic'

TEST 12 'alternating BM tests'

EXEC -F $':::1:::0:\n:::1:1:0:'

INPUT - ':::0:::1:::1:::0:'

SAME OUTPUT INPUT

EXEC -F $':::1:::0:\n:::1:1:1:'

EXEC -E $':::1:::0:|:::1:1:0:'

EXEC -E $':::1:::0:|:::1:1:1:'

TEST 13 '-c, -h, -t combinations'

DO DATA x.dat xyz.dat

EXEC x x.dat xyz.dat

OUTPUT - $'x.dat:x\nxyz.dat:x'

EXEC -c x x.dat xyz.dat

OUTPUT - $'x.dat:1\nxyz.dat:1'

EXEC -ch x x.dat xyz.dat

OUTPUT - $'1\n1'

EXEC -ct x x.dat xyz.dat

OUTPUT - $'2'

EXEC -cht x x.dat xyz.dat

OUTPUT - $'2'

EXEC -h x x.dat xyz.dat

OUTPUT - $'x\nx'

EXEC -ht x x.dat xyz.dat

OUTPUT - $'2'

EXEC -t x x.dat xyz.dat

OUTPUT - $'2'

TEST 14 '-m with -c, -h, -n, -t combinations'

DO DATA g6.dat g7.dat

EXEC -m -e open:{ -e close:} g6.dat g7.dat

OUTPUT - $'g6.dat:open:{

g6.dat:open: if(p==0){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(p==0){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(proc->prbuf==0){

g6.dat:close: }

g6.dat:open: if(n+proc->nprbuf+1>proc->maxprbuf){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:long call0[]={ /* plain function, 0 arguments */

g6.dat:close:};

g6.dat:open:long call1[]={ /* plain function, 1 argument */

g6.dat:close:};

g6.dat:open:long call2[]={ /* plain function, 2 arguments */

g6.dat:close:};

g6.dat:open:long call3[]={ /* plain function, 3 arguments */

g6.dat:close:};

g6.dat:open:long call4[]={ /* plain function, 4 arguments */

g6.dat:close:};

g6.dat:open:long call5[]={ /* plain function, 5 arguments */

g6.dat:close:};

g6.dat:open:long call2_0[]={/* two-step function, 0 arguments */

g6.dat:close:};

g6.dat:open:struct{

g6.dat:open:}bltin[]={

g6.dat:close:}bltin[]={

g6.dat:open: 0, {0, 0, 0}, 0, 0,

g6.dat:close: 0, {0, 0, 0}, 0, 0,

g6.dat:close:};

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(type==Sstruct){

g6.dat:close: }else

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(cflag){

g6.dat:close: }

g6.dat:open: if(errmark()){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: switch(n->t){

g6.dat:open: if(n->l->t==NCall && !bflag){

g6.dat:close: }

g6.dat:open: switch(n->o.t){

g6.dat:close: }

g6.dat:open: switch(n->o.i){

g6.dat:open: if(eqtype(etypeof(n->l), &arychartype)){

g6.dat:close: }

g6.dat:open: if(isptrtype(etypeof(n->l))){

g6.dat:close: }else

g6.dat:open: if(retain && n->l->t==NID && isinttype(etypeof(n->l))){

g6.dat:close: }

g6.dat:close: }

g6.dat:open: switch(typeof(n)->o.t){

g6.dat:open: if(n->o.s->val->isauto){

g6.dat:open: }else{

g6.dat:close: }else{

g6.dat:close: }

g6.dat:open: if(n->o.s->val->isauto){

g6.dat:open: }else{

g6.dat:close: }else{

g6.dat:close: }

g6.dat:close: }

g6.dat:open: if(nscope==1){

g6.dat:close: }else

g6.dat:open: case NSmash:{

g6.dat:open: if(vr->type->o.t==TType){

g6.dat:close: }

g6.dat:open: if(isptrtype(vl->type)){

g6.dat:open: if(vl->isauto){

g6.dat:open: }else{

g6.dat:close: }else{

g6.dat:close: }

g6.dat:close: }

g6.dat:open: if(vl->isauto){

g6.dat:close: }

g6.dat:close: }

g6.dat:open: if(retain){

g6.dat:close: }

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(isstr){

g6.dat:open: }else{

g6.dat:close: }else{

g6.dat:close: }

g6.dat:open: if(a->t!=NID){

g6.dat:open: }else if(a->o.s->val->isauto){

g6.dat:close: }else if(a->o.s->val->isauto){

g6.dat:open: }else{

g6.dat:close: }else{

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: switch(n->t){

g6.dat:open: switch(typeof(n)->o.t){

g6.dat:open: if(n->o.s->val->isauto){

g6.dat:close: }

g6.dat:open: if(n->o.s->val->isauto){

g6.dat:close: }

g6.dat:open: if(n->o.s->val->isauto){

g6.dat:close: }

g6.dat:close: }

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: switch(n->t){

g6.dat:open: if(n->o.s->val->isauto){

g6.dat:close: }

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(n->r==0){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(n->o.i){ /* enter loop at top, so jump to body */

g6.dat:close: }

g6.dat:open: if(n->r->r){ /* jump to condition */

g6.dat:close: }

g6.dat:open: if(n->r->r){

g6.dat:close: }else

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:open: else{

g6.dat:open: sprint(buf, "prog(){call on line %d}", n->line);

g6.dat:close: sprint(buf, "prog(){call on line %d}", n->line);

g6.dat:close: }

g6.dat:open: switch(callinst){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(n->t==NList){

g6.dat:close: }

g6.dat:open: if(n->t==NArraycom){

g6.dat:close: }else if(etypeoft(n)->o.t==TArray)

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(n->t==NList){

g6.dat:close: }

g6.dat:open: if(c->o.t==\'=\'){

g6.dat:close: }

g6.dat:open: if(c->o.t==SND){

g6.dat:close: }

g6.dat:open: else if(c->t==NArraycom){

g6.dat:close: }else

g6.dat:open: if(c->t==NArraycom){ /* save array index */

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(s->t==NList){

g6.dat:close: }

g6.dat:open: else{

g6.dat:open: if(isptr){ /* string */

g6.dat:open: }else{

g6.dat:close: }else{

g6.dat:close: }

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(isptrtype(s->val->type)){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(n->t==NExprlist){

g6.dat:close: }

g6.dat:open: switch(t->o.t){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(errmark()){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(returnloc){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(types->t==NList){

g6.dat:close: }

g6.dat:open: if(isptrtype(types)){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:open: switch(t->o.t){

g6.dat:open: else{

g6.dat:close: }

g6.dat:open: if(v==0){

g6.dat:close: }

g6.dat:open: if(t->r->o.t==TChar){

g6.dat:close: }else

g6.dat:open: if(v==0){

g6.dat:close: }

g6.dat:open: if(v==0){

g6.dat:close: }

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: switch(t->o.t){

g6.dat:open: if(isptrtype(t)){

g6.dat:open: }else if(t->o.t==TInt || t->o.t==TUnit){

g6.dat:close: }else if(t->o.t==TInt || t->o.t==TUnit){

g6.dat:close: }else if(t->o.t==TChar)

g6.dat:open: case TStruct:{

g6.dat:close: }

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(t->t==NList){

g6.dat:close: }

g6.dat:open: for(i=length(t); --i>=0; ){

g6.dat:open: if(*pos==BPW){

g6.dat:close: }

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(l<-2 || l>10){

g6.dat:close: };

g6.dat:open: switch((int)l){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: switch(n->t){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: switch(n->t){

g6.dat:open: switch(n->o.i){

g6.dat:close: }

g6.dat:open: if(isconst(n->o.n)){

g6.dat:open: if(topofstack()){

g6.dat:open: }else{

g6.dat:close: }else{

g6.dat:close: }

g6.dat:close: }

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: switch(n->t){

g6.dat:open: switch(n->o.i){

g6.dat:close: }

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: switch(t->o.t){

g6.dat:open: if(t->r->o.t==TChar){

g6.dat:close: }

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(proc->pc==0){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(n->t==NList){

g6.dat:close: }

g6.dat:open: if(n->t==NDeclsc){

g6.dat:close: }

g6.dat:open: if(n->r==0){

g6.dat:close: }

g6.dat:open: if(dotypchk){

g6.dat:open: if(n->o.n){

g6.dat:close: }

g6.dat:close: }

g6.dat:open: if(docomp && n->o.n){

g6.dat:close: }else

g6.dat:open: if(n->o.n && docomp && nscope==0){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(id->t==NList){

g6.dat:close: }

g6.dat:close:}

g6.dat:open: * rec {

g6.dat:close: * };

g6.dat:open: * rec type T: struct of { t:T; };

g6.dat:close: * rec type T: struct of { t:T; };

g6.dat:open:{

g6.dat:open: if(n->t==NDeclsc){

g6.dat:close: }

g6.dat:open: if(n->r==0){

g6.dat:open: }else if(n->r->o.t==TType){

g6.dat:close: }else if(n->r->o.t==TType){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(n->t==NDeclsc){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open: * prog(a:int){

g6.dat:open: * begin prog(b:int){ f(a, b); }(b);

g6.dat:close: * begin prog(b:int){ f(a, b); }(b);

g6.dat:close: * }

g6.dat:open: * prog(a:int){

g6.dat:open: * begin prog(b:int, a:int){ f(a, b); }(b, a);

g6.dat:close: * begin prog(b:int, a:int){ f(a, b); }(b, a);

g6.dat:close: * }

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:open: if(!alreadyformal(n, begf)){

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:open: switch(n->t){

g6.dat:open: if(0<n->o.s->val->scope && n->o.s->val->scope<fscope){

g6.dat:close: }

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:{

g6.dat:close:}

g6.dat:open:prbuf(){

g6.dat:close:}

g6.dat:open:{

g6.dat:open: else{

g6.dat:open: switch(t){

g6.dat:close: }

g6.dat:close: }

g6.dat:close:}

g6.dat:open:{

g6.dat:open: switch(n->t){

g7.dat:open:{

g7.dat:open: else if (c != n) {

g7.dat:close: } else if(rebuf->w == rebuf->s)

g7.dat:open: else {

g7.dat:open: if (sub) {

g7.dat:close: }

g7.dat:close: }

g7.dat:close:}

g7.dat:open:{

g7.dat:open: if(code && code != REG_NOMATCH) {

g7.dat:close: }

g7.dat:close:}

g7.dat:open:{

g7.dat:close:}

g7.dat:open:{

g7.dat:open: if(n = regsubexec(re, (char*)data->s, elementsof(matches), matches)) {

g7.dat:close: }

g7.dat:close:}'

EXEC -m -e include:include -e define:define g6.dat g7.dat

OUTPUT - $'g6.dat:include:#include "alloc.h"

g6.dat:include:#include <libc.h>

g6.dat:include:#include "alloc.h"

g6.dat:include:#include "word.h"

g6.dat:include:#include "store.h"

g6.dat:include:#include "comm.h"

g6.dat:include:#include <libc.h>

g6.dat:include:#include "node.h"

g6.dat:include:#include "symbol.h"

g6.dat:include:#include "alloc.h"

g6.dat:include:#include "word.h"

g6.dat:include:#include "store.h"

g6.dat:include:#include "comm.h"

g6.dat:include:#include "inst.h"

g6.dat:include:#include <libc.h>

g6.dat:include:#include "lib.h"

g6.dat:include:#include "lib.h"

g6.dat:include:#include "node.h"

g6.dat:include:#include "symbol.h"

g6.dat:include:#include "alloc.h"

g6.dat:include:#include "ydefs.h"

g6.dat:include:#include "word.h"

g6.dat:include:#include "store.h"

g6.dat:include:#include "comm.h"

g6.dat:include:#include "inst.h"

g6.dat:include:#include "errjmp.h"

g6.dat:include:#include <libc.h>

g6.dat:include:#include "alloc.h"

g6.dat:include:#include "node.h"

g6.dat:include:#include "symbol.h"

g6.dat:include:#include "ydefs.h"

g6.dat:include:#include "word.h"

g6.dat:include:#include "store.h"

g6.dat:include:#include <libc.h>

g6.dat:include:#include "alloc.h"

g6.dat:include:#include "word.h"

g6.dat:include:#include "store.h"

g6.dat:include:#include "comm.h"

g6.dat:include:#include <libc.h>

g6.dat:include: nargs+=2; /* includes result and sym; add pc, fp */

g6.dat:include:#include "node.h"

g6.dat:include:#include "symbol.h"

g6.dat:include:#include "alloc.h"

g6.dat:include:#include "ydefs.h"

g6.dat:include:#include "word.h"

g6.dat:include:#include "store.h"

g6.dat:include:#include <libc.h>

g6.dat:include:#include "nodenames.h"

g6.dat:include:#include "typenames.h"

g6.dat:include:#include "errjmp.h"

g6.dat:include:#include "node.h"

g6.dat:include:#include "symbol.h"

g6.dat:include:#include "ydefs.h"

g6.dat:include:#include <libc.h>

g6.dat:define:#define FNS

g6.dat:define:#define C 0x40000000

g6.dat:define:#define I 0x20000000

g6.dat:define:#define F 0x10000000

g6.dat:define:#define M(x) ((x)&~(C|I|F))

g7.dat:include:#include "sed.h" /* define sed stuff */

g7.dat:define:#include "sed.h" /* define sed stuff */'

EXEC -n -m -e open:{ -e close:} g6.dat g7.dat

OUTPUT - $'g6.dat:6:open:{

g6.dat:9:open: if(p==0){

g6.dat:12:close: }

g6.dat:14:close:}

g6.dat:17:open:{

g6.dat:19:open: if(p==0){

g6.dat:22:close: }

g6.dat:24:close:}

g6.dat:36:open:{

g6.dat:39:close:}

g6.dat:42:open:{

g6.dat:45:close:}

g6.dat:48:open:{

g6.dat:51:close:}

g6.dat:54:open:{

g6.dat:57:close:}

g6.dat:60:open:{

g6.dat:63:close:}

g6.dat:66:open:{

g6.dat:69:close:}

g6.dat:72:open:{

g6.dat:75:close:}

g6.dat:78:open:{

g6.dat:81:close:}

g6.dat:84:open:{

g6.dat:87:close:}

g6.dat:90:open:{

g6.dat:93:close:}

g6.dat:96:open:{

g6.dat:99:close:}

g6.dat:102:open:{

g6.dat:105:close:}

g6.dat:108:open:{

g6.dat:111:close:}

g6.dat:114:open:{

g6.dat:117:close:}

g6.dat:123:open:{

g6.dat:127:close:}

g6.dat:130:open:{

g6.dat:134:close:}

g6.dat:137:open:{

g6.dat:141:close:}

g6.dat:144:open:{

g6.dat:148:close:}

g6.dat:151:open:{

g6.dat:155:close:}

g6.dat:158:open:{

g6.dat:162:close:}

g6.dat:165:open:{

g6.dat:169:close:}

g6.dat:172:open:{

g6.dat:176:close:}

g6.dat:179:open:{

g6.dat:189:close:}

g6.dat:192:open:{

g6.dat:198:close:}

g6.dat:201:open:{

g6.dat:207:close:}

g6.dat:210:open:{

g6.dat:214:close:}

g6.dat:217:open:{

g6.dat:221:close:}

g6.dat:224:open:{

g6.dat:228:close:}

g6.dat:231:open:{

g6.dat:235:close:}

g6.dat:238:open:{

g6.dat:242:close:}

g6.dat:245:open:{

g6.dat:251:close:}

g6.dat:258:open:{

g6.dat:261:close:}

g6.dat:264:open:{

g6.dat:267:close:}

g6.dat:270:open:{

g6.dat:273:close:}

g6.dat:276:open:{

g6.dat:281:close:}

g6.dat:284:open:{

g6.dat:289:close:}

g6.dat:296:open:{

g6.dat:307:close:}

g6.dat:314:open:{

g6.dat:317:close:}

g6.dat:320:open:{

g6.dat:323:close:}

g6.dat:326:open:{

g6.dat:329:close:}

g6.dat:332:open:{

g6.dat:335:close:}

g6.dat:338:open:{

g6.dat:341:close:}

g6.dat:346:open:{

g6.dat:350:open: if(proc->prbuf==0){

g6.dat:354:close: }

g6.dat:355:open: if(n+proc->nprbuf+1>proc->maxprbuf){

g6.dat:358:close: }

g6.dat:361:close:}

g6.dat:367:open:{

g6.dat:370:close:}

g6.dat:373:open:{

g6.dat:377:close:}

g6.dat:380:open:{

g6.dat:384:close:}

g6.dat:387:open:{

g6.dat:392:close:}

g6.dat:411:open:long call0[]={ /* plain function, 0 arguments */

g6.dat:413:close:};

g6.dat:414:open:long call1[]={ /* plain function, 1 argument */

g6.dat:416:close:};

g6.dat:417:open:long call2[]={ /* plain function, 2 arguments */

g6.dat:419:close:};

g6.dat:420:open:long call3[]={ /* plain function, 3 arguments */

g6.dat:422:close:};

g6.dat:423:open:long call4[]={ /* plain function, 4 arguments */

g6.dat:425:close:};

g6.dat:426:open:long call5[]={ /* plain function, 5 arguments */

g6.dat:428:close:};

g6.dat:429:open:long call2_0[]={/* two-step function, 0 arguments */

g6.dat:431:close:};

g6.dat:433:open:struct{

g6.dat:438:open:}bltin[]={

g6.dat:438:close:}bltin[]={

g6.dat:440:open: 0, {0, 0, 0}, 0, 0,

g6.dat:440:close: 0, {0, 0, 0}, 0, 0,

g6.dat:441:close:};

g6.dat:444:open:{

g6.dat:451:close:}

g6.dat:455:open:{

g6.dat:484:close:}

g6.dat:488:open:{

g6.dat:495:open: if(type==Sstruct){

g6.dat:498:close: }else

g6.dat:502:close:}

g6.dat:525:open:{

g6.dat:529:open: if(cflag){

g6.dat:533:close: }

g6.dat:535:open: if(errmark()){

g6.dat:540:close: }

g6.dat:545:close:}

g6.dat:548:open:{

g6.dat:552:open: switch(n->t){

g6.dat:559:open: if(n->l->t==NCall && !bflag){

g6.dat:562:close: }

g6.dat:567:open: switch(n->o.t){

g6.dat:584:close: }

g6.dat:601:open: switch(n->o.i){

g6.dat:607:open: if(eqtype(etypeof(n->l), &arychartype)){

g6.dat:610:close: }

g6.dat:704:open: if(isptrtype(etypeof(n->l))){

g6.dat:707:close: }else

g6.dat:711:open: if(retain && n->l->t==NID && isinttype(etypeof(n->l))){

g6.dat:714:close: }

g6.dat:741:close: }

g6.dat:753:open: switch(typeof(n)->o.t){

g6.dat:756:open: if(n->o.s->val->isauto){

g6.dat:759:open: }else{

g6.dat:759:close: }else{

g6.dat:762:close: }

g6.dat:768:open: if(n->o.s->val->isauto){

g6.dat:771:open: }else{

g6.dat:771:close: }else{

g6.dat:774:close: }

g6.dat:784:close: }

g6.dat:813:open: if(nscope==1){

g6.dat:821:close: }else

g6.dat:829:open: case NSmash:{

g6.dat:833:open: if(vr->type->o.t==TType){

g6.dat:837:close: }

g6.dat:842:open: if(isptrtype(vl->type)){

g6.dat:843:open: if(vl->isauto){

g6.dat:846:open: }else{

g6.dat:846:close: }else{

g6.dat:849:close: }

g6.dat:851:close: }

g6.dat:852:open: if(vl->isauto){

g6.dat:856:close: }

g6.dat:860:close: }

g6.dat:862:open: if(retain){

g6.dat:871:close: }

g6.dat:888:close: }

g6.dat:891:close:}

g6.dat:894:open:{

g6.dat:896:open: if(isstr){

g6.dat:900:open: }else{

g6.dat:900:close: }else{

g6.dat:905:close: }

g6.dat:906:open: if(a->t!=NID){

g6.dat:910:open: }else if(a->o.s->val->isauto){

g6.dat:910:close: }else if(a->o.s->val->isauto){

g6.dat:914:open: }else{

g6.dat:914:close: }else{

g6.dat:918:close: }

g6.dat:919:close:}

g6.dat:922:open:{

g6.dat:923:open: switch(n->t){

g6.dat:925:open: switch(typeof(n)->o.t){

g6.dat:927:open: if(n->o.s->val->isauto){

g6.dat:931:close: }

g6.dat:937:open: if(n->o.s->val->isauto){

g6.dat:941:close: }

g6.dat:949:open: if(n->o.s->val->isauto){

g6.dat:953:close: }

g6.dat:961:close: }

g6.dat:973:close: }

g6.dat:974:close:}

g6.dat:980:open:{

g6.dat:981:open: switch(n->t){

g6.dat:983:open: if(n->o.s->val->isauto){

g6.dat:987:close: }

g6.dat:1002:close: }

g6.dat:1003:close:}

g6.dat:1006:open:{

g6.dat:1013:open: if(n->r==0){

g6.dat:1016:close: }

g6.dat:1024:close:}

g6.dat:1027:open:{

g6.dat:1043:close:}

g6.dat:1046:open:{

g6.dat:1048:open: if(n->o.i){ /* enter loop at top, so jump to body */

g6.dat:1052:close: }

g6.dat:1054:open: if(n->r->r){ /* jump to condition */

g6.dat:1058:close: }

g6.dat:1064:open: if(n->r->r){

g6.dat:1068:close: }else

g6.dat:1071:close:}

g6.dat:1074:open:{

g6.dat:1093:close:}

g6.dat:1096:open:{

g6.dat:1113:open: else{

g6.dat:1116:open: sprint(buf, "prog(){call on line %d}", n->line);

g6.dat:1116:close: sprint(buf, "prog(){call on line %d}", n->line);

g6.dat:1120:close: }

g6.dat:1122:open: switch(callinst){

g6.dat:1140:close: }

g6.dat:1142:close:}

g6.dat:1145:open:{

g6.dat:1162:close:}

g6.dat:1165:open:{

g6.dat:1167:open: if(n->t==NList){

g6.dat:1171:close: }

g6.dat:1181:open: if(n->t==NArraycom){

g6.dat:1184:close: }else if(etypeoft(n)->o.t==TArray)

g6.dat:1188:close:}

g6.dat:1191:open:{

g6.dat:1193:open: if(n->t==NList){

g6.dat:1198:close: }

g6.dat:1207:open: if(c->o.t==\'=\'){

g6.dat:1210:close: }

g6.dat:1211:open: if(c->o.t==SND){

g6.dat:1217:close: }

g6.dat:1224:open: else if(c->t==NArraycom){

g6.dat:1229:close: }else

g6.dat:1231:open: if(c->t==NArraycom){ /* save array index */

g6.dat:1236:close: }

g6.dat:1242:close:}

g6.dat:1245:open:{

g6.dat:1261:close:}

g6.dat:1264:open:{

g6.dat:1267:open: if(s->t==NList){

g6.dat:1271:close: }

g6.dat:1278:open: else{

g6.dat:1280:open: if(isptr){ /* string */

g6.dat:1285:open: }else{

g6.dat:1285:close: }else{

g6.dat:1288:close: }

g6.dat:1293:close: }

g6.dat:1303:close:}

g6.dat:1306:open:{

g6.dat:1313:close:}

g6.dat:1316:open:{

g6.dat:1319:open: if(isptrtype(s->val->type)){

g6.dat:1322:close: }

g6.dat:1323:close:}

g6.dat:1326:open:{

g6.dat:1330:open: if(n->t==NExprlist){

g6.dat:1334:close: }

g6.dat:1336:open: switch(t->o.t){

g6.dat:1354:close: }

g6.dat:1355:close:}

g6.dat:1358:open:{

g6.dat:1373:open: if(errmark()){

g6.dat:1379:close: }

g6.dat:1404:close:}

g6.dat:1407:open:{

g6.dat:1408:open: if(returnloc){

g6.dat:1412:close: }

g6.dat:1420:close:}

g6.dat:1423:open:{

g6.dat:1426:open: if(types->t==NList){

g6.dat:1429:close: }

g6.dat:1433:open: if(isptrtype(types)){

g6.dat:1436:close: }

g6.dat:1438:close:}

g6.dat:1441:open:{

g6.dat:1444:close:}

g6.dat:1447:open:{

g6.dat:1448:open: switch(t->o.t){

g6.dat:1463:open: else{

g6.dat:1466:close: }

g6.dat:1469:open: if(v==0){

g6.dat:1473:close: }

g6.dat:1488:open: if(t->r->o.t==TChar){

g6.dat:1493:close: }else

g6.dat:1497:open: if(v==0){

g6.dat:1502:close: }

g6.dat:1506:open: if(v==0){

g6.dat:1509:close: }

g6.dat:1519:close: }

g6.dat:1520:close:}

g6.dat:1523:open:{

g6.dat:1524:open: switch(t->o.t){

g6.dat:1529:open: if(isptrtype(t)){

g6.dat:1532:open: }else if(t->o.t==TInt || t->o.t==TUnit){

g6.dat:1532:close: }else if(t->o.t==TInt || t->o.t==TUnit){

g6.dat:1535:close: }else if(t->o.t==TChar)

g6.dat:1540:open: case TStruct:{

g6.dat:1550:close: }

g6.dat:1555:close: }

g6.dat:1557:close:}

g6.dat:1560:open:{

g6.dat:1562:open: if(t->t==NList){

g6.dat:1566:close: }

g6.dat:1569:open: for(i=length(t); --i>=0; ){

g6.dat:1570:open: if(*pos==BPW){

g6.dat:1574:close: }

g6.dat:1578:close: }

g6.dat:1579:close:}

g6.dat:1582:open:{

g6.dat:1583:open: if(l<-2 || l>10){

g6.dat:1587:close: };

g6.dat:1588:open: switch((int)l){

g6.dat:1630:close: }

g6.dat:1631:close:}

g6.dat:1634:open:{

g6.dat:1637:open: switch(n->t){

g6.dat:1651:close: }

g6.dat:1653:close:}

g6.dat:1667:open:{

g6.dat:1672:open: switch(n->t){

g6.dat:1700:open: switch(n->o.i){

g6.dat:1742:close: }

g6.dat:1759:open: if(isconst(n->o.n)){

g6.dat:1763:open: if(topofstack()){

g6.dat:1766:open: }else{

g6.dat:1766:close: }else{

g6.dat:1769:close: }

g6.dat:1772:close: }

g6.dat:1821:close: }

g6.dat:1825:close:}

g6.dat:1828:open:{

g6.dat:1831:open: switch(n->t){

g6.dat:1837:open: switch(n->o.i){

g6.dat:1870:close: }

g6.dat:1895:close: }

g6.dat:1898:close:}

g6.dat:1902:open:{

g6.dat:1907:open: switch(t->o.t){

g6.dat:1917:open: if(t->r->o.t==TChar){

g6.dat:1927:close: }

g6.dat:1929:close: }

g6.dat:1931:close:}

g6.dat:1945:open:{

g6.dat:1950:close:}

g6.dat:1953:open:{

g6.dat:1959:close:}

g6.dat:1962:open:{

g6.dat:1968:close:}

g6.dat:1971:open:{

g6.dat:1974:close:}

g6.dat:1993:open:{

g6.dat:2000:open: if(proc->pc==0){

g6.dat:2005:close: }

g6.dat:2007:close:}

g6.dat:2010:open:{

g6.dat:2034:close:}

g6.dat:2037:open:{

g6.dat:2047:close:}

g6.dat:2050:open:{

g6.dat:2060:close:}

g6.dat:2072:open:{

g6.dat:2076:open: if(n->t==NList){

g6.dat:2080:close: }

g6.dat:2081:open: if(n->t==NDeclsc){

g6.dat:2084:close: }

g6.dat:2087:open: if(n->r==0){

g6.dat:2093:close: }

g6.dat:2094:open: if(dotypchk){

g6.dat:2096:open: if(n->o.n){

g6.dat:2111:close: }

g6.dat:2112:close: }

g6.dat:2113:open: if(docomp && n->o.n){

g6.dat:2118:close: }else

g6.dat:2121:open: if(n->o.n && docomp && nscope==0){

g6.dat:2125:close: }

g6.dat:2126:close:}

g6.dat:2130:open:{

g6.dat:2131:open: if(id->t==NList){

g6.dat:2135:close: }

g6.dat:2146:close:}

g6.dat:2150:open: * rec {

g6.dat:2153:close: * };

g6.dat:2164:open: * rec type T: struct of { t:T; };

g6.dat:2164:close: * rec type T: struct of { t:T; };

g6.dat:2171:open:{

g6.dat:2173:open: if(n->t==NDeclsc){

g6.dat:2176:close: }

g6.dat:2177:open: if(n->r==0){

g6.dat:2182:open: }else if(n->r->o.t==TType){

g6.dat:2182:close: }else if(n->r->o.t==TType){

g6.dat:2186:close: }

g6.dat:2190:close:}

g6.dat:2194:open:{

g6.dat:2197:open: if(n->t==NDeclsc){

g6.dat:2200:close: }

g6.dat:2207:close:}

g6.dat:2211:open:{

g6.dat:2222:close:}

g6.dat:2226:open:{

g6.dat:2230:close:}

g6.dat:2233:open:{

g6.dat:2243:close:}

g6.dat:2249:open: * prog(a:int){

g6.dat:2250:open: * begin prog(b:int){ f(a, b); }(b);

g6.dat:2250:close: * begin prog(b:int){ f(a, b); }(b);

g6.dat:2251:close: * }

g6.dat:2255:open: * prog(a:int){

g6.dat:2256:open: * begin prog(b:int, a:int){ f(a, b); }(b, a);

g6.dat:2256:close: * begin prog(b:int, a:int){ f(a, b); }(b, a);

g6.dat:2257:close: * }

g6.dat:2267:open:{

g6.dat:2276:close:}

g6.dat:2279:open:{

g6.dat:2290:close:}

g6.dat:2293:open:{

g6.dat:2295:open: if(!alreadyformal(n, begf)){

g6.dat:2306:close: }

g6.dat:2307:close:}

g6.dat:2310:open:{

g6.dat:2316:close:}

g6.dat:2319:open:{

g6.dat:2322:open: switch(n->t){

g6.dat:2346:open: if(0<n->o.s->val->scope && n->o.s->val->scope<fscope){

g6.dat:2350:close: }

g6.dat:2397:close: }

g6.dat:2400:close:}

g6.dat:2411:open:{

g6.dat:2418:close:}

g6.dat:2421:open:{

g6.dat:2428:close:}

g6.dat:2431:open:{

g6.dat:2438:close:}

g6.dat:2441:open:{

g6.dat:2446:close:}

g6.dat:2449:open:{

g6.dat:2455:close:}

g6.dat:2458:open:{

g6.dat:2465:close:}

g6.dat:2468:open:{

g6.dat:2474:close:}

g6.dat:2477:open:{

g6.dat:2483:close:}

g6.dat:2486:open:{

g6.dat:2492:close:}

g6.dat:2498:open:prbuf(){

g6.dat:2502:close:}

g6.dat:2505:open:{

g6.dat:2511:open: else{

g6.dat:2512:open: switch(t){

g6.dat:2561:close: }

g6.dat:2563:close: }

g6.dat:2566:close:}

g6.dat:2569:open:{

g6.dat:2572:open: switch(n->t){

g7.dat:9:open:{

g7.dat:16:open: else if (c != n) {

g7.dat:23:close: } else if(rebuf->w == rebuf->s)

g7.dat:25:open: else {

g7.dat:26:open: if (sub) {

g7.dat:32:close: }

g7.dat:34:close: }

g7.dat:36:close:}

g7.dat:40:open:{

g7.dat:41:open: if(code && code != REG_NOMATCH) {

g7.dat:45:close: }

g7.dat:46:close:}

g7.dat:50:open:{

g7.dat:55:close:}

g7.dat:59:open:{

g7.dat:64:open: if(n = regsubexec(re, (char*)data->s, elementsof(matches), matches)) {

g7.dat:67:close: }

g7.dat:73:close:}'

EXEC -n -m -e include:include -e define:define g6.dat g7.dat

OUTPUT - $'g6.dat:1:include:#include "alloc.h"

g6.dat:2:include:#include <libc.h>

g6.dat:25:include:#include "alloc.h"

g6.dat:26:include:#include "word.h"

g6.dat:27:include:#include "store.h"

g6.dat:28:include:#include "comm.h"

g6.dat:29:include:#include <libc.h>

g6.dat:393:include:#include "node.h"

g6.dat:394:include:#include "symbol.h"

g6.dat:395:include:#include "alloc.h"

g6.dat:396:include:#include "word.h"

g6.dat:397:include:#include "store.h"

g6.dat:398:include:#include "comm.h"

g6.dat:399:include:#include "inst.h"

g6.dat:400:include:#include <libc.h>

g6.dat:402:define:#define FNS

g6.dat:403:include:#include "lib.h"

g6.dat:406:define:#define C 0x40000000

g6.dat:407:define:#define I 0x20000000

g6.dat:408:define:#define F 0x10000000

g6.dat:409:define:#define M(x) ((x)&~(C|I|F))

g6.dat:439:include:#include "lib.h"

g6.dat:503:include:#include "node.h"

g6.dat:504:include:#include "symbol.h"

g6.dat:505:include:#include "alloc.h"

g6.dat:506:include:#include "ydefs.h"

g6.dat:507:include:#include "word.h"

g6.dat:508:include:#include "store.h"

g6.dat:509:include:#include "comm.h"

g6.dat:510:include:#include "inst.h"

g6.dat:511:include:#include "errjmp.h"

g6.dat:512:include:#include <libc.h>

g6.dat:1654:include:#include "alloc.h"

g6.dat:1655:include:#include "node.h"

g6.dat:1656:include:#include "symbol.h"

g6.dat:1657:include:#include "ydefs.h"

g6.dat:1658:include:#include "word.h"

g6.dat:1659:include:#include "store.h"

g6.dat:1660:include:#include <libc.h>

g6.dat:1932:include:#include "alloc.h"

g6.dat:1933:include:#include "word.h"

g6.dat:1934:include:#include "store.h"

g6.dat:1935:include:#include "comm.h"

g6.dat:1936:include:#include <libc.h>

g6.dat:2016:include: nargs+=2; /* includes result and sym; add pc, fp */

g6.dat:2061:include:#include "node.h"

g6.dat:2062:include:#include "symbol.h"

g6.dat:2063:include:#include "alloc.h"

g6.dat:2064:include:#include "ydefs.h"

g6.dat:2065:include:#include "word.h"

g6.dat:2066:include:#include "store.h"

g6.dat:2067:include:#include <libc.h>

g6.dat:2402:include:#include "nodenames.h"

g6.dat:2403:include:#include "typenames.h"

g6.dat:2404:include:#include "errjmp.h"

g6.dat:2405:include:#include "node.h"

g6.dat:2406:include:#include "symbol.h"

g6.dat:2407:include:#include "ydefs.h"

g6.dat:2408:include:#include <libc.h>

g7.dat:3:include:#include "sed.h" /* define sed stuff */

g7.dat:3:define:#include "sed.h" /* define sed stuff */'

EXEC -c -m -e open:{ -e close:} g6.dat g7.dat

OUTPUT - $'g6.dat:open:238

g6.dat:close:236

g7.dat:open:9

g7.dat:close:9'

EXEC -c -m -e include:include -e define:define g6.dat g7.dat

OUTPUT - $'g6.dat:include:54

g6.dat:define:5

g7.dat:include:1

g7.dat:define:1'

EXEC -h -m -e open:{ -e close:} g6.dat g7.dat

OUTPUT - $'open:{

open: if(p==0){

close: }

close:}

open:{

open: if(p==0){

close: }

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

open: if(proc->prbuf==0){

close: }

open: if(n+proc->nprbuf+1>proc->maxprbuf){

close: }

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:{

close:}

open:long call0[]={ /* plain function, 0 arguments */

close:};

open:long call1[]={ /* plain function, 1 argument */

close:};

open:long call2[]={ /* plain function, 2 arguments */

close:};

open:long call3[]={ /* plain function, 3 arguments */

close:};

open:long call4[]={ /* plain function, 4 arguments */

close:};

open:long call5[]={ /* plain function, 5 arguments */

close:};

open:long call2_0[]={/* two-step function, 0 arguments */

close:};

open:struct{

open:}bltin[]={

close:}bltin[]={

open: 0, {0, 0, 0}, 0, 0,

close: 0, {0, 0, 0}, 0, 0,

close:};

open:{

close:}

open:{

close:}

open:{

open: if(type==Sstruct){

close: }else

close:}

open:{

open: if(cflag){

close: }

open: if(errmark()){

close: }

close:}

open:{

open: switch(n->t){

open: if(n->l->t==NCall && !bflag){

close: }

open: switch(n->o.t){

close: }

open: switch(n->o.i){

open: if(eqtype(etypeof(n->l), &arychartype)){

close: }

open: if(isptrtype(etypeof(n->l))){

close: }else

open: if(retain && n->l->t==NID && isinttype(etypeof(n->l))){

close: }

close: }

open: switch(typeof(n)->o.t){

open: if(n->o.s->val->isauto){

open: }else{

close: }else{

close: }

open: if(n->o.s->val->isauto){

open: }else{

close: }else{

close: }

close: }

open: if(nscope==1){

close: }else

open: case NSmash:{

open: if(vr->type->o.t==TType){

close: }

open: if(isptrtype(vl->type)){

open: if(vl->isauto){

open: }else{

close: }else{

close: }

close: }

open: if(vl->isauto){

close: }

close: }

open: if(retain){

close: }

close: }

close:}

open:{

open: if(isstr){

open: }else{

close: }else{

close: }

open: if(a->t!=NID){

open: }else if(a->o.s->val->isauto){

close: }else if(a->o.s->val->isauto){

open: }else{

close: }else{

close: }

close:}

open:{

open: switch(n->t){

open: switch(typeof(n)->o.t){

open: if(n->o.s->val->isauto){

close: }

open: if(n->o.s->val->isauto){

close: }

open: if(n->o.s->val->isauto){

close: }

close: }

close: }

close:}

open:{

open: switch(n->t){

open: if(n->o.s->val->isauto){

close: }

close: }

close:}

open:{

open: if(n->r==0){

close: }

close:}

open:{

close:}

open:{

open: if(n->o.i){ /* enter loop at top, so jump to body */

close: }

open: if(n->r->r){ /* jump to condition */

close: }

open: if(n->r->r){

close: }else

close:}

open:{

close:}

open:{

open: else{

open: sprint(buf, "prog(){call on line %d}", n->line);

close: sprint(buf, "prog(){call on line %d}", n->line);

close: }

open: switch(callinst){

close: }

close:}

open:{

close:}

open:{

open: if(n->t==NList){

close: }

open: if(n->t==NArraycom){

close: }else if(etypeoft(n)->o.t==TArray)

close:}

open:{

open: if(n->t==NList){

close: }

open: if(c->o.t==\'=\'){

close: }

open: if(c->o.t==SND){

close: }

open: else if(c->t==NArraycom){

close: }else

open: if(c->t==NArraycom){ /* save array index */

close: }

close:}

open:{

close:}

open:{

open: if(s->t==NList){

close: }

open: else{

open: if(isptr){ /* string */

open: }else{

close: }else{

close: }

close: }

close:}

open:{

close:}

open:{

open: if(isptrtype(s->val->type)){

close: }

close:}

open:{

open: if(n->t==NExprlist){

close: }

open: switch(t->o.t){

close: }

close:}

open:{

open: if(errmark()){

close: }

close:}

open:{

open: if(returnloc){

close: }

close:}

open:{

open: if(types->t==NList){

close: }

open: if(isptrtype(types)){

close: }

close:}

open:{

close:}

open:{

open: switch(t->o.t){

open: else{

close: }

open: if(v==0){

close: }

open: if(t->r->o.t==TChar){

close: }else

open: if(v==0){

close: }

open: if(v==0){

close: }

close: }

close:}

open:{

open: switch(t->o.t){

open: if(isptrtype(t)){

open: }else if(t->o.t==TInt || t->o.t==TUnit){

close: }else if(t->o.t==TInt || t->o.t==TUnit){

close: }else if(t->o.t==TChar)

open: case TStruct:{

close: }

close: }

close:}

open:{

open: if(t->t==NList){

close: }

open: for(i=length(t); --i>=0; ){

open: if(*pos==BPW){

close: }

close: }

close:}

open:{

open: if(l<-2 || l>10){

close: };

open: switch((int)l){

close: }

close:}

open:{

open: switch(n->t){

close: }

close:}

open:{

open: switch(n->t){

open: switch(n->o.i){

close: }

open: if(isconst(n->o.n)){

open: if(topofstack()){

open: }else{

close: }else{

close: }

close: }

close: }

close:}

open:{

open: switch(n->t){

open: switch(n->o.i){

close: }

close: }

close:}

open:{

open: switch(t->o.t){

open: if(t->r->o.t==TChar){

close: }

close: }

close:}

open:{

close:}