Hi Bakul.  Long time since our Bay Area plan 9 hacking sessions. I've avoided the valley all together for a year and a half now. Not quite long enough yet. 

I thought the same thing, using ~0 for nil, but realized two things. First, that's a valid address on the PDP11 where the convention developed. It's the unibus space. Second, ~0 + member offest is still in page zero. 

By the way, are there any structs more than 4K in Linux? Are there any in plan 9?

Sent from my iPad

On Nov 26, 2015, at 2:27 AM, Bakul Shah <bakul@bitblocks.com> wrote:

Using 0xfff...f instead of 0 for a null ptr might've been less "disgusting"! 

On Nov 25, 2015, at 6:04 PM, Prof Brucee <prof.brucee@gmail.com> wrote:

gcc is indeed a very sad tome. The mmap of 0 is disgusting. I like kenc. It just works. My behaviour this afternoon will be undefined but not as stupid as that of some programmers.

On 26/11/2015 5:43 AM, "Brantley Coile" <brantleycoile@me.com> wrote:

Align it to column 7 and it looks like all the code I saw when I started. 

iPhone email

On Nov 25, 2015, at 12:13 PM, Ryan Gonzalez <rymg19@gmail.com> wrote:

Neither! It's what happens when you run sed 's/^\s*//' on your whole code base, yielding results like (from cmd/yacc.c):

void

setup(int argc, char *argv[])

