Thread View: pe.cust.sources
1 messages
1 total messages
Started by Earl Wallace
Thu, 13 Jun 1985 19:13
Little Smalltalk Source, *New* Part 6 of 20
Author: Earl Wallace
Date: Thu, 13 Jun 1985 19:13
Date: Thu, 13 Jun 1985 19:13
2074 lines
58549 bytes
58549 bytes
#! /bin/sh
#
# This is an another posting of the Little Smalltalk source, the last posting
# of this source went out in 5 parts and they were too big (>200k) for most
# sites so I redid the whole mess to keep the files around the 50k range.
#
# The complete set is now 20 parts.
#
# P.S. - If you don't receive all 20 parts within 5 days, drop me a line.
# Also, I have the Rand sources of May 1984, if someone has a more
# updated copy, I'll be happy to post them (or YOU can post them :-))
#
# -earlw@pesnta
#
#! /bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #! /bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create the files:
# parser/parser.h
# parser/parser.lex
# parser/parser.y
# parser/uchar.c
# parser/y.tab.c
# parser/y.tab.h
# prelude/Makefile
# prelude/acollection.p
# prelude/acollection.st
# prelude/array.p
# prelude/array.st
# prelude/bag.p
# prelude/bag.st
# prelude/block.p
# prelude/block.st
# This archive created: Thu Jun 13 11:31:53 1985
# By: Earl Wallace (Perkin-Elmer Data Systems Group / Customer Service)
export PATH; PATH=/bin:$PATH
if test -f 'parser/parser.h'
then
echo shar: will not over-write existing file "'parser/parser.h'"
else
cat << \SHAR_EOF > 'parser/parser.h'
/*
Little Smalltalk
definitions used by parser
*/
enum vartypes {instvar, argvar, tempvar};
struct varstruct {
struct varstruct *nextvar;
enum vartypes vtype;
char *text;
short position;
};
enum objtypes {classobj, varobj, instvarobj, contvarobj,
litobj, pseuobj, primobj, exprobj, blockobj};
struct objstruct {
enum objtypes objtype;
union {
char *varname;
int varoffset;
struct litstruct *litinfo;
enum pseuvars pseuinfo;
struct primstruct *priminfo;
struct statestruct *stateinfo;
struct blockstruct *blockinfo;
} ee;
};
struct blockstruct {
int arglocation;
int numargs;
struct statestruct *bstates;
};
enum littypes {numlit, fnumlit, charlit, strlit, symlit, arlit, bytelit};
struct litstruct {
enum littypes littype;
union {
int litint;
char litchar;
char *litstr;
char *litsym;
struct litlist *litarry;
} ll;
};
struct litlist {
struct litstruct *litele;
struct litlist *nextlit;
int litposition;
};
struct primstruct {
int primnumber;
struct primlist *plist;
} ;
struct primlist {
struct primlist *nextprim;
struct objstruct *pobject;
};
enum cmdtypes {reccmd, uncmd, bincmd, keycmd, semistart, semiend};
struct exprstruct {
enum cmdtypes cmdtype;
char *cmdname;
struct exprstruct *receiver;
union {
struct exprstruct *argument;
struct keylist *keys;
struct objstruct *recobj;
} cc;
struct exprstruct *nextcmd;
};
enum statetypes {blkupar, upar, asgn, iasgn, casgn, expr};
struct statestruct {
enum statetypes statetype;
struct statestruct *nextstate;
union {
struct varstruct *variable;
int varpos;
} mm;
union {
struct statestruct *stateexpr;
struct exprstruct *cmd;
} nn;
};
struct keylist {
char *keyword;
struct exprstruct *arg;
struct keylist *nextkey;
};
struct methodstruct {
struct exprstruct *pattern;
int numtempvars;
struct statestruct *states;
struct methodstruct *nextmethod;
};
struct classstruct {
char *name;
char *super;
};
# define structalloc(type) (struct type *) alloc(sizeof (struct type ))
extern struct varstruct *instvars;
extern struct varstruct *contextvars;
# define addinst(x) (instvars = addvlist(mkvar(x, instvar), instvars))
extern char *walloc();
SHAR_EOF
if test 2746 -ne "`wc -c < 'parser/parser.h'`"
then
echo shar: error transmitting "'parser/parser.h'" '(should have been 2746 characters)'
fi
fi # end of overwriting check
if test -f 'parser/parser.lex'
then
echo shar: will not over-write existing file "'parser/parser.lex'"
else
cat << \SHAR_EOF > 'parser/parser.lex'
%{
/*
Little Smalltalk lexical analyzer
*/
# include <math.h>
# undef input
# undef unput
double atof();
int linenum = 1;
%}
%%
[ \t]+ {;}
\n {linenum++;}
\" {readcomment();}
":=" {return(ASSIGN);}
"<-" {return(ASSIGN);}
Class {return(lexsave(CLASS));}
self {yylval.p = selfvar; return(PSEUDO);}
selfProcess {yylval.p = procvar; return(PSEUDO);}
super {yylval.p = supervar; return(PSEUDO);}
nil {yylval.p = nilvar; return(PSEUDO);}
true {yylval.p = truevar; return(PSEUDO);}
false {yylval.p = falsevar; return(PSEUDO);}
smalltalk {yylval.p = smallvar; return(PSEUDO);}
\$. {yylval.i = yytext[1]; return(LITCHAR);}
# {return(PS);}
[0-9]+r-?[0-9A-Z]+(\.[0-9A-Z]+)?(e[-+]?[0-9]+)? {return(lexsave(LITFNUM));}
[0-9]+ {yylval.i = atoi(yytext); return(LITNUM);}
[0-9]+(\.[0-9]+)?(e[-+]?[0-9]+)? {return(lexsave(LITFNUM));}
'[^']*' {char c; unput(c = input());
if (c == '\'') yymore();
else return(lexlstr());}
[a-zA-Z0-9]+:? {return(varlex());}
:[a-zA-Z0-9]+ {return(slexsave(COLONVAR));}
#[^ \t\n.()\[]+ {return(slexsave(LITSYM));}
"-" {return(lexsave(MINUS));}
"(" {return(LP);}
")" {return(RP);}
"[" {return(LB);}
"]" {return(RB);}
"." {return(PERIOD);}
^"|" {return(lexsave(MBAR));}
^"!" {return(lexsave(MBAR));}
"|" {return(lexsave(BAR));}
"!" {return(lexsave(BAR));}
";" {return(SEMI);}
"^" {return(lexsave(UPARROW));}
">" {return(lexsave(PE));}
[^ \t\nA-Za-z0-9] {return(lexsave(BINARY));}
"<primitive" {return(PRIMITIVE);}
%%
static int ocbuf = 0;
static int pbbuf[400];
static int input()
{ int c;
if (ocbuf) {c = pbbuf[--ocbuf]; }
else {
c = getc(fp);
if (c == EOF) c = 0;
}
return(c);
}
static unput(c)
char c;
{
if (c) pbbuf[ocbuf++] = c;
}
# include <ctype.h>
static readcomment()
{ char c;
while ((c = input()) && c != '\"')
if (c == '\n') linenum++;
if (!c) yyerror("unterminated comment");
}
char *walloc(s) char *s;
{ char *p, *malloc();
p = malloc((unsigned) (strlen(s) + 1));
if (p == (char *) 0) yyerror("out of variable string space");
strcpy(p, s);
return(p);
}
static int slexsave(type)
int type;
{
yylval.c = walloc(&yytext[1]);
if (yylval.c == 0) yerr("cannot create symbol %s", yytext);
return(type);
}
static int lexsave(type)
int type;
{
yylval.c = walloc(yytext);
if (yylval.c == 0) yerr("cannot create string %s", yytext);
return(type);
}
static int varlex()
{
lexsave(0);
if (yytext[yyleng-1] == ':') return(KEYWORD);
else if (islower(yytext[0])) return(LOWERCASEVAR);
else return(UPPERCASEVAR);
}
static int lexlstr()
{ char *p, *q;
yylval.c = p = walloc(&yytext[1]);
*(p + yyleng -2) = '\0';
return(LITSTR);
}
SHAR_EOF
if test 3484 -ne "`wc -c < 'parser/parser.lex'`"
then
echo shar: error transmitting "'parser/parser.lex'" '(should have been 3484 characters)'
fi
fi # end of overwriting check
if test -f 'parser/parser.y'
then
echo shar: will not over-write existing file "'parser/parser.y'"
else
cat << \SHAR_EOF > 'parser/parser.y'
/*
Little Smalltalk Class method syntax
differs from smalltalk-80 slightly
class heading is different
vertical bar must appear between methods
syntax for primitives is different
*/
/* literals */
%token LITNUM LITFNUM LITCHAR LITSTR LITSYM
/* basic objects */
%token CLASS ASSIGN BINARY PRIMITIVE
/* types of variables */
%token PSEUDO UPPERCASEVAR LOWERCASEVAR COLONVAR KEYWORD
/* one character symbols */
%token LP RP LB RB PERIOD BAR MBAR SEMI UPARROW PS MINUS PE
/* ( ) [ ] . | ^| ; ^ # - > */
%{
# include "env.h"
# include "drive.h"
# include "parser.h"
%}
%union {
struct litlist *a;
struct blockstruct *b;
char *c;
struct exprstruct *e;
int i;
struct keylist *k;
struct classstruct *l;
struct methodstruct *m;
struct objstruct *o;
enum pseuvars p;
struct primlist *r;
struct statestruct *s;
struct litstruct *t;
struct primstruct *u
}
%{
extern struct blockstruct *mkblock();
extern struct classstruct *mkclass();
extern struct varstruct *mkvar(), *addvlist(), *invlist();
extern struct methodstruct *mkmethod();
extern struct exprstruct *mkexpr(), *mkkey();
extern struct keylist *mkklist();
extern struct statestruct *mkstate();
extern struct objstruct *mkobj();
extern struct primstruct *mkprim();
extern struct primlist *addprim();
extern struct litstruct *mklit();
extern struct litlist *addlit();
extern char *bincat();
struct varstruct *instvars;
struct varstruct *contextvars;
int bytetop = 0;
uchar bytearray[1000];
YYSTYPE e;
int errorcount = 0;
%}
%type <a> litarray
%type <b> block
%type <c> CLASS KEYWORD LOWERCASEVAR UPPERCASEVAR COLONVAR LITSYM LITSTR
%type <c> BINARY BAR MINUS UPARROW PE
%type <c> classname binarysym binarychar
%type <c> LITFNUM fliteral
%type <e> pattern expression cexpression binary unary
%type <e> kcontinuation bcontinuation ucontinuation
%type <i> LITCHAR LITNUM PRIMITIVE
%type <i> tempvars cvarlist namelist barglist nliteral
%type <k> keypattern keywordlist
%type <l> super classheading
%type <m> method methodlist
%type <o> primary
%type <p> PSEUDO
%type <r> objlist
%type <s> statelist statement sexpression opmessagelist
%type <s> bstatelist bstatement bexpression
%type <t> literal iliteral aliteral
%type <u> primitive
%start file
%%
file : classdef
| file classdef
;
classdef: classheading lb methodlist RB
{if (errorcount == 0) genclass($1, $3);}
;
lb : LB
| error {if ((yytext[0] == ':') ||
isalpha(yytext[0])) expect(":SuperClass");
else expect("open brace [");}
;
classheading: class super instancevars {$$ = $2;}
;
class : CLASS
| error {expect("keyword Class");}
;
super : classname {$$ = mkclass($1, (char *) 0);}
| classname COLONVAR {$$ = mkclass($1, $2);}
| error {expect("Classname :Superclass");
$$ = mkclass("Error", (char *) 0);}
;
classname: UPPERCASEVAR
| CLASS
;
instancevars: /* empty */
| bar instvarlist bar
;
instvarlist: LOWERCASEVAR {addinst($1);}
| instvarlist LOWERCASEVAR {addinst($2);}
| error {expect("instance variable");}
;
methodlist: method
| methodlist MBAR method
{$3->nextmethod = $1; $$ = $3;}
;
method : pattern tempvars statelist op
{deltemps($2); $$ = mkmethod($1, $2, $3);}
;
pattern: keypattern
{$$ = mkkey((struct exprstruct *) 0, $1);}
| binarysym argvariable
{$$ = mkexpr((struct exprstruct *) 0, bincmd, $1, (struct exprstruct *) 0);}
| LOWERCASEVAR
{$$ = mkexpr((struct exprstruct *) 0, uncmd, $1, (struct exprstruct *) 0);}
| error {expect("method pattern");
$$ = mkexpr((struct exprstruct *) 0, uncmd, "", (struct exprstruct *) 0);}
;
keypattern: KEYWORD argvariable
{$$ = mkklist((struct keylist *) 0, $1, (struct exprstruct *) 0);}
| keypattern KEYWORD argvariable
{$$ = mkklist($1, $2, (struct exprstruct *) 0);}
;
argvariable: LOWERCASEVAR {addtemp($1, argvar);}
| error {expect("argument variable");}
;
tempvars: /* empty */ {$$ = 0;}
| bar namelist bar {$$ = $2;}
;
bar : BAR
| MBAR
| error {expect("| (vertical bar)");}
;
namelist: tvariable {$$ = 1;}
| namelist tvariable {$$ = $1 + 1;}
;
tvariable: LOWERCASEVAR {addtemp($1, tempvar);}
;
statelist: statement {$$ = $1;}
| statelist PERIOD statement {$3->nextstate = $1; $$ = $3;}
;
op : /* empty - optional period */
| PERIOD
;
statement: UPARROW sexpression {$$ = mkstate(upar, (char *) 0, $2);}
| sexpression
;
sexpression: LOWERCASEVAR ASSIGN sexpression
{$$ = mkstate(asgn, $1, $3);}
| cexpression
{$$ = mkstate(expr, (char *) 0, (struct statestruct *) $1);}
;
cexpression: expression
| kcontinuation {$$ = mkexpr($1, semiend, 0, 0);}
;
kcontinuation: bcontinuation
| bcontinuation keywordlist {$$ = mkkey($1, $2);}
;
bcontinuation: ucontinuation
| bcontinuation binarysym unary
{$$ = mkexpr($1, bincmd, $2, $3);}
;
ucontinuation: cexpression SEMI {$$ = mkexpr($1, semistart, 0, 0);}
| ucontinuation LOWERCASEVAR
{$$ = mkexpr($1, uncmd, $2, (struct exprstruct *) 0);}
;
expression: binary {$$ = $1;}
| binary keywordlist {$$ = mkkey($1, $2);}
;
keywordlist: KEYWORD binary
{$$ = mkklist((struct keylist *) 0, $1, $2);}
| keywordlist KEYWORD binary
{$$ = mkklist($1, $2, $3);}
;
binary : unary {$$ = $1;}
| binary binarysym unary {$$ = mkexpr($1, bincmd, $2, $3);}
;
binarysym: binarychar {$$ = $1;}
| binarychar binarychar {$$ = bincat($1, $2);}
;
binarychar: BINARY
| BAR
| MINUS
| UPARROW
| PE
;
unary : primary
{$$ = mkexpr((struct exprstruct *) 0, reccmd, (char *) 0,
(struct exprstruct *) $1);}
| unary LOWERCASEVAR
{$$ = mkexpr($1, uncmd, $2, (struct exprstruct *) 0);}
;
primary : classname {e.c = $1; $$ = mkobj(classobj, &e);}
| LOWERCASEVAR {e.c = $1; $$ = mkobj(varobj, &e);}
| literal {e.t = $1; $$ = mkobj(litobj, &e);}
| PSEUDO {e.p = $1; $$ = mkobj(pseuobj, &e);}
| primitive {e.u = $1; $$ = mkobj(primobj, &e);}
| LP sexpression RP {e.s = $2; $$ = mkobj(exprobj, &e);}
| block {e.b = $1; $$ = mkobj(blockobj, &e);}
;
primitive: PRIMITIVE LITNUM objlist PE
{$$ = mkprim($2, $3);}
;
objlist : /* empty */ {$$ = (struct primlist *) 0;}
| objlist primary {$$ = addprim($1, $2);}
;
block : LB barglist opmessagelist RB
{$$ = mkblock($2, $3);
deltemps($2);}
;
barglist : /* empty */ {$$ = 0;}
| cvarlist BAR {$$ = $1;}
;
cvarlist: COLONVAR {addtemp($1, argvar); $$ = 1;}
| cvarlist COLONVAR {addtemp($2, argvar); $$ = $1 + 1;}
;
opmessagelist: bstatelist bstatement {$2->nextstate = $1; $$ = $2;}
| bstatement {$$ = $1;}
;
bstatement: UPARROW sexpression {$$ = mkstate(blkupar, (char *) 0, $2);}
| bexpression {$$ = mkstate(upar, (char *) 0, $1);}
;
bexpression: /* empty */
{e.p = nilvar;
$$ = mkstate(expr, (char *) 0,
(struct statestruct *) mkexpr((struct exprstruct *) 0, reccmd, (char *) 0,
(struct exprstruct *) mkobj(pseuobj, &e)));}
| sexpression {$$ = $1;}
;
bstatelist: sexpression PERIOD {$$ = $1;}
| bstatelist sexpression PERIOD
{$2->nextstate = $1; $$ = $2;}
;
literal : iliteral {$$ = $1;}
| alitstart litarray RP {e.a = $2; $$ = mklit(arlit, &e);}
;
alitstart: PS LP
;
iliteral: fliteral {e.c = $1; $$ = mklit(fnumlit, &e);}
| nliteral {e.i = $1; $$ = mklit(numlit, &e);}
| LITCHAR {e.i = $1; $$ = mklit(charlit, &e);}
| LITSTR {e.c = $1; $$ = mklit(strlit, &e);}
| LITSYM {e.c = $1; $$ = mklit(symlit, &e);}
| PS LB bytearray RB {bytearray[bytetop] = '\0';
$$ = mklit(bytelit, &e);}
;
fliteral: LITFNUM {$$ = $1;}
| MINUS LITFNUM {$$ = bincat("-", $2);}
;
nliteral: LITNUM {$$ = $1;}
| MINUS LITNUM {$$ = - $2;}
;
aliteral: iliteral {$$ = $1;}
| LOWERCASEVAR {e.c = $1; $$ = mklit(symlit, &e);}
| UPPERCASEVAR {e.c = $1; $$ = mklit(symlit, &e);}
| KEYWORD {e.c = $1; $$ = mklit(symlit, &e);}
| COLONVAR {e.c = $1; $$ = mklit(symlit, &e);}
| CLASS {e.c = $1; $$ = mklit(symlit, &e);}
| binarysym {e.c = $1; $$ = mklit(symlit, &e);}
| ias litarray RP {e.a = $2; $$ = mklit(arlit, &e);}
;
ias : PS LP
| LP
;
litarray: /* empty */ {$$ = (struct litlist *) 0;}
| litarray aliteral {$$ = addlit($1, $2);}
;
bytearray: LITNUM {bytetop = 0;
bytearray[bytetop++] = itouc($1);}
| bytearray LITNUM {bytearray[bytetop++] = itouc($2);}
;
%%
# include <stdio.h>
char *filename;
FILE *fp;
FILE *ofd;
# include "lex.yy.c"
main(argc, argv)
int argc;
char **argv;
{
if (argc != 2) quiter("parser: wrong number of arguments");
filename = argv[1];
fp = fopen(filename, "r");
if (fp == NULL) {
yerr("cannot open input file %s", filename);
quiter("parser quits");
}
ofd = stdout;
return(yyparse());
}
quiter(s) char *s; {fprintf(stderr,"%s\n", s); exit(1);}
yywarn(s, v) char *s, *v; {
fprintf(stderr, "%s: line %d: Warning ", filename, linenum);
fprintf(stderr, s, v);
fprintf(stderr,"\n");
}
yyerror(s) char *s; {yerr(s, "");}
yerr(s, v)
char *s, *v;
{
fprintf(stderr, "%s: line %d: ", filename, linenum);
fprintf(stderr, s, v);
fprintf(stderr,"\n");
if (errorcount++ > 10) quiter("too many errors, goodby");
}
expect(str) char *str;
{ char buffer[100];
sprintf(buffer,"Expected %%s found %s", yytext);
yerr(buffer, str);
}
int yywrap() { return(1);}
char *alloc(size) int size; /* allocate a block of storage */
{ char *p, *malloc();
p = malloc( (unsigned) size);
if (p == (char *) 0) yyerror("out of free space");
return(p);
}
char *bincat(s1, s2)
char *s1, *s2;
{ char *p;
p = alloc(strlen(s1) + strlen(s2) + 1);
strcpy(p, s1);
strcat(p, s2);
return(p);
}
SHAR_EOF
if test 11138 -ne "`wc -c < 'parser/parser.y'`"
then
echo shar: error transmitting "'parser/parser.y'" '(should have been 11138 characters)'
fi
fi # end of overwriting check
if test -f 'parser/uchar.c'
then
echo shar: will not over-write existing file "'parser/uchar.c'"
else
cat << \SHAR_EOF > 'parser/uchar.c'
# include "env.h"
main() {
int i;
uchar c;
i = 250;
c = itouc(i);
i = uctoi(c);
if (i == 250) printf("success\n");
else printf("failure\n");
}
SHAR_EOF
if test 164 -ne "`wc -c < 'parser/uchar.c'`"
then
echo shar: error transmitting "'parser/uchar.c'" '(should have been 164 characters)'
fi
fi # end of overwriting check
if test -f 'parser/y.tab.c'
then
echo shar: will not over-write existing file "'parser/y.tab.c'"
else
cat << \SHAR_EOF > 'parser/y.tab.c'
# define LITNUM 257
# define LITFNUM 258
# define LITCHAR 259
# define LITSTR 260
# define LITSYM 261
# define CLASS 262
# define ASSIGN 263
# define BINARY 264
# define PRIMITIVE 265
# define PSEUDO 266
# define UPPERCASEVAR 267
# define LOWERCASEVAR 268
# define COLONVAR 269
# define KEYWORD 270
# define LP 271
# define RP 272
# define LB 273
# define RB 274
# define PERIOD 275
# define BAR 276
# define MBAR 277
# define SEMI 278
# define UPARROW 279
# define PS 280
# define MINUS 281
# define PE 282
# line 26 "parser.y"
# include "env.h"
# include "drive.h"
# include "parser.h"
# line 31 "parser.y"
typedef union {
struct litlist *a;
struct blockstruct *b;
char *c;
struct exprstruct *e;
int i;
struct keylist *k;
struct classstruct *l;
struct methodstruct *m;
struct objstruct *o;
enum pseuvars p;
struct primlist *r;
struct statestruct *s;
struct litstruct *t;
struct primstruct *u
} YYSTYPE;
# line 49 "parser.y"
extern struct blockstruct *mkblock();
extern struct classstruct *mkclass();
extern struct varstruct *mkvar(), *addvlist(), *invlist();
extern struct methodstruct *mkmethod();
extern struct exprstruct *mkexpr(), *mkkey();
extern struct keylist *mkklist();
extern struct statestruct *mkstate();
extern struct objstruct *mkobj();
extern struct primstruct *mkprim();
extern struct primlist *addprim();
extern struct litstruct *mklit();
extern struct litlist *addlit();
extern char *bincat();
struct varstruct *instvars;
struct varstruct *contextvars;
int bytetop = 0;
uchar bytearray[1000];
YYSTYPE e;
int errorcount = 0;
#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar;
extern short yyerrflag;
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 150
#endif
YYSTYPE yylval, yyval;
# define YYERRCODE 256
# line 348 "parser.y"
# include <stdio.h>
char *filename;
FILE *fp;
FILE *ofd;
# include "lex.yy.c"
main(argc, argv)
int argc;
char **argv;
{
if (argc != 2) quiter("parser: wrong number of arguments");
filename = argv[1];
fp = fopen(filename, "r");
if (fp == NULL) {
yerr("cannot open input file %s", filename);
quiter("parser quits");
}
ofd = stdout;
return(yyparse());
}
quiter(s) char *s; {fprintf(stderr,"%s\n", s); exit(1);}
yywarn(s, v) char *s, *v; {
fprintf(stderr, "%s: line %d: Warning ", filename, linenum);
fprintf(stderr, s, v);
fprintf(stderr,"\n");
}
yyerror(s) char *s; {yerr(s, "");}
yerr(s, v)
char *s, *v;
{
fprintf(stderr, "%s: line %d: ", filename, linenum);
fprintf(stderr, s, v);
fprintf(stderr,"\n");
if (errorcount++ > 10) quiter("too many errors, goodby");
}
expect(str) char *str;
{ char buffer[100];
sprintf(buffer,"Expected %%s found %s", yytext);
yerr(buffer, str);
}
int yywrap() { return(1);}
char *alloc(size) int size; /* allocate a block of storage */
{ char *p, *malloc();
p = malloc( (unsigned) size);
if (p == (char *) 0) yyerror("out of free space");
return(p);
}
char *bincat(s1, s2)
char *s1, *s2;
{ char *p;
p = alloc(strlen(s1) + strlen(s2) + 1);
strcpy(p, s1);
strcat(p, s2);
return(p);
}
short yyexca[] ={
-1, 1,
0, -1,
-2, 0,
};
# define YYNPROD 119
# define YYLAST 309
short yyact[]={
81, 79, 75, 76, 77, 127, 92, 25, 157, 141,
124, 123, 126, 125, 131, 156, 140, 155, 36, 26,
152, 37, 28, 130, 132, 29, 81, 79, 75, 76,
77, 127, 89, 25, 154, 149, 124, 123, 126, 125,
131, 120, 10, 119, 34, 26, 114, 40, 28, 130,
132, 29, 81, 79, 75, 76, 77, 15, 105, 9,
71, 65, 14, 116, 32, 33, 67, 146, 72, 107,
106, 35, 107, 43, 98, 78, 80, 147, 81, 79,
75, 76, 77, 15, 48, 42, 71, 65, 14, 54,
99, 84, 67, 91, 72, 143, 47, 109, 108, 102,
138, 78, 80, 81, 79, 75, 76, 77, 15, 13,
6, 71, 65, 14, 54, 15, 5, 67, 136, 72,
14, 69, 62, 101, 58, 52, 78, 80, 81, 79,
75, 76, 77, 15, 53, 60, 71, 65, 14, 54,
24, 51, 67, 93, 72, 81, 79, 75, 76, 77,
15, 78, 80, 71, 65, 14, 116, 31, 22, 67,
83, 72, 94, 17, 129, 45, 25, 142, 78, 80,
21, 20, 23, 25, 70, 41, 39, 25, 26, 95,
2, 28, 7, 27, 29, 26, 34, 90, 28, 26,
27, 29, 28, 34, 27, 29, 88, 46, 84, 44,
20, 49, 100, 96, 86, 87, 32, 33, 30, 4,
63, 8, 1, 32, 33, 12, 85, 66, 121, 64,
117, 139, 97, 122, 135, 134, 113, 50, 133, 16,
115, 112, 3, 118, 11, 19, 74, 103, 137, 144,
110, 82, 104, 111, 38, 61, 59, 57, 55, 56,
18, 73, 68, 145, 150, 0, 148, 0, 0, 0,
0, 0, 0, 0, 128, 0, 0, 122, 0, 0,
151, 0, 0, 153, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 128 };
short yypact[]={
-146,-146,-1000,-214,-147,-1000,-1000,-1000, -98,-1000,
-1000,-212,-198,-1000,-1000,-1000,-256,-1000,-212,-223,
-183,-1000,-1000,-183, -87,-1000,-1000,-1000,-1000,-1000,
-1000,-172,-1000,-1000,-1000,-1000,-1000, -98,-154,-177,
-183,-1000,-1000,-1000,-1000,-1000, -63,-1000,-1000,-1000,
-243,-1000,-129,-1000,-170,-272,-1000,-1000, -91, -91,
-194,-178,-1000,-1000,-1000,-1000,-1000,-129,-1000,-1000,
-1000,-158,-211,-1000,-1000,-1000,-1000,-1000,-201,-1000,
-160,-1000, -70,-1000,-1000,-1000,-1000,-1000,-1000,-154,
-1000,-129,-1000,-224,-112,-112,-224,-112,-1000,-1000,
-229,-231,-1000,-179,-260,-1000,-1000,-162,-1000,-1000,
-1000,-1000,-1000,-1000,-112,-194,-1000, -87,-194,-1000,
-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
-204,-1000,-160,-205,-239,-179,-1000,-255,-129,-1000,
-1000,-1000,-240,-1000, -87,-257,-1000,-1000,-1000,-1000,
-1000,-267,-1000,-1000,-1000,-1000,-1000,-1000 };
short yypgo[]={
0, 123, 252, 210, 162, 140, 251, 250, 249, 248,
124, 135, 247, 246, 245, 244, 242, 241, 237, 236,
235, 143, 234, 232, 163, 229, 122, 228, 227, 141,
134, 225, 224, 118, 221, 219, 121, 218, 217, 212,
180, 211, 209, 208, 157, 197, 196, 175, 160, 174,
167, 164 };
short yyr1[]={
0, 39, 39, 40, 41, 41, 23, 42, 42, 22,
22, 22, 3, 3, 43, 43, 45, 45, 45, 25,
25, 24, 7, 7, 7, 7, 20, 20, 47, 47,
15, 15, 44, 44, 44, 17, 17, 48, 28, 28,
46, 46, 29, 29, 30, 30, 9, 9, 12, 12,
13, 13, 14, 14, 8, 8, 21, 21, 10, 10,
4, 4, 5, 5, 5, 5, 5, 11, 11, 26,
26, 26, 26, 26, 26, 26, 38, 27, 27, 2,
18, 18, 16, 16, 31, 31, 33, 33, 34, 34,
32, 32, 35, 35, 49, 36, 36, 36, 36, 36,
36, 6, 6, 19, 19, 37, 37, 37, 37, 37,
37, 37, 37, 51, 51, 1, 1, 50, 50 };
short yyr2[]={
0, 1, 2, 4, 1, 1, 3, 1, 1, 1,
2, 1, 1, 1, 0, 3, 1, 2, 1, 1,
3, 4, 1, 2, 1, 1, 2, 3, 1, 1,
0, 3, 1, 1, 1, 1, 2, 1, 1, 3,
0, 1, 2, 1, 3, 1, 1, 1, 1, 2,
1, 3, 2, 2, 1, 2, 2, 3, 1, 3,
1, 2, 1, 1, 1, 1, 1, 1, 2, 1,
1, 1, 1, 1, 3, 1, 4, 0, 2, 4,
0, 2, 1, 2, 2, 1, 2, 1, 0, 1,
2, 3, 1, 3, 2, 1, 1, 1, 1, 1,
4, 1, 2, 1, 2, 1, 1, 1, 1, 1,
1, 1, 3, 2, 1, 0, 2, 1, 2 };
short yychk[]={
-1000, -39, -40, -23, -42, 262, 256, -40, -41, 273,
256, -22, -3, 256, 267, 262, -25, -24, -7, -20,
-4, 268, 256, 270, -5, 264, 276, 281, 279, 282,
-43, -44, 276, 277, 256, 269, 274, 277, -15, -44,
270, -47, 268, 256, -47, -5, -45, 268, 256, -24,
-28, -29, 279, -30, 268, -9, -8, -12, -10, -13,
-11, -14, -26, -3, -35, 266, -38, 271, -2, -36,
-49, 265, 273, -6, -19, 259, 260, 261, 280, 258,
281, 257, -17, -48, 268, -47, -44, 268, -46, 275,
-30, 263, 278, -21, -4, 270, -21, -4, 268, 268,
-30, -1, 257, -18, -16, 269, 271, 273, 258, 257,
-44, -48, -29, -30, 270, -11, 268, -10, -11, 272,
272, -37, -36, 268, 267, 270, 269, 262, -4, -51,
280, 271, 281, -27, -31, -32, -33, -30, 279, -34,
276, 269, -50, 257, -10, -1, 271, 282, -26, 274,
-33, -30, 275, -30, 274, 257, 272, 275 };
short yydef[]={
0, -2, 1, 0, 0, 7, 8, 2, 0, 4,
5, 14, 9, 11, 12, 13, 0, 19, 30, 22,
0, 24, 25, 0, 60, 62, 63, 64, 65, 66,
6, 0, 32, 33, 34, 10, 3, 0, 0, 0,
0, 23, 28, 29, 26, 61, 0, 16, 18, 20,
40, 38, 0, 43, 70, 45, 46, 47, 54, 48,
58, 50, 67, 69, 71, 72, 73, 0, 75, 92,
115, 0, 80, 95, 96, 97, 98, 99, 0, 101,
0, 103, 0, 35, 37, 27, 15, 17, 21, 41,
42, 0, 52, 55, 0, 0, 49, 0, 68, 53,
0, 0, 77, 88, 0, 82, 94, 0, 102, 104,
31, 36, 39, 44, 0, 59, 70, 56, 51, 74,
93, 116, 105, 106, 107, 108, 109, 110, 111, 115,
0, 114, 64, 0, 0, 88, 85, 89, 0, 87,
81, 83, 0, 117, 57, 0, 113, 76, 78, 79,
84, 89, 90, 86, 100, 118, 112, 91 };
#ifndef lint
static char yaccpar_sccsid[] = "@(#)yaccpar 4.1 (Berkeley) 2/11/83";
#endif not lint
#
# define YYFLAG -1000
# define YYERROR goto yyerrlab
# define YYACCEPT return(0)
# define YYABORT return(1)
/* parser for yacc output */
#ifdef YYDEBUG
int yydebug = 0; /* 1 for debugging */
#endif
YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
int yychar = -1; /* current input token number */
int yynerrs = 0; /* number of errors */
short yyerrflag = 0; /* error recovery flag */
yyparse() {
short yys[YYMAXDEPTH];
short yyj, yym;
register YYSTYPE *yypvt;
register short yystate, *yyps, yyn;
register YYSTYPE *yypv;
register short *yyxi;
yystate = 0;
yychar = -1;
yynerrs = 0;
yyerrflag = 0;
yyps= &yys[-1];
yypv= &yyv[-1];
yystack: /* put a state and value onto the stack */
#ifdef YYDEBUG
if( yydebug ) printf( "state %d, char 0%o\n", yystate, yychar );
#endif
if( ++yyps> &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
*yyps = yystate;
++yypv;
*yypv = yyval;
yynewstate:
yyn = yypact[yystate];
if( yyn<= YYFLAG ) goto yydefault; /* simple state */
if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
yychar = -1;
yyval = yylval;
yystate = yyn;
if( yyerrflag > 0 ) --yyerrflag;
goto yystack;
}
yydefault:
/* default state action */
if( (yyn=yydef[yystate]) == -2 ) {
if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
/* look through exception table */
for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
while( *(yyxi+=2) >= 0 ){
if( *yyxi == yychar ) break;
}
if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */
}
if( yyn == 0 ){ /* error */
/* error ... attempt to resume parsing */
switch( yyerrflag ){
case 0: /* brand new error */
yyerror( "syntax error" );
yyerrlab:
++yynerrs;
case 1:
case 2: /* incompletely recovered error ... try again */
yyerrflag = 3;
/* find a state where "error" is a legal shift action */
while ( yyps >= yys ) {
yyn = yypact[*yyps] + YYERRCODE;
if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
yystate = yyact[yyn]; /* simulate a shift of "error" */
goto yystack;
}
yyn = yypact[*yyps];
/* the current yyps has no shift onn "error", pop stack */
#ifdef YYDEBUG
if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
#endif
--yyps;
--yypv;
}
/* there is no state on the stack with an error shift ... abort */
yyabort:
return(1);
case 3: /* no shift yet; clobber input char */
#ifdef YYDEBUG
if( yydebug ) printf( "error recovery discards char %d\n", yychar );
#endif
if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
yychar = -1;
goto yynewstate; /* try again in the same state */
}
}
/* reduction by production yyn */
#ifdef YYDEBUG
if( yydebug ) printf("reduce %d\n",yyn);
#endif
yyps -= yyr2[yyn];
yypvt = yypv;
yypv -= yyr2[yyn];
yyval = yypv[1];
yym=yyn;
/* consult goto table to find next state */
yyn = yyr1[yyn];
yyj = yypgo[yyn] + *yyps + 1;
if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
switch(yym){
case 3:
# line 103 "parser.y"
{if (errorcount == 0) genclass(yypvt[-3].l, yypvt[-1].m);} break;
case 5:
# line 107 "parser.y"
{if ((yytext[0] == ':') ||
isalpha(yytext[0])) expect(":SuperClass");
else expect("open brace [");} break;
case 6:
# line 112 "parser.y"
{yyval.l = yypvt[-1].l;} break;
case 8:
# line 116 "parser.y"
{expect("keyword Class");} break;
case 9:
# line 119 "parser.y"
{yyval.l = mkclass(yypvt[-0].c, (char *) 0);} break;
case 10:
# line 120 "parser.y"
{yyval.l = mkclass(yypvt[-1].c, yypvt[-0].c);} break;
case 11:
# line 121 "parser.y"
{expect("Classname :Superclass");
yyval.l = mkclass("Error", (char *) 0);} break;
case 16:
# line 133 "parser.y"
{addinst(yypvt[-0].c);} break;
case 17:
# line 134 "parser.y"
{addinst(yypvt[-0].c);} break;
case 18:
# line 135 "parser.y"
{expect("instance variable");} break;
case 20:
# line 140 "parser.y"
{yypvt[-0].m->nextmethod = yypvt[-2].m; yyval.m = yypvt[-0].m;} break;
case 21:
# line 144 "parser.y"
{deltemps(yypvt[-2].i); yyval.m = mkmethod(yypvt[-3].e, yypvt[-2].i, yypvt[-1].s);} break;
case 22:
# line 148 "parser.y"
{yyval.e = mkkey((struct exprstruct *) 0, yypvt[-0].k);} break;
case 23:
# line 150 "parser.y"
{yyval.e = mkexpr((struct exprstruct *) 0, bincmd, yypvt[-1].c, (struct exprstruct *) 0);} break;
case 24:
# line 152 "parser.y"
{yyval.e = mkexpr((struct exprstruct *) 0, uncmd, yypvt[-0].c, (struct exprstruct *) 0);} break;
case 25:
# line 153 "parser.y"
{expect("method pattern");
yyval.e = mkexpr((struct exprstruct *) 0, uncmd, "", (struct exprstruct *) 0);} break;
case 26:
# line 158 "parser.y"
{yyval.k = mkklist((struct keylist *) 0, yypvt[-1].c, (struct exprstruct *) 0);} break;
case 27:
# line 160 "parser.y"
{yyval.k = mkklist(yypvt[-2].k, yypvt[-1].c, (struct exprstruct *) 0);} break;
case 28:
# line 163 "parser.y"
{addtemp(yypvt[-0].c, argvar);} break;
case 29:
# line 164 "parser.y"
{expect("argument variable");} break;
case 30:
# line 167 "parser.y"
{yyval.i = 0;} break;
case 31:
# line 168 "parser.y"
{yyval.i = yypvt[-1].i;} break;
case 34:
# line 173 "parser.y"
{expect("| (vertical bar)");} break;
case 35:
# line 176 "parser.y"
{yyval.i = 1;} break;
case 36:
# line 177 "parser.y"
{yyval.i = yypvt[-1].i + 1;} break;
case 37:
# line 180 "parser.y"
{addtemp(yypvt[-0].c, tempvar);} break;
case 38:
# line 183 "parser.y"
{yyval.s = yypvt[-0].s;} break;
case 39:
# line 184 "parser.y"
{yypvt[-0].s->nextstate = yypvt[-2].s; yyval.s = yypvt[-0].s;} break;
case 42:
# line 191 "parser.y"
{yyval.s = mkstate(upar, (char *) 0, yypvt[-0].s);} break;
case 44:
# line 196 "parser.y"
{yyval.s = mkstate(asgn, yypvt[-2].c, yypvt[-0].s);} break;
case 45:
# line 198 "parser.y"
{yyval.s = mkstate(expr, (char *) 0, (struct statestruct *) yypvt[-0].e);} break;
case 47:
# line 202 "parser.y"
{yyval.e = mkexpr(yypvt[-0].e, semiend, 0, 0);} break;
case 49:
# line 206 "parser.y"
{yyval.e = mkkey(yypvt[-1].e, yypvt[-0].k);} break;
case 51:
# line 211 "parser.y"
{yyval.e = mkexpr(yypvt[-2].e, bincmd, yypvt[-1].c, yypvt[-0].e);} break;
case 52:
# line 214 "parser.y"
{yyval.e = mkexpr(yypvt[-1].e, semistart, 0, 0);} break;
case 53:
# line 216 "parser.y"
{yyval.e = mkexpr(yypvt[-1].e, uncmd, yypvt[-0].c, (struct exprstruct *) 0);} break;
case 54:
# line 219 "parser.y"
{yyval.e = yypvt[-0].e;} break;
case 55:
# line 220 "parser.y"
{yyval.e = mkkey(yypvt[-1].e, yypvt[-0].k);} break;
case 56:
# line 224 "parser.y"
{yyval.k = mkklist((struct keylist *) 0, yypvt[-1].c, yypvt[-0].e);} break;
case 57:
# line 226 "parser.y"
{yyval.k = mkklist(yypvt[-2].k, yypvt[-1].c, yypvt[-0].e);} break;
case 58:
# line 229 "parser.y"
{yyval.e = yypvt[-0].e;} break;
case 59:
# line 230 "parser.y"
{yyval.e = mkexpr(yypvt[-2].e, bincmd, yypvt[-1].c, yypvt[-0].e);} break;
case 60:
# line 233 "parser.y"
{yyval.c = yypvt[-0].c;} break;
case 61:
# line 234 "parser.y"
{yyval.c = bincat(yypvt[-1].c, yypvt[-0].c);} break;
case 67:
# line 245 "parser.y"
{yyval.e = mkexpr((struct exprstruct *) 0, reccmd, (char *) 0,
(struct exprstruct *) yypvt[-0].o);} break;
case 68:
# line 248 "parser.y"
{yyval.e = mkexpr(yypvt[-1].e, uncmd, yypvt[-0].c, (struct exprstruct *) 0);} break;
case 69:
# line 251 "parser.y"
{e.c = yypvt[-0].c; yyval.o = mkobj(classobj, &e);} break;
case 70:
# line 252 "parser.y"
{e.c = yypvt[-0].c; yyval.o = mkobj(varobj, &e);} break;
case 71:
# line 253 "parser.y"
{e.t = yypvt[-0].t; yyval.o = mkobj(litobj, &e);} break;
case 72:
# line 254 "parser.y"
{e.p = yypvt[-0].p; yyval.o = mkobj(pseuobj, &e);} break;
case 73:
# line 255 "parser.y"
{e.u = yypvt[-0].u; yyval.o = mkobj(primobj, &e);} break;
case 74:
# line 256 "parser.y"
{e.s = yypvt[-1].s; yyval.o = mkobj(exprobj, &e);} break;
case 75:
# line 257 "parser.y"
{e.b = yypvt[-0].b; yyval.o = mkobj(blockobj, &e);} break;
case 76:
# line 261 "parser.y"
{yyval.u = mkprim(yypvt[-2].i, yypvt[-1].r);} break;
case 77:
# line 264 "parser.y"
{yyval.r = (struct primlist *) 0;} break;
case 78:
# line 265 "parser.y"
{yyval.r = addprim(yypvt[-1].r, yypvt[-0].o);} break;
case 79:
# line 269 "parser.y"
{yyval.b = mkblock(yypvt[-2].i, yypvt[-1].s);
deltemps(yypvt[-2].i);} break;
case 80:
# line 273 "parser.y"
{yyval.i = 0;} break;
case 81:
# line 274 "parser.y"
{yyval.i = yypvt[-1].i;} break;
case 82:
# line 277 "parser.y"
{addtemp(yypvt[-0].c, argvar); yyval.i = 1;} break;
case 83:
# line 278 "parser.y"
{addtemp(yypvt[-0].c, argvar); yyval.i = yypvt[-1].i + 1;} break;
case 84:
# line 281 "parser.y"
{yypvt[-0].s->nextstate = yypvt[-1].s; yyval.s = yypvt[-0].s;} break;
case 85:
# line 282 "parser.y"
{yyval.s = yypvt[-0].s;} break;
case 86:
# line 285 "parser.y"
{yyval.s = mkstate(blkupar, (char *) 0, yypvt[-0].s);} break;
case 87:
# line 286 "parser.y"
{yyval.s = mkstate(upar, (char *) 0, yypvt[-0].s);} break;
case 88:
# line 290 "parser.y"
{e.p = nilvar;
yyval.s = mkstate(expr, (char *) 0,
(struct statestruct *) mkexpr((struct exprstruct *) 0, reccmd, (char *) 0,
(struct exprstruct *) mkobj(pseuobj, &e)));} break;
case 89:
# line 294 "parser.y"
{yyval.s = yypvt[-0].s;} break;
case 90:
# line 297 "parser.y"
{yyval.s = yypvt[-1].s;} break;
case 91:
# line 299 "parser.y"
{yypvt[-1].s->nextstate = yypvt[-2].s; yyval.s = yypvt[-1].s;} break;
case 92:
# line 302 "parser.y"
{yyval.t = yypvt[-0].t;} break;
case 93:
# line 303 "parser.y"
{e.a = yypvt[-1].a; yyval.t = mklit(arlit, &e);} break;
case 95:
# line 309 "parser.y"
{e.c = yypvt[-0].c; yyval.t = mklit(fnumlit, &e);} break;
case 96:
# line 310 "parser.y"
{e.i = yypvt[-0].i; yyval.t = mklit(numlit, &e);} break;
case 97:
# line 311 "parser.y"
{e.i = yypvt[-0].i; yyval.t = mklit(charlit, &e);} break;
case 98:
# line 312 "parser.y"
{e.c = yypvt[-0].c; yyval.t = mklit(strlit, &e);} break;
case 99:
# line 313 "parser.y"
{e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
case 100:
# line 314 "parser.y"
{bytearray[bytetop] = '\0';
yyval.t = mklit(bytelit, &e);} break;
case 101:
# line 318 "parser.y"
{yyval.c = yypvt[-0].c;} break;
case 102:
# line 319 "parser.y"
{yyval.c = bincat("-", yypvt[-0].c);} break;
case 103:
# line 322 "parser.y"
{yyval.i = yypvt[-0].i;} break;
case 104:
# line 323 "parser.y"
{yyval.i = - yypvt[-0].i;} break;
case 105:
# line 326 "parser.y"
{yyval.t = yypvt[-0].t;} break;
case 106:
# line 327 "parser.y"
{e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
case 107:
# line 328 "parser.y"
{e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
case 108:
# line 329 "parser.y"
{e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
case 109:
# line 330 "parser.y"
{e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
case 110:
# line 331 "parser.y"
{e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
case 111:
# line 332 "parser.y"
{e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
case 112:
# line 333 "parser.y"
{e.a = yypvt[-1].a; yyval.t = mklit(arlit, &e);} break;
case 115:
# line 340 "parser.y"
{yyval.a = (struct litlist *) 0;} break;
case 116:
# line 341 "parser.y"
{yyval.a = addlit(yypvt[-1].a, yypvt[-0].t);} break;
case 117:
# line 344 "parser.y"
{bytetop = 0;
bytearray[bytetop++] = itouc(yypvt[-0].i);} break;
case 118:
# line 346 "parser.y"
{bytearray[bytetop++] = itouc(yypvt[-0].i);} break;
}
goto yystack; /* stack new state and value */
}
SHAR_EOF
if test 20727 -ne "`wc -c < 'parser/y.tab.c'`"
then
echo shar: error transmitting "'parser/y.tab.c'" '(should have been 20727 characters)'
fi
fi # end of overwriting check
if test -f 'parser/y.tab.h'
then
echo shar: will not over-write existing file "'parser/y.tab.h'"
else
cat << \SHAR_EOF > 'parser/y.tab.h'
# define LITNUM 257
# define LITFNUM 258
# define LITCHAR 259
# define LITSTR 260
# define LITSYM 261
# define CLASS 262
# define ASSIGN 263
# define BINARY 264
# define PRIMITIVE 265
# define PSEUDO 266
# define UPPERCASEVAR 267
# define LOWERCASEVAR 268
# define COLONVAR 269
# define KEYWORD 270
# define LP 271
# define RP 272
# define LB 273
# define RB 274
# define PERIOD 275
# define BAR 276
# define MBAR 277
# define SEMI 278
# define UPARROW 279
# define PS 280
# define MINUS 281
# define PE 282
typedef union {
struct litlist *a;
struct blockstruct *b;
char *c;
struct exprstruct *e;
int i;
struct keylist *k;
struct classstruct *l;
struct methodstruct *m;
struct objstruct *o;
enum pseuvars p;
struct primlist *r;
struct statestruct *s;
struct litstruct *t;
struct primstruct *u
} YYSTYPE;
extern YYSTYPE yylval;
SHAR_EOF
if test 868 -ne "`wc -c < 'parser/y.tab.h'`"
then
echo shar: error transmitting "'parser/y.tab.h'" '(should have been 868 characters)'
fi
fi # end of overwriting check
if test -f 'prelude/Makefile'
then
echo shar: will not over-write existing file "'prelude/Makefile'"
else
cat << \SHAR_EOF > 'prelude/Makefile'
.SUFFIXES : .st .p
PREPATH = /usr/src/public/lsmalltalk/prelude
BINDIR = ../bin
PARSED = class.p object.p \
string.p larray.p nil.p array.p\
boolean.p true.p false.p block.p symbol.p \
magnitude.p number.p integer.p char.p float.p radian.p point.p random.p \
collection.p bag.p set.p kcollection.p dictionary.p scollection.p interval.p \
list.p acollection.p file.p bytearray.p \
semaphore.p process.p smalltalk.p
.st.p:
$(BINDIR)/parse $(PREPATH)/$*.st >$*.p
install: standard
-make fastsave
bundle: *.st Makefile savescript
bundle Makefile savescript init *.st >../prelude.bundle
standard: $(PARSED)
cat $(PARSED) init >standard
newstd: $(PARSED)
cat $(PARSED) >newstd
fastsave: standard
$(BINDIR)/st -m <savescript
clean:
-rm *.p
SHAR_EOF
if test 748 -ne "`wc -c < 'prelude/Makefile'`"
then
echo shar: error transmitting "'prelude/Makefile'" '(should have been 748 characters)'
fi
fi # end of overwriting check
if test -f 'prelude/acollection.p'
then
echo shar: will not over-write existing file "'prelude/acollection.p'"
else
cat << \SHAR_EOF > 'prelude/acollection.p'
temp <- <primitive 110 12 >
<primitive 112 temp 1 " shallowCopy " \
#( #[ 32 164 32 163 176 113 81 32 163 178 225 2 7 33 34 \
32 34 177 208 243 179 242 33 243 245] \
#( ) ) >
<primitive 112 temp 2 " next " \
#( #[ 16 81 192 96 16 32 163 200 247 3 32 16 177 243 245 \
] \
#( ) ) >
<primitive 112 temp 3 " lastKey " \
#( #[ 32 163 243 245] \
#( ) ) >
<primitive 112 temp 4 " firstKey " \
#( #[ 81 243 245] \
#( ) ) >
<primitive 112 temp 5 " first " \
#( #[ 81 96 16 32 163 200 247 3 32 16 177 243 245] \
#( ) ) >
<primitive 112 temp 6 " do: " \
#( #[ 81 32 163 178 225 2 8 34 96 33 32 34 177 180 243 \
179 242 245] \
#( ) ) >
<primitive 112 temp 7 " deepCopy " \
#( #[ 32 164 32 163 176 113 81 32 163 178 225 2 9 33 34 \
32 34 177 10 20 208 243 179 242 33 243 245] \
#( ) ) >
<primitive 112 temp 8 " currentKey " \
#( #[ 16 243 245] \
#( ) ) >
<primitive 112 temp 9 " copyFrom:to: " \
#( #[ 34 33 193 81 192 115 32 164 35 176 116 36 81 35 32 \
33 132 0 242 36 243 245] \
#( #replaceFrom:to:with:startingAt: ) ) >
<primitive 112 temp 10 " coerce: " \
#( #[ 32 164 33 163 176 114 34 81 33 163 33 131 0 242 34 \
243 245] \
#( #replaceFrom:to:with: ) ) >
<primitive 112 temp 11 " at:ifAbsent: " \
#( #[ 33 80 200 251 4 33 32 163 204 247 3 34 165 243 242 \
32 33 177 243 245] \
#( ) ) >
<primitive 112 temp 12 " = " \
#( #[ 32 163 33 163 202 247 2 92 243 242 80 114 32 225 3 \
14 35 33 34 81 192 241 114 177 202 247 2 92 244 243 \
179 242 91 243 245] \
#( ) ) >
<primitive 98 #ArrayedCollection \
<primitive 97 #ArrayedCollection #SequenceableCollection #/u/smalltalk/prelude/acollection.st \
#( #current ) \
#( #shallowCopy #next #lastKey #firstKey #first #do: #deepCopy #currentKey #copyFrom:to: #coerce: #at:ifAbsent: #= ) \
temp 5 7 > >
SHAR_EOF
if test 1809 -ne "`wc -c < 'prelude/acollection.p'`"
then
echo shar: error transmitting "'prelude/acollection.p'" '(should have been 1809 characters)'
fi
fi # end of overwriting check
if test -f 'prelude/acollection.st'
then
echo shar: will not over-write existing file "'prelude/acollection.st'"
else
cat << \SHAR_EOF > 'prelude/acollection.st'
Class ArrayedCollection :SequenceableCollection
| current |
[
= anArray | i |
(self size ~= anArray size) ifTrue: [^ false].
i <- 0.
self do: [:x | (x ~= (anArray at: (i <- i + 1)))
ifTrue: [^ false]].
^ true
|
at: key ifAbsent: exceptionBlock
((key <= 0) or: [key > self size])
ifTrue: [^ exceptionBlock value].
^ self at: key
|
coerce: aCollection | temp |
temp <- self class new: aCollection size.
temp replaceFrom: 1 to: aCollection size with: aCollection.
^ temp
|
copyFrom: start to: stop | size temp |
size <- stop - start + 1.
temp <- self class new: size.
temp replaceFrom: 1 to: size with: self startingAt: start.
^ temp
|
currentKey
^ current
|
deepCopy | newobj |
newobj <- self class new: self size.
(1 to: self size) do:
[:i | newobj at: i
put: (self at: i) copy ].
^ newobj
|
do: aBlock
(1 to: self size)
do: [:i | current <- i.
aBlock value: (self at: i)]
|
first
current <- 1.
^ (current <= self size)
ifTrue: [ self at: current]
|
firstKey
^ 1
|
lastKey
^ self size
|
next
current <- current + 1.
^ (current <= self size)
ifTrue: [ self at: current]
|
shallowCopy | newobj |
newobj <- self class new: self size.
(1 to: self size) do:
[:i | newobj at: i
put: (self at: i) ].
^ newobj
]
SHAR_EOF
if test 1564 -ne "`wc -c < 'prelude/acollection.st'`"
then
echo shar: error transmitting "'prelude/acollection.st'" '(should have been 1564 characters)'
fi
fi # end of overwriting check
if test -f 'prelude/array.p'
then
echo shar: will not over-write existing file "'prelude/array.p'"
else
cat << \SHAR_EOF > 'prelude/array.p'
temp <- <primitive 110 5 >
<primitive 112 temp 1 " size " \
#( #[ 32 250 1 4 243 245] \
#( ) ) >
<primitive 112 temp 2 " printString " \
#( #[ 48 113 32 250 1 4 114 34 80 204 247 21 32 34 250 \
2 111 169 49 11 17 33 11 17 113 34 81 193 241 114 \
242 249 26 242 50 33 11 17 243 245] \
#( ')' ' ' '#( ' ) ) >
<primitive 112 temp 3 " at:put: " \
#( #[ 33 81 199 251 6 33 32 250 1 4 204 247 6 32 48 \
188 242 93 243 242 32 33 34 250 3 112 242 34 243 245 \
] \
#( 'index error' ) ) >
<primitive 112 temp 4 " at: " \
#( #[ 33 81 199 251 6 33 32 250 1 4 204 247 6 32 48 \
188 242 93 243 242 32 33 250 2 111 243 245] \
#( 'index error' ) ) >
<primitive 112 temp 5 " new: " \
#( #[ 33 250 1 114 243 245] \
#( ) ) >
<primitive 98 #Array \
<primitive 97 #Array #ArrayedCollection #/u/smalltalk/prelude/array.st \
#( ) \
#( #size #printString #at:put: #at: #new: ) \
temp 3 4 > >
SHAR_EOF
if test 904 -ne "`wc -c < 'prelude/array.p'`"
then
echo shar: error transmitting "'prelude/array.p'" '(should have been 904 characters)'
fi
fi # end of overwriting check
if test -f 'prelude/array.st'
then
echo shar: will not over-write existing file "'prelude/array.st'"
else
cat << \SHAR_EOF > 'prelude/array.st'
Class Array :ArrayedCollection
[
new: aValue
^ <primitive 114 aValue>
|
at: aNumber
( (aNumber < 1) or: [aNumber > <primitive 4 self> ] )
ifTrue: [ self error: 'index error'. ^nil ].
^ <primitive 111 self aNumber >
|
at: aNumber put: aValue
( (aNumber < 1) or: [aNumber > <primitive 4 self> ] )
ifTrue: [ self error: 'index error'. ^nil ].
<primitive 112 self aNumber aValue >.
^ aValue
|
printString | value i |
value <- ')'.
i <- <primitive 4 self>.
[i > 0] whileTrue:
[ value <- <primitive 111 self i> printString ,
' ', value.
i <- i - 1].
^ '#( ' , value
|
size
^ <primitive 4 self>
]
SHAR_EOF
if test 642 -ne "`wc -c < 'prelude/array.st'`"
then
echo shar: error transmitting "'prelude/array.st'" '(should have been 642 characters)'
fi
fi # end of overwriting check
if test -f 'prelude/bag.p'
then
echo shar: will not over-write existing file "'prelude/bag.p'"
else
cat << \SHAR_EOF > 'prelude/bag.p'
temp <- <primitive 110 8 >
<primitive 112 temp 1 " next " \
#( #[ 17 162 247 27 17 80 204 247 9 17 81 193 97 16 171 \
243 248 10 242 16 167 241 97 161 247 2 93 243 242 249 \
31 242 93 243 245] \
#( ) ) >
<primitive 112 temp 2 " first " \
#( #[ 16 166 241 97 161 247 2 93 243 242 17 81 193 97 16 \
171 243 245] \
#( ) ) >
<primitive 112 temp 3 " occurrencesOf: " \
#( #[ 16 33 224 2 80 243 213 243 245] \
#( ) ) >
<primitive 112 temp 4 " size " \
#( #[ 16 80 226 1 4 33 34 192 243 215 243 245] \
#( ) ) >
<primitive 112 temp 5 " remove:ifAbsent: " \
#( #[ 16 33 224 3 34 165 244 213 115 81 35 201 247 6 16 \
33 11 40 248 7 242 16 33 35 81 193 208 242 245] \
#( ) ) >
<primitive 112 temp 6 " add:withOccurrences: " \
#( #[ 34 224 4 32 33 189 243 183 242 33 243 245] \
#( ) ) >
<primitive 112 temp 7 " add: " \
#( #[ 16 33 81 16 33 224 2 80 243 213 192 208 242 245] \
#( ) ) >
<primitive 112 temp 8 " new " \
#( #[ 5 40 160 96 245] \
#( ) ) >
<primitive 98 #Bag \
<primitive 97 #Bag #Collection #/u/smalltalk/prelude/bag.st \
#( #dict #count ) \
#( #next #first #occurrencesOf: #size #remove:ifAbsent: #add:withOccurrences: #add: #new ) \
temp 4 8 > >
SHAR_EOF
if test 1200 -ne "`wc -c < 'prelude/bag.p'`"
then
echo shar: error transmitting "'prelude/bag.p'" '(should have been 1200 characters)'
fi
fi # end of overwriting check
if test -f 'prelude/bag.st'
then
echo shar: will not over-write existing file "'prelude/bag.st'"
else
cat << \SHAR_EOF > 'prelude/bag.st'
Class Bag :Collection
| dict count |
[
new
dict <- Dictionary new
| add: newElement
dict at: newElement
put: (1 + (dict at: newElement ifAbsent: [0]))
| add: newObj withOccurrences: anInteger
anInteger timesRepeat: [ self add: newObj ].
^ newObj
| remove: oldElement ifAbsent: exceptionBlock | i |
i <- dict at: oldElement
ifAbsent: [ ^ exceptionBlock value].
(1 = i) ifTrue: [dict removeKey: oldElement]
ifFalse: [dict at: oldElement put: i - 1 ]
| size
^ dict inject: 0 into: [:x :y | x + y]
| occurrencesOf: anElement
^ dict at: anElement ifAbsent: [0]
| first
(count <- dict first) isNil ifTrue: [^ nil].
count <- count - 1.
^ dict currentKey
| next
[count notNil] whileTrue:
[ (count > 0)
ifTrue: [count <- count - 1. ^ dict currentKey]
ifFalse: [(count <- dict next) isNil
ifTrue: [^ nil] ]].
^ nil
]
SHAR_EOF
if test 1102 -ne "`wc -c < 'prelude/bag.st'`"
then
echo shar: error transmitting "'prelude/bag.st'" '(should have been 1102 characters)'
fi
fi # end of overwriting check
if test -f 'prelude/block.p'
then
echo shar: will not over-write existing file "'prelude/block.p'"
else
cat << \SHAR_EOF > 'prelude/block.p'
temp <- <primitive 110 14 >
<primitive 112 temp 1 " value:value:value:value:value: " \
#( #[ 85 250 1 140 242 245] \
#( ) ) >
<primitive 112 temp 2 " value:value:value:value: " \
#( #[ 84 250 1 140 242 245] \
#( ) ) >
<primitive 112 temp 3 " value:value:value: " \
#( #[ 83 250 1 140 242 245] \
#( ) ) >
<primitive 112 temp 4 " value:value: " \
#( #[ 82 250 1 140 242 245] \
#( ) ) >
<primitive 112 temp 5 " value: " \
#( #[ 81 250 1 140 242 245] \
#( ) ) >
<primitive 112 temp 6 " value " \
#( #[ 80 250 1 140 242 245] \
#( ) ) >
<primitive 112 temp 7 " whileFalse: " \
#( #[ 32 165 246 5 33 165 242 249 9 243 245] \
#( ) ) >
<primitive 112 temp 8 " whileFalse " \
#( #[ 32 165 246 4 93 242 249 8 243 245] \
#( ) ) >
<primitive 112 temp 9 " whileTrue: " \
#( #[ 32 165 247 5 33 165 242 249 9 243 245] \
#( ) ) >
<primitive 112 temp 10 " whileTrue " \
#( #[ 32 165 247 4 93 242 249 8 243 245] \
#( ) ) >
<primitive 112 temp 11 " forkWith: " \
#( #[ 32 33 11 35 10 40 242 93 243 245] \
#( ) ) >
<primitive 112 temp 12 " fork " \
#( #[ 32 10 33 10 40 242 93 243 245] \
#( ) ) >
<primitive 112 temp 13 " newProcessWith: " \
#( #[ 32 33 250 2 141 243 245] \
#( ) ) >
<primitive 112 temp 14 " newProcess " \
#( #[ 32 250 1 141 243 245] \
#( ) ) >
<primitive 98 #Block \
<primitive 97 #Block #Object #/u/smalltalk/prelude/block.st \
#( ) \
#( #value:value:value:value:value: #value:value:value:value: #value:value:value: #value:value: #value: #value #whileFalse: #whileFalse #whileTrue: #whileTrue #forkWith: #fork #newProcessWith: #newProcess ) \
temp 6 3 > >
SHAR_EOF
if test 1632 -ne "`wc -c < 'prelude/block.p'`"
then
echo shar: error transmitting "'prelude/block.p'" '(should have been 1632 characters)'
fi
fi # end of overwriting check
if test -f 'prelude/block.st'
then
echo shar: will not over-write existing file "'prelude/block.st'"
else
cat << \SHAR_EOF > 'prelude/block.st'
"
Class Block.
Note how whileTrue: and whileFalse: depend upon the parser
optimizing the loops into control flow, rather than message
passing. If this were not the case, whileTrue: would have to
be implemented using recursion, as follows:
whileTrue: aBlock
(self value) ifFalse: [^nil].
aBlock value.
^ self whileTrue: aBlock
"
Class Block
[
newProcess
^ <primitive 141 self>
|
newProcessWith: argumentArray
^ <primitive 141 self argumentArray>
|
fork
self newProcess resume.
^ nil
|
forkWith: argumentArray
(self newProcessWith: argumentArray) resume.
^ nil
|
whileTrue
^ [self value ] whileTrue: []
|
whileTrue: aBlock
^ [ self value ] whileTrue: [ aBlock value ]
|
whileFalse
^ [ self value ] whileFalse: []
|
whileFalse: aBlock
^ [ self value ] whileFalse: [ aBlock value ]
|
value
<primitive 140 0>
|
value: a
<primitive 140 1>
|
value: a value: b
<primitive 140 2>
|
value: a value: b value: c
<primitive 140 3>
|
value: a value: b value: c value: d
<primitive 140 4>
|
value: a value: b value: c value: d value: e
<primitive 140 5>
]
SHAR_EOF
if test 1111 -ne "`wc -c < 'prelude/block.st'`"
then
echo shar: error transmitting "'prelude/block.st'" '(should have been 1111 characters)'
fi
fi # end of overwriting check
# End of shell archive
exit 0
Thread Navigation
This is a paginated view of messages in the thread with full content displayed inline.
Messages are displayed in chronological order, with the original post highlighted in green.
Use pagination controls to navigate through all messages in large threads.
Back to All Threads