28 Oct
2018
28 Oct
'18
9:34 p.m.
Hello,
This is Alan Snyder's C grammar. It's supposedly for yacc, but it's
probably using some really ancient version. Maybe from when Alan did a
stint at Bell labs and converted yacc from B to C.
Does anyone recognize this type of yacc input? I don't have the
corresponding yacc version, and the one in V6 isn't happy about this
file. What would it take to update the grammar for V6 yacc? Add in
some %term, replace \\ with %%?
# C GRAMMAR #
# 28 May 1978 #
# Alan Snyder #
# 26 acceptable conflicts:
2 S/R conflicts for (parsing) ambiguity between
declarators and function_declarators
1 S/R conflict for the C ELSE ambiguity
4 R/R conflicts for the (parsing) problem with regard
to integer constants as initial_values
12 R/R conflicts for the (parsing) problem with regard
to identifiers in function calls
1 R/R conflict for the (parsing) problem with regard
to identifiers in goto statements
4 R/R conflicts and 1 S/R conflict for TYPEDEFs
1 S/R conflict for ambiguous cast types
(int ()) = (int x()) not (int (x))
Approximate description:
18 S/R ( shift 37 reduce 141
50 S/R ( shift 37 reduce 71
81 S/R ( shift 37 reduce 71
113 R/R ( reduce 141 reduce 140
113 R/R ( reduce 159 reduce 140
113 R/R * reduce 159 reduce 141
113 S/R : shift 199 reduce 141
183 R/R , reduce 203 reduce 24
183 R/R } reduce 203 reduce 24
204 R/R ( reduce 159 reduce 140
206 R/R ( reduce 148 reduce 139
207 R/R ( reduce 147 reduce 139
208 R/R ( reduce 145 reduce 139
209 R/R ( reduce 144 reduce 139
210 R/R ( reduce 146 reduce 139
211 R/R ( reduce 149 reduce 139
212 R/R ( reduce 150 reduce 139
215 R/R ( reduce 159 reduce 140
215 R/R ; reduce 159 reduce 138
225 R/R ( reduce 151 reduce 139
228 R/R ( reduce 159 reduce 140
284 R/R , reduce 203 reduce 25
284 R/R } reduce 203 reduce 25
291 S/R ) shift 339 reduce 165
343 R/R ( reduce 153 reduce 139
360 S/R ELSE shift 369 reduce 94
#
# terminal symbols #
';' '}' '{' ']' '[' ')'
'(' ':'
',' '.' '?' '~' '!' '&'
'|' '^'
'%' '/' '*' '-' '+' '='
'<' '>'
'++' '--' '==' '!=' '<='
'>=' '<<' '>>'
'->' '=op' '&&' '||' 'c'
INT CHAR FLOAT DOUBLE STRUCT AUTO STATIC
EXTERN RETURN GOTO IF ELSE SWITCH
BREAK CONTINUE WHILE DO FOR DEFAULT CASE
ENTRY REGISTER SIZEOF LONG SHORT UNSIGNED TYPEDEF 'l'
'm' 'n' 'o' 'p' 'q' 'r'
's'
identifier integer floatcon string
# precedence information #
\< ','
\> '=' '=op'
\> '?' ':'
\< '||'
\< '&&'
\< '|'
\< '^'
\< '&'
\< '==' '!='
\< '<' '>' '<=' '>='
\< '<<' '>>'
\< '+' '-'
\< '*' '/' '%'
\> '!' '~'
\> '++' '--' SIZEOF
\< '[' '(' '.' '->'
\\
# external definitions #
program:
program external_definition
|
external_definition:
declaration
| function_definition
function_definition:
function_specification function_body {afdef(#1,#2);}
function_specification:
decl_specifiers function_declarator {val=afdcl(1);}
| function_declarator {val=afdcl(0);}
function_body:
formal_declarations compound_statement {val=#2;}
formal_declarations:
formal_decl_list {afpdcl();}
| {afpdcl();}
compound_statement:
begin declaration_list statement_list end {val=#3;}
| begin statement_list end {val=#2;}
init_declarator_list:
init_declarator
| init_declarator_list ',' init_declarator
init_declarator:
$declarator initializer {aidecl();}
| declarator {aidecl();}
| function_declarator {adeclr(maktyp());}
initializer:
initial_value
| '{' initial_value_expression_list '}'
| '{' initial_value_expression_list ',' '}'
initial_value_expression_list:
initial_value_expression
| initial_value_expression_list ',' initial_value_expression
initial_value:
integer {inz(i_int,#1);}
| '-' integer {inz(i_int,-#2);}
| floatcon {inz(i_float,#1);}
| '-' floatcon {inz(i_negfloat,#2);}
| identifier {inz(i_idn,#1);}
| '&' identifier {inz(i_idn,#2);}
| string {inz(i_string,#1);}
initial_value_expression:
constant {inz(i_int,#1);}
| initial_value
# declarations #
declaration_list:
declaration
| declaration_list declaration
declaration:
decl_specifiers init_declarator_list ';'
| literal_type_specifier ';'
decl_specifiers:
type_specifier {attrib(-1,#1);}
| sc_specifier type_specifier {attrib(#1,#2);}
| type_specifier sc_specifier {attrib(#2,#1);}
type_specifier:
type_identifier
| literal_type_specifier
literal_type_specifier:
INT {val=TINT;}
| CHAR {val=TCHAR;}
| FLOAT {val=TFLOAT;}
| DOUBLE {val=TDOUBLE;}
| LONG {val=TINT;}
| LONG INT {val=TINT;}
| SHORT {val=TINT;}
| SHORT INT {val=TINT;}
| LONG FLOAT {val=TDOUBLE;}
| UNSIGNED {val=TINT;}
| UNSIGNED INT {val=TINT;}
| struct '{' type_decl_list '}' {val=astruct(NULL,#3);}
| struct $identifier '{' type_decl_list '}' {val=astruct(#2,#4);}
| struct identifier {val=aostruct(#2);}
sc_specifier:
AUTO {val=c_auto;}
| STATIC {val=c_static;}
| EXTERN {val=c_extern;}
| REGISTER {val=c_auto;}
| TYPEDEF {val=c_typedef;}
declarator_list:
declarator
| declarator_list ',' declarator
declarator:
dclr {val=adeclr(maktyp());}
| identifier ':' constant {val=adeclr(afield(#1,#3));}
| ':' constant {val=adeclr(afield(-1,#2));}
$declarator:
dclr {aiinz(adeclr(maktyp()));}
dclr:
'*' dclr {val=adclr(#2,MPTR);}
| dclr '(' ')' {val=adclr(#1,MFUNC);}
| dclr '[' ']' {val=adclr(#1,MARRAY,1);}
| dclr '[' constant ']' {val=adclr(#1,MARRAY,#3);}
| identifier {val=adclr(0,0);}
| '(' dclr ')' {val=#2;}
function_declarator:
'*' function_declarator {val=adclr(#2,MPTR);}
| function_declarator '(' ')' {val=adclr(#1,MFUNC);}
| function_declarator '[' ']' {val=adclr(#1,MARRAY,1);}
| function_declarator '[' constant ']' {val=adclr(#1,MARRAY,#3);}
| identifier '(' ')' {val=adclr(adclr(0,0),MFUNC);
parml=0;}
| identifier '(' parameter_list ')' {val=adclr(adclr(0,0),MFUNC);
parml=#3;}
| '(' function_declarator ')' {val=#2;}
parameter_list:
identifier {val=push(#1);}
| parameter_list ',' identifier {push(#3);}
formal_decl_list:
formal_declaration
| formal_decl_list formal_declaration
formal_declaration:
type_declaration
| REGISTER type_declaration
type_decl_list:
type_declaration
| type_decl_list type_declaration
type_declaration:
$type_specifier declarator_list ';' {in_type_def=0;
val=#2;}
$type_specifier:
type_specifier {in_type_def=1;
attrib(-1,#1);}
# statements #
statement_list:
statement
| statement_list statement {val=astmtl(#1,#2);}
statement:
expression ';' {val=aexprstmt(#1);}
| compound_statement
| IF '(' expression ')' statement {val=aif(#3,#5,0);}
| IF '(' expression ')' statement ELSE
statement {val=aif(#3,#5,#7);}
| while '(' expression ')' statement {val=awhile(#3,#5);}
| for '(' .expression ';' .expression ';' .expression
')' statement
{val=afor(#3,#5,#7,#9);}
| do statement WHILE '(' expression ')'
';' {val=ado(#2,#5);}
| switch '(' expression ')' statement {val=aswitch(#3,#5);}
| CASE constant ':' statement {val=acase(#2,#4);}
| DEFAULT ':' statement {val=adefault(#3);}
| BREAK ';' {val=abreak();}
| CONTINUE ';' {val=acontinue();}
| RETURN ';' {val=areturn(0);}
| RETURN expression ';' {val=areturn(#2);}
| GOTO lexpression ';' {val=agoto(#2);}
| identifier ':' statement {val=alabel(#1,#3);}
| ENTRY identifier ':' statement {val=aentry(#2,#4);}
| ';' {val=anull();}
# expressions #
.expression:
expression
| {val=0;}
expression_list:
expression \= '='
| expression_list ',' expression {val=aelist(#1,#3);}
expression:
expression '*' expression {val=node(n_times,#1,#3);}
| expression '/' expression {val=node(n_div,#1,#3);}
| expression '%' expression {val=node(n_mod,#1,#3);}
| expression '+' expression {val=node(n_plus,#1,#3);}
| expression '-' expression {val=node(n_minus,#1,#3);}
| expression '<<' expression {val=node(n_ls,#1,#3);}
| expression '>>' expression {val=node(n_rs,#1,#3);}
| expression '<' expression {val=node(n_lt,#1,#3);}
| expression '>' expression {val=node(n_gt,#1,#3);}
| expression '<=' expression {val=node(n_le,#1,#3);}
| expression '>=' expression {val=node(n_ge,#1,#3);}
| expression '==' expression {val=node(n_eq,#1,#3);}
| expression '!=' expression {val=node(n_ne,#1,#3);}
| expression '&' expression {val=node(n_band,#1,#3);}
| expression '^' expression {val=node(n_bxor,#1,#3);}
| expression '|' expression {val=node(n_bior,#1,#3);}
| expression '&&' expression {val=node(n_tv_and,#1,#3);}
| expression '||' expression {val=node(n_tv_or,#1,#3);}
| expression '?' expression ':' expression
{val=node(n_qmark,#1,node(n_colon,#3,#5));}
| expression '=' expression {val=node(n_assign,#1,#3);}
| expression '=op' expression {val=node(n_ars+#2,#1,#3);}
| expression ',' expression {val=node(n_comma,#1,#3);}
| term
# the following productions are ordered very carefully so that the
desired thing is done in the case of a R/R conflict #
lexpression:
expression
| identifier {val=aidn(alidn(#1));}
fterm:
term
| identifier {val=aidn(afidn(#1));}
type_identifier:
identifier {val=atidn(#1);}
term:
term '++' {val=node(n_inca,#1);}
| term '--' {val=node(n_deca,#1);}
| '*' term {val=node(n_star,#2);}
| '&' term {val=node(n_addr,#2);}
| '-' term {val=node(n_uminus,#2);}
| '!' term {val=node(n_tvnot,#2);}
| '~' term {val=node(n_bnot,#2);}
| '++' term {val=node(n_incb,#2);}
| '--' term {val=node(n_decb,#2);}
| SIZEOF term {val=node(n_sizeof,#2);}
| SIZEOF '(' cast_type ')' \= SIZEOF
{val=node(n_int,1);} # hack #
| '(' cast_type ')' term \= '++'
{val=#4;} # hack #
| term '[' expression ']' {val=asubscript(#1,#3);}
| fterm '(' expression_list ')' {val=acall(#1,#3);}
| fterm '(' ')' {val=acall(#1,0);}
| term '.' identifier {val=adot(#1,#3);}
| term '->' identifier {val=aptr(#1,#3);}
| identifier {val=aidn(aeidn(#1));}
| integer {val=node(n_int,#1);}
| floatcon {val=node(n_float,#1);}
| string {val=node(n_string,#1);}
| '(' expression ')' {val=#2;}
cast_type: literal_type_specifier null_decl
null_decl: # empty #
| '(' ')'
| '(' null_decl ')' '(' ')'
| '*' null_decl
| null_decl '[' ']'
| null_decl '[' constant ']'
| '(' null_decl ')'
while: WHILE {apshw();}
do: DO {apshd();}
for: FOR {apshf();}
switch: SWITCH {apshs();}
struct: STRUCT {strlev++;}
$identifier: identifier {val=astridn(#1);}
begin: '{' {abegin();}
end: '}' {aend();}
constant:
constant '*' constant {val=#1*#3;}
| constant '/' constant {val=#1/#3;}
| constant '%' constant {val=#1%#3;}
| constant '+' constant {val=#1+#3;}
| constant '-' constant {val=#1-#3;}
| constant '<<' constant {val=#1<<#3;}
| constant '>>' constant {val=#1>>#3;}
| constant '<' constant {val=#1<#3;}
| constant '>' constant {val=#1>#3;}
| constant '<=' constant {val=#1<=#3;}
| constant '>=' constant {val=#1>=#3;}
| constant '==' constant {val=#1==#3;}
| constant '!=' constant {val=#1!=#3;}
| constant '&' constant {val=#1}
| constant '^' constant {val=#1^#3;}
| constant '|' constant {val=#1|#3;}
| constant '&&' constant {val=#1&}
| constant '||' constant {val=#1||#3;}
| constant '?' constant ':' constant
{val=(#1?#3:#5);}
| c_term
c_term:
'-' c_term {val= -#2;}
| '!' c_term {val= !#2;}
| '~' c_term {val= ~#2;}
| integer
| '(' constant ')' {val=#2;}
29 Oct
29 Oct
3 a.m.
I don't recognize this as any Yacc that my hands have touched.
Looking at the reserved words,
there is one, ENTRY, that I've never heard of (although FORTRAN had an
ENTRY statement),
and there is STRUCT but no UNION. Also, he uses val= instead of
$$=. There don't seem to be
any nontrivial assignment ops (neither += or =+).
Al was at Bell Labs in 1973, and this is dated 5 years later.
The use of quotes for single character literals was in early Yaccs,
but it led to some strange-looking
lexical analyzer code, and I quickly gave it up.
I'm guessing either Al wrote it from scratch or based it on some other
similar program. LR parsing
made quite a stir in the 70's.
Can't help you though as far as how to generate a parser from this
input...
Steve
----- Original Message -----
From: "Lars Brinkhoff" <lars(a)nocrew.org>
To:<tuhs@tuhs.org>
Cc:
Sent:Sun, 28 Oct 2018 21:34:49 +0000
Subject:[TUHS] Archaic yacc C grammar
Hello,
This is Alan Snyder's C grammar. It's supposedly for yacc, but it's
probably using some really ancient version. Maybe from when Alan did
a
stint at Bell labs and converted yacc from B to C.
Does anyone recognize this type of yacc input? I don't have the
corresponding yacc version, and the one in V6 isn't happy about this
file. What would it take to update the grammar for V6 yacc? Add in
some %term, replace with %%?
# C GRAMMAR #
# 28 May 1978 #
# Alan Snyder #
# 26 acceptable conflicts:
2 S/R conflicts for (parsing) ambiguity between
declarators and function_declarators
1 S/R conflict for the C ELSE ambiguity
4 R/R conflicts for the (parsing) problem with regard
to integer constants as initial_values
12 R/R conflicts for the (parsing) problem with regard
to identifiers in function calls
1 R/R conflict for the (parsing) problem with regard
to identifiers in goto statements
4 R/R conflicts and 1 S/R conflict for TYPEDEFs
1 S/R conflict for ambiguous cast types
(int ()) = (int x()) not (int (x))
Approximate description:
18 S/R ( shift 37 reduce 141
50 S/R ( shift 37 reduce 71
81 S/R ( shift 37 reduce 71
113 R/R ( reduce 141 reduce 140
113 R/R ( reduce 159 reduce 140
113 R/R * reduce 159 reduce 141
113 S/R : shift 199 reduce 141
183 R/R , reduce 203 reduce 24
183 R/R } reduce 203 reduce 24
204 R/R ( reduce 159 reduce 140
206 R/R ( reduce 148 reduce 139
207 R/R ( reduce 147 reduce 139
208 R/R ( reduce 145 reduce 139
209 R/R ( reduce 144 reduce 139
210 R/R ( reduce 146 reduce 139
211 R/R ( reduce 149 reduce 139
212 R/R ( reduce 150 reduce 139
215 R/R ( reduce 159 reduce 140
215 R/R ; reduce 159 reduce 138
225 R/R ( reduce 151 reduce 139
228 R/R ( reduce 159 reduce 140
284 R/R , reduce 203 reduce 25
284 R/R } reduce 203 reduce 25
291 S/R ) shift 339 reduce 165
343 R/R ( reduce 153 reduce 139
360 S/R ELSE shift 369 reduce 94
#
# terminal symbols #
';' '}' '{' ']' '[' ')'
'(' ':'
',' '.' '?' '~' '!' '&'
'|' '^'
'%' '/' '*' '-' '+' '='
'<' '>'
'++' '--' '==' '!=' '<='
'>=' '<<' '>>'
'->' '=op' '&&' '||' 'c'
INT CHAR FLOAT DOUBLE STRUCT AUTO STATIC
EXTERN RETURN GOTO IF ELSE SWITCH
BREAK CONTINUE WHILE DO FOR DEFAULT CASE
ENTRY REGISTER SIZEOF LONG SHORT UNSIGNED TYPEDEF 'l'
'm' 'n' 'o' 'p' 'q' 'r'
's'
identifier integer floatcon string
# precedence information #
< ','
'=' '=op'
'?' ':'
< '||'
< '&&'
< '|'
< '^'
< '&'
< '==' '!='
< '<' '>' '<=' '>='
< '<<' '>>'
< '+' '-'
< '*' '/' '%'
'!' '~'
'++' '--' SIZEOF
< '[' '('
'.' '->'
# external definitions #
program:
program external_definition
|
external_definition:
declaration
| function_definition
function_definition:
function_specification function_body {afdef(#1,#2);}
function_specification:
decl_specifiers function_declarator {val=afdcl(1);}
| function_declarator {val=afdcl(0);}
function_body:
formal_declarations compound_statement {val=#2;}
formal_declarations:
formal_decl_list {afpdcl();}
| {afpdcl();}
compound_statement:
begin declaration_list statement_list end {val=#3;}
| begin statement_list end {val=#2;}
init_declarator_list:
init_declarator
| init_declarator_list ',' init_declarator
init_declarator:
$declarator initializer {aidecl();}
| declarator {aidecl();}
| function_declarator {adeclr(maktyp());}
initializer:
initial_value
| '{' initial_value_expression_list '}'
| '{' initial_value_expression_list ',' '}'
initial_value_expression_list:
initial_value_expression
| initial_value_expression_list ',' initial_value_expression
initial_value:
integer {inz(i_int,#1);}
| '-' integer {inz(i_int,-#2);}
| floatcon {inz(i_float,#1);}
| '-' floatcon {inz(i_negfloat,#2);}
| identifier {inz(i_idn,#1);}
| '&' identifier {inz(i_idn,#2);}
| string {inz(i_string,#1);}
initial_value_expression:
constant {inz(i_int,#1);}
| initial_value
# declarations #
declaration_list:
declaration
| declaration_list declaration
declaration:
decl_specifiers init_declarator_list ';'
| literal_type_specifier ';'
decl_specifiers:
type_specifier {attrib(-1,#1);}
| sc_specifier type_specifier {attrib(#1,#2);}
| type_specifier sc_specifier {attrib(#2,#1);}
type_specifier:
type_identifier
| literal_type_specifier
literal_type_specifier:
INT {val=TINT;}
| CHAR {val=TCHAR;}
| FLOAT {val=TFLOAT;}
| DOUBLE {val=TDOUBLE;}
| LONG {val=TINT;}
| LONG INT {val=TINT;}
| SHORT {val=TINT;}
| SHORT INT {val=TINT;}
| LONG FLOAT {val=TDOUBLE;}
| UNSIGNED {val=TINT;}
| UNSIGNED INT {val=TINT;}
| struct '{' type_decl_list '}' {val=astruct(NULL,#3);}
| struct $identifier '{' type_decl_list '}' {val=astruct(#2,#4);}
| struct identifier {val=aostruct(#2);}
sc_specifier:
AUTO {val=c_auto;}
| STATIC {val=c_static;}
| EXTERN {val=c_extern;}
| REGISTER {val=c_auto;}
| TYPEDEF {val=c_typedef;}
declarator_list:
declarator
| declarator_list ',' declarator
declarator:
dclr {val=adeclr(maktyp());}
| identifier ':' constant {val=adeclr(afield(#1,#3));}
| ':' constant {val=adeclr(afield(-1,#2));}
$declarator:
dclr {aiinz(adeclr(maktyp()));}
dclr:
'*' dclr {val=adclr(#2,MPTR);}
| dclr '(' ')' {val=adclr(#1,MFUNC);}
| dclr '[' ']' {val=adclr(#1,MARRAY,1);}
| dclr '[' constant ']' {val=adclr(#1,MARRAY,#3);}
| identifier {val=adclr(0,0);}
| '(' dclr ')' {val=#2;}
function_declarator:
'*' function_declarator {val=adclr(#2,MPTR);}
| function_declarator '(' ')' {val=adclr(#1,MFUNC);}
| function_declarator '[' ']' {val=adclr(#1,MARRAY,1);}
| function_declarator '[' constant ']' {val=adclr(#1,MARRAY,#3);}
| identifier '(' ')' {val=adclr(adclr(0,0),MFUNC);
parml=0;}
| identifier '(' parameter_list ')' {val=adclr(adclr(0,0),MFUNC);
parml=#3;}
| '(' function_declarator ')' {val=#2;}
parameter_list:
identifier {val=push(#1);}
| parameter_list ',' identifier {push(#3);}
formal_decl_list:
formal_declaration
| formal_decl_list formal_declaration
formal_declaration:
type_declaration
| REGISTER type_declaration
type_decl_list:
type_declaration
| type_decl_list type_declaration
type_declaration:
$type_specifier declarator_list ';' {in_type_def=0;
val=#2;}
$type_specifier:
type_specifier {in_type_def=1;
attrib(-1,#1);}
# statements #
statement_list:
statement
| statement_list statement {val=astmtl(#1,#2);}
statement:
expression ';' {val=aexprstmt(#1);}
| compound_statement
| IF '(' expression ')' statement {val=aif(#3,#5,0);}
| IF '(' expression ')' statement ELSE statement
{val=aif(#3,#5,#7);}
| while '(' expression ')' statement {val=awhile(#3,#5);}
| for '(' .expression ';' .expression ';' .expression
')' statement
{val=afor(#3,#5,#7,#9);}
| do statement WHILE '(' expression ')' ';'
{val=ado(#2,#5);}
| switch '(' expression ')' statement {val=aswitch(#3,#5);}
| CASE constant ':' statement {val=acase(#2,#4);}
| DEFAULT ':' statement {val=adefault(#3);}
| BREAK ';' {val=abreak();}
| CONTINUE ';' {val=acontinue();}
| RETURN ';' {val=areturn(0);}
| RETURN expression ';' {val=areturn(#2);}
| GOTO lexpression ';' {val=agoto(#2);}
| identifier ':' statement {val=alabel(#1,#3);}
| ENTRY identifier ':' statement {val=aentry(#2,#4);}
| ';' {val=anull();}
# expressions #
.expression:
expression
| {val=0;}
expression_list:
expression = '='
| expression_list ',' expression {val=aelist(#1,#3);}
expression:
expression '*' expression {val=node(n_times,#1,#3);}
| expression '/' expression {val=node(n_div,#1,#3);}
| expression '%' expression {val=node(n_mod,#1,#3);}
| expression '+' expression {val=node(n_plus,#1,#3);}
| expression '-' expression {val=node(n_minus,#1,#3);}
| expression '<<' expression {val=node(n_ls,#1,#3);}
| expression '>>' expression {val=node(n_rs,#1,#3);}
| expression '<' expression {val=node(n_lt,#1,#3);}
| expression '>' expression {val=node(n_gt,#1,#3);}
| expression '<=' expression {val=node(n_le,#1,#3);}
| expression '>=' expression {val=node(n_ge,#1,#3);}
| expression '==' expression {val=node(n_eq,#1,#3);}
| expression '!=' expression {val=node(n_ne,#1,#3);}
| expression '&' expression {val=node(n_band,#1,#3);}
| expression '^' expression {val=node(n_bxor,#1,#3);}
| expression '|' expression {val=node(n_bior,#1,#3);}
| expression '&&' expression {val=node(n_tv_and,#1,#3);}
| expression '||' expression {val=node(n_tv_or,#1,#3);}
| expression '?' expression ':' expression
{val=node(n_qmark,#1,node(n_colon,#3,#5));}
| expression '=' expression {val=node(n_assign,#1,#3);}
| expression '=op' expression {val=node(n_ars+#2,#1,#3);}
| expression ',' expression {val=node(n_comma,#1,#3);}
| term
# the following productions are ordered very carefully so that the
desired thing is done in the case of a R/R conflict #
lexpression:
expression
| identifier {val=aidn(alidn(#1));}
fterm:
term
| identifier {val=aidn(afidn(#1));}
type_identifier:
identifier {val=atidn(#1);}
term:
term '++' {val=node(n_inca,#1);}
| term '--' {val=node(n_deca,#1);}
| '*' term {val=node(n_star,#2);}
| '&' term {val=node(n_addr,#2);}
| '-' term {val=node(n_uminus,#2);}
| '!' term {val=node(n_tvnot,#2);}
| '~' term {val=node(n_bnot,#2);}
| '++' term {val=node(n_incb,#2);}
| '--' term {val=node(n_decb,#2);}
| SIZEOF term {val=node(n_sizeof,#2);}
| SIZEOF '(' cast_type ')' = SIZEOF
{val=node(n_int,1);} # hack #
| '(' cast_type ')' term = '++'
{val=#4;} # hack #
| term '[' expression ']' {val=asubscript(#1,#3);}
| fterm '(' expression_list ')' {val=acall(#1,#3);}
| fterm '(' ')' {val=acall(#1,0);}
| term '.' identifier {val=adot(#1,#3);}
| term '->' identifier {val=aptr(#1,#3);}
| identifier {val=aidn(aeidn(#1));}
| integer {val=node(n_int,#1);}
| floatcon {val=node(n_float,#1);}
| string {val=node(n_string,#1);}
| '(' expression ')' {val=#2;}
cast_type: literal_type_specifier null_decl
null_decl: # empty #
| '(' ')'
| '(' null_decl ')' '(' ')'
| '*' null_decl
| null_decl '[' ']'
| null_decl '[' constant ']'
| '(' null_decl ')'
while: WHILE {apshw();}
do: DO {apshd();}
for: FOR {apshf();}
switch: SWITCH {apshs();}
struct: STRUCT {strlev++;}
$identifier: identifier {val=astridn(#1);}
begin: '{' {abegin();}
end: '}' {aend();}
constant:
constant '*' constant {val=#1*#3;}
| constant '/' constant {val=#1/#3;}
| constant '%' constant {val=#1%#3;}
| constant '+' constant {val=#1+#3;}
| constant '-' constant {val=#1-#3;}
| constant '<<' constant {val=#1<<#3;}
| constant '>>' constant {val=#1>>#3;}
| constant '<' constant {val=#1<#3;}
| constant '>' constant {val=#1>#3;}
| constant '<=' constant {val=#1<=#3;}
| constant '>=' constant {val=#1>=#3;}
| constant '==' constant {val=#1==#3;}
| constant '!=' constant {val=#1!=#3;}
| constant '&' constant {val=#1}
| constant '^' constant {val=#1^#3;}
| constant '|' constant {val=#1|#3;}
| constant '&&' constant {val=#1&}
| constant '||' constant {val=#1||#3;}
| constant '?' constant ':' constant
{val=(#1?#3:#5);}
| c_term
c_term:
'-' c_term {val= -#2;}
| '!' c_term {val= !#2;}
| '~' c_term {val= ~#2;}
| integer
| '(' constant ')' {val=#2;}
7:31 a.m.
Steve Johnson wrote:
Looking at the reserved words, there is one, ENTRY,
that I've never
heard of (although FORTRAN had an ENTRY statement), and there is
STRUCT but no UNION. Also, he uses val= instead of $$=. There don't
seem to be any nontrivial assignment ops (neither += or =+).
This is for Snyder's C compiler. There is something called =op which
is guess is for =+ etc.
I'm guessing either Al wrote it from scratch or
based it on some other
similar program.
Looks like you're right. I found this in another file, so it would seem
he wrote it back at MIT:
"The original YACC was designed and implemented on a PDP-11/45 and a
Honeywell 6000 by S. C. Johnson at Bell Laboratories. The version
described in this paper was implemented on the PDP-10 by Alan Snyder.
5:52 p.m.
Yes. If it was =op, this means the C program probably used =+
instead of +=. That was the
dialect of C that was around when Al was at Bell Labs. The
transition from =+ to += was a
pain, but decreased errors dramatically (a=-1 vs a= -1).
We actually had a pretty good system for making changes like that.
First, we would change
the compiler to accept both the old and the new. Then we would
produce a warning
that on a particular date the old would no longer work. Then we made
the old an error
and printed a message about how to fix it. Eventually, we just let
it be a syntax error.
This process was applied many times on the way from typeless B to
strongly typed C.
----- Original Message -----
From: "Lars Brinkhoff" <lars(a)nocrew.org>
To:"Steve Johnson" <scj(a)yaccman.com>
Cc:<tuhs@tuhs.org>
Sent:Mon, 29 Oct 2018 07:31:24 +0000
Subject:Re: [TUHS] Archaic yacc C grammar
Steve Johnson wrote:
Looking at the reserved words, there is one, ENTRY,
that I've never
heard of (although FORTRAN had an ENTRY statement), and there is
STRUCT but no UNION. Also, he uses val= instead of $$=. There don't
seem to be any nontrivial assignment ops (neither += or =+).
This is for Snyder's C compiler. There is something called =op which
is guess is for =+ etc.
I'm guessing either Al wrote it from scratch or
based it on some
other
similar program.
Looks like you're right. I found this in another file, so it would
seem
he wrote it back at MIT:
"The original YACC was designed and implemented on a PDP-11/45 and a
Honeywell 6000 by S. C. Johnson at Bell Laboratories. The version
described in this paper was implemented on the PDP-10 by Alan Snyder.
6:37 p.m.
On Mon, Oct 29, 2018 at 12:30 PM Steve Johnson <scj(a)yaccman.com> wrote:
We actually had a pretty good system for making
changes like that. First,
we would change
the compiler to accept both the old and the new. Then we would produce a
warning
that on a particular date the old would no longer work. Then we made the
old an error
and printed a message about how to fix it. Eventually, we just let it be
a syntax error.
This process was applied many times on the way from typeless B to strongly
typed C.
How long a transition period did you typically have?
Warner
30 Oct
30 Oct
8:16 a.m.
Warner Losh wrote:
Steve Johnson wrote:
We actually had a pretty good system for making changes like
that. First, we would change the compiler to accept both the old and
the new. Then we would produce a warning that on a particular date
the old would no longer work. Then we made the old an error and
printed a message about how to fix it.
How long a transition period did you typically have?
I heard the V7 compiler still supports old B style initialization
"int x 42;". So in some cases, a really long time.
3 Nov
3 Nov
9:50 p.m.
One thing that was supported on PCC for many years was the ability to
generate GE/Honeywell 6-bit character constants, using the back quote
(`) character. I remember trying it in the late 80's on a shipping
Sun machine and seeing that it was still present in the grammar, and,
as nearly as I could remember, still produced the correct answer.
Steve
----- Original Message -----
From: "Lars Brinkhoff" <lars(a)nocrew.org>
To:"Warner Losh" <imp(a)bsdimp.com>
Cc:"Steve Johnson" <scj(a)yaccman.com>om>, "The Eunuchs Hysterical
Society"
<tuhs(a)tuhs.org>
Sent:Tue, 30 Oct 2018 08:16:17 +0000
Subject:Re: [TUHS] Archaic yacc C grammar
Warner Losh wrote:
Steve Johnson wrote:
We actually had a pretty good system for making changes like
that. First, we would change the compiler to accept both the old
and
the new. Then we would produce a warning that on a
particular date
the old would no longer work. Then we made the old an error and
printed a message about how to fix it.
How long a transition period did you typically have?
I heard the V7 compiler still supports old B style initialization
"int x 42;". So in some cases, a really long time.
29 Oct
29 Oct
7:02 p.m.
On Oct 29, 2018, at 10:52 AM, Steve Johnson
<scj(a)yaccman.com> wrote:
We actually had a pretty good system for making changes like that. First, we would
change
the compiler to accept both the old and the new. Then we would produce a warning
that on a particular date the old would no longer work. Then we made the old an error
and printed a message about how to fix it. Eventually, we just let it be a syntax
error.
This process was applied many times on the way from typeless B to strongly typed C.
Was there ever a time when a change was desired that you couldn’t accept both
the old and the new?
David
30 Oct
30 Oct
10:01 p.m.
The closest I came was when we went from a single namespace for all
structure names to a namespace for each structure, and references that
were checked using the pointer type of the structure pointer.
My code was a nightmare, and some of the old Unix code was at least a
bad dream. I had to start out pretending to have a single
namespace, but when I saw the use of an actual structure pointer I had
to do it the new way. As I recall when I saw something that would
not have been legal with the old rules (for example, two different
structures with the same element name but different offsets) then I
threw
the switch and demanded the new way.
There were certainly system changes that were flash cut. For
example, changing the file system format -- there was no attempt to
allow both, which meant that the conversion program got one shot to
get it right. And it didn't always manage that...
Steve
----- Original Message -----
From:
david(a)kdbarto.org
To:
"Steve Johnson" <scj(a)yaccman.com>
Cc:
"The Eunuchs Hysterical Society" <tuhs(a)tuhs.org>
Sent:
Mon, 29 Oct 2018 12:02:29 -0700
Subject:
Re: [TUHS] Archaic yacc C grammar
On Oct 29, 2018, at 10:52 AM, Steve Johnson <scj(a)yaccman.com [1]>
wrote:
We actually had a pretty good system for making changes like that.
First, we would change
the compiler to accept both the old and the new. Then we would
produce a warning
that on a particular date the old would no longer work. Then we made
the old an error
and printed a message about how to fix it. Eventually, we just let
it be a syntax error.
This process was applied many times on the way from typeless B to
strongly typed C.
Was there ever a time when a change was desired that you couldn’t
accept both
the old and the new?
David
Links:
------
[1] mailto:scj@yaccman.com
31 Oct
31 Oct
12:58 a.m.
I'm coming into this late (and tired, been working on my water system
and the carbs on my boat all day) but I *loved* the single namespace
for all structure fields.
Instead of
p->size
we have
p->st_size
and I instantly know that p is a struct stat pointer.
I get that it doesn't scale but man, oh man, do I love the early Unix
data structures that had one namespace. I kinda wish you hadn't fixed
that Steve.
What was the push that made you fix it?
On Tue, Oct 30, 2018 at 03:01:55PM -0700, Steve Johnson wrote:
The closest I came was when we went from a single
namespace for all
structure names to a namespace for each structure, and references that
were checked using the pointer type of the structure pointer.
My code was a nightmare, and some of the old Unix code was at least a
bad dream.???? I had to start out pretending to have a single
namespace, but when I saw the use of an actual structure pointer I had
to do it the new way.?? As I recall when I saw something that would
not have been legal with the old rules (for example, two different
structures with the same element name but different offsets) then I
threw
the switch and demanded the new way.??
There were certainly system changes that were flash cut.?? For
example, changing the file system format -- there was no attempt to
allow both, which meant that the conversion program got one shot to
get it right.?? And it didn't always manage that...
Steve
----- Original Message -----
From:
david(a)kdbarto.org
To:
"Steve Johnson" <scj(a)yaccman.com>
Cc:
"The Eunuchs Hysterical Society" <tuhs(a)tuhs.org>
Sent:
Mon, 29 Oct 2018 12:02:29 -0700
Subject:
Re: [TUHS] Archaic yacc C grammar
On Oct 29, 2018, at 10:52 AM, Steve Johnson <scj(a)yaccman.com [1]>
wrote:
We actually had a pretty good system for making changes like that.??
First, we would change
the compiler to accept both the old and the new.???? Then we would
produce a warning
that on a particular date the old would no longer work.?? Then we made
the old an error
and printed a message about how to fix it.???? Eventually, we just let
it be a syntax error.
This process was applied many times on the way from typeless B to
strongly typed C.
Was there ever a time when a change was desired that you couldn???t
accept both
the old and the new?
David
Links:
------
[1] mailto:scj@yaccman.com
--
---
Larry McVoy lm at mcvoy.com http://www.mcvoy.com/lm
1:49 p.m.
On Tue, Oct 30, 2018 at 9:46 PM Larry McVoy <lm(a)mcvoy.com> wrote:
Instead of
p->size
we have
p->st_size
and I instantly know that p is a struct stat pointer.
+1
Amen Larry. I understand why people had a desire for different
namespaces, but a single namespace sure made code a lot more readable and
understandable.
I still use that trick in new code, because I think it just makes it easier
to identify what is going on when I glance at it.
Clem
ᐧ
3 Nov
3 Nov
10:14 p.m.
----- Original Message -----
From:"Larry McVoy" <lm(a)mcvoy.com>
...
I get that it doesn't scale but man, oh man, do I love the
early Unix
data structures that had one namespace. I kinda wish you hadn't
fixed
that Steve.
What was the push that made you fix it?
It came from Dennis, so I can't say why he decided to change it. The
argument for it is that many structures would have similar names and
similar functions, such as "next" and "prev" in linked lists.
Adding a new linked list action could be done much more easily by
copying the code and changing the declaration, instead of having to
change ab_next into cd_next, and then dealing with the inevitable
typos that would sneak a use of ab_next into code for cd.
Just to clarify, from the beginning I considered C to be Dennis'
language. I would make suggestions, and sometimes he adopted them
(I'm responsible for ^ as the exclusive OR, for example). In one
case, with casts, we were porting Unix to the 32-bit Interdata and
desparately needed a cast operator, but couldn't find a syntax that we
liked that was general enough to handle casts to, for example,
structure pointers or function pointers. Matters were approaching a
crisis, and one evening I played with the yacc grammar and worked out
the strengths and weaknesses of the top three candidates. I
suggested the one that I felt was best, and that was what was adopted.
The simple rule was that you formed a cast by taking a declaration
of what you wanted the result to be, remove the variable being
declared, and enclose the rest in parens. I had implemented it and
saw that it worked (because the port was based on PCC, there wasn't
nearly the pressure to change the PDP-11 compiler). The fact that
we could explain the syntax in one sentence led us to feel like it
would be reasonable. The problem, of course, is that we didn't put
anything back where the variable had been, so when you encounter a
nontrivial cast you have to enumerate all the possible places a
variable might be and determine which one is syntactically correst
while your brain turns to mush...
Steve
31 Oct
31 Oct
6:09 a.m.
Steve Johnson wrote:
The closest I came was when we went from a single
namespace for all
structure names to a namespace for each structure, and references that
were checked using the pointer type of the structure pointer. My code
was a nightmare, and some of the old Unix code was at least a bad
dream.
How about this, pointer to int used as pointer to struct.
prlook( pp ) int *pp;{
int j;
pp = pp->lset;
....
2000
days inactive
2006
days old
12 comments
6 participants
participants (6)
-
Clem Cole -
David -
Larry McVoy -
Lars Brinkhoff -
Steve Johnson -
Warner Losh