{

long c, t;

int i, j, fd, lev, ty, ytab, *p;

int vflag, dflag, stem;

char actnm[8], *stemc, *s, dirbuf[128];

Biobuf *fout;

ytab = 0;

vflag = 0;

dflag = 0;

stem = 0;

stemc = "y";

foutput = 0;

fdefine = 0;

fdebug = 0;

ARGBEGIN{

case 'v':

case 'V':

vflag++;

break;

case 'D':

yydebug = ARGF();

break;

case 'a':

yyarg = 1;

break;

case 'd':

dflag++;

break;

case 'l':

yyline = 0;

break;

case 'o':

ytab++;

ytabc = ARGF();

break;

case 's':

stem++;

stemc = ARGF();

break;

case 'S':

parser = PARSERS;

break;

default:

error("illegal option: %c", ARGC());

}ARGEND

openup(stemc, dflag, vflag, ytab, ytabc);

fout = dflag?fdefine:ftable;

if(yyarg){

Bprint(ftable, "#define\tYYARG\t1\n\n");

}

if((fd = mkstemp(ttempname)) >= 0){

tempname = ttempname;

ftemp = Bfdopen(fd, OWRITE);

}

if((fd = mkstemp(tactname)) >= 0){

actname = tactname;

faction = Bfdopen(fd, OWRITE);

}

if(ftemp == 0 || faction == 0)

error("cannot open temp file");

if(argc < 1)

error("no input file");

infile = argv[0];

if(infile[0] != '/' && getwd(dirbuf, sizeof dirbuf)!=nil){

i = strlen(infile)+1+strlen(dirbuf)+1+10;

s = malloc(i);

if(s != nil){

snprint(s, i, "%s/%s", dirbuf, infile);

cleanname(s);

infile = s;

}

}

finput = Bopen(infile, OREAD);

if(finput == 0)

error("cannot open '%s'", argv[0]);

cnamp = cnames;

defin(0, "$end");

extval = PRIVATE; /* tokens start in unicode 'private use' */

defin(0, "error");

defin(1, "$accept");

defin(0, "$unk");

mem = mem0;

i = 0;

for(t = gettok(); t != MARK && t != ENDFILE;)

switch(t) {

case ';':

t = gettok();

break;

case START:

if(gettok() != IDENTIFIER)

error("bad %%start construction");

start = chfind(1, tokname);

t = gettok();

continue;

case TYPEDEF:

if(gettok() != TYPENAME)

error("bad syntax in %%type");

ty = numbval;

for(;;) {

t = gettok();

switch(t) {

case IDENTIFIER:

if((t=chfind(1, tokname)) < NTBASE) {

j = TYPE(toklev[t]);

if(j != 0 && j != ty)

error("type redeclaration of token %s",

tokset[t].name);

else

SETTYPE(toklev[t], ty);

} else {

j = nontrst[t-NTBASE].value;

if(j != 0 && j != ty)

error("type redeclaration of nonterminal %s",

nontrst[t-NTBASE].name );

else

nontrst[t-NTBASE].value = ty;

}

case ',':

continue;

case ';':

t = gettok();

default:

break;

}

break;

}

continue;

case UNION:

/* copy the union declaration to the output */

cpyunion();

t = gettok();

continue;

case LEFT:

case BINARY:

case RIGHT:

i++;

case TERM:

/* nonzero means new prec. and assoc. */

lev = t-TERM;

ty = 0;

/* get identifiers so defined */

t = gettok();

/* there is a type defined */

if(t == TYPENAME) {

ty = numbval;

t = gettok();

}

for(;;) {

switch(t) {

case ',':

t = gettok();

continue;

case ';':

break;

case IDENTIFIER:

j = chfind(0, tokname);

if(j >= NTBASE)

error("%s defined earlier as nonterminal", tokname);

if(lev) {

if(ASSOC(toklev[j]))

error("redeclaration of precedence of %s", tokname);

SETASC(toklev[j], lev);

SETPLEV(toklev[j], i);

}

if(ty) {

if(TYPE(toklev[j]))

error("redeclaration of type of %s", tokname);

SETTYPE(toklev[j],ty);

}

t = gettok();

if(t == NUMBER) {

tokset[j].value = numbval;

if(j < ndefout && j > 3)

error("please define type number of %s earlier",

tokset[j].name);

t = gettok();

}

continue;

}

break;

}

continue;

case LCURLY:

defout(0);

cpycode();

t = gettok();

continue;

default:

error("syntax error");

}

if(t == ENDFILE)

error("unexpected EOF before %%");

/* t is MARK */

if(!yyarg)

Bprint(ftable, "extern int yyerrflag;\n");

Bprint(ftable, "#ifndef YYMAXDEPTH\n");

Bprint(ftable, "#define YYMAXDEPTH 150\n");

Bprint(ftable, "#endif\n" );

if(!ntypes) {

Bprint(ftable, "#ifndef YYSTYPE\n");

Bprint(ftable, "#define YYSTYPE int\n");

Bprint(ftable, "#endif\n");

}

if(!yyarg){

Bprint(ftable, "YYSTYPE yylval;\n");

Bprint(ftable, "YYSTYPE yyval;\n");

}else{

if(dflag)

Bprint(ftable, "#include \"%s.%s\"\n\n", stemc, FILED);

Bprint(fout, "struct Yyarg {\n");

Bprint(fout, "\tint\tyynerrs;\n");

Bprint(fout, "\tint\tyyerrflag;\n");

Bprint(fout, "\tvoid*\targ;\n");

Bprint(fout, "\tYYSTYPE\tyyval;\n");

Bprint(fout, "\tYYSTYPE\tyylval;\n");

Bprint(fout, "};\n\n");

}

prdptr[0] = mem;

/* added production */

*mem++ = NTBASE;

/* if start is 0, we will overwrite with the lhs of the first rule */

*mem++ = start;

*mem++ = 1;

*mem++ = 0;

prdptr[1] = mem;

while((t=gettok()) == LCURLY)

cpycode();

if(t != IDENTCOLON)

error("bad syntax on first rule");

if(!start)

prdptr[0][1] = chfind(1, tokname);

/* read rules */

while(t != MARK && t != ENDFILE) {

/* process a rule */

rlines[nprod] = lineno;

if(t == '|')

*mem++ = *prdptr[nprod-1];

else

if(t == IDENTCOLON) {

*mem = chfind(1, tokname);

if(*mem < NTBASE)

error("token illegal on LHS of grammar rule");

mem++;

} else

error("illegal rule: missing semicolon or | ?");

/* read rule body */

t = gettok();

more_rule:

while(t == IDENTIFIER) {

*mem = chfind(1, tokname);

if(*mem < NTBASE)

levprd[nprod] = toklev[*mem];

mem++;

t = gettok();

}

if(t == PREC) {

if(gettok() != IDENTIFIER)

error("illegal %%prec syntax");

j = chfind(2, tokname);

if(j >= NTBASE)

error("nonterminal %s illegal after %%prec",

nontrst[j-NTBASE].name);

levprd[nprod] = toklev[j];

t = gettok();

}

if(t == '=') {

levprd[nprod] |= ACTFLAG;

Bprint(faction, "\ncase %d:", nprod);

cpyact(mem-prdptr[nprod]-1);

Bprint(faction, " break;");

if((t=gettok()) == IDENTIFIER) {

/* action within rule... */

sprint(actnm, "$$%d", nprod);

/* make it a nonterminal */

j = chfind(1, actnm);

/*

* the current rule will become rule number nprod+1

* move the contents down, and make room for the null

*/

for(p = mem; p >= prdptr[nprod]; --p)

p[2] = *p;

mem += 2;

/* enter null production for action */

p = prdptr[nprod];

*p++ = j;

*p++ = -nprod;

/* update the production information */

levprd[nprod+1] = levprd[nprod] & ~ACTFLAG;

levprd[nprod] = ACTFLAG;

if(++nprod >= NPROD)

error("more than %d rules", NPROD);

prdptr[nprod] = p;

/* make the action appear in the original rule */

*mem++ = j;

/* get some more of the rule */

goto more_rule;

}

}

while(t == ';')

t = gettok();

*mem++ = -nprod;

/* check that default action is reasonable */

if(ntypes && !(levprd[nprod]&ACTFLAG) && nontrst[*prdptr[nprod]-NTBASE].value) {

/* no explicit action, LHS has value */

int tempty;

tempty = prdptr[nprod][1];

if(tempty < 0)

error("must return a value, since LHS has a type");

else

if(tempty >= NTBASE)

tempty = nontrst[tempty-NTBASE].value;

else

tempty = TYPE(toklev[tempty]);

if(tempty != nontrst[*prdptr[nprod]-NTBASE].value)

error("default action causes potential type clash");

}

nprod++;

if(nprod >= NPROD)

error("more than %d rules", NPROD);

prdptr[nprod] = mem;

levprd[nprod] = 0;

}

/* end of all rules */

defout(1);

finact();

if(t == MARK) {

Bprint(ftable, "\n");

if(yyline)

Bprint(ftable, "#line\t%d\t\"%s\"\n", lineno, infile);

while((c=Bgetrune(finput)) != Beof)

Bputrune(ftable, c);

}

Bterm(finput);

}

On Wed, Nov 25, 2015 at 10:03 AM, <plannine@sigint.cs.purdue.edu> wrote:

On Wed, Nov 25, 2015 at 09:25:55AM -0500, Brantley Coile wrote:
> unindented consequences

Is that a class of Python bugs or an awesome name for a Nerdcore band?

--

Ryan

[ERROR]: Your autotools build scripts are 200 lines longer than your program. Something’s wrong.

http://kirbyfan64.github.io/