Simple data share in Inferno. Define a struct with a single byte in it.

Now with b == nil throw in a b.data = 42. Visible channel to every process.

This requires 0xF zillion to be writeable.

On 26 November 2015 at 22:22, Brantley Coile <brantleycoile@me.com> wrote:

> 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/
>>
>>
>>