Cbrain

cbrain
The cbrain eso programming language is an extension of the pbrain programming language for use from OpenCOBOL that adds numbers and various operators. Pronounced see brain. pbrain was extended with the addition of instructions matching C augmented assignments, a few 'lettered' operators (breaking comment compatibility, adding {} cell neutral comment segments to compensate) and integer number support to pbrain instructions. pbrain was created by Paul M. Parks in 2004.

The source code linked by Daniel B Cristofani for pbrain.c looked like an excellent candidate for inclusion in the OpenCOBOL link library toolkit. This source was then modified as cbrain.c by Brian Tiffin in 2013.

hello
0 (<<<<< <<<<<)   > 72 > 101 > 7 o a c c +++ > 32 > 99 c - > 114 o - > 105 c > 5 a > 32 > 0 : <<< [. >] << [. <] 10.

displayed as

Hello cbrain niarbc olleH

When is Easter?
From the Computus, Anonymous Gregorian algorithm

{When is Easter?} 0 > 89 > 101 > 97 > 114 > 63 > 32 > 0   <[<]>[.>]<[<]    =    c > 19 % o > 100 d o > 4 d    <<< @ >>>> ! > 8 a > 25 d < > ! o s + > 3 d < <<<<< < @ >>>>> >> ! > 19 m <<<<< < @ >>>>> >> ! a <<<< @ >>>>> ! s o s > 15 a > 30 % <<<<< @ >>>>> > ! > 4 d   o <<<<< < @ >>>>> >> ! a > 2 m > 32 a <<< @ >>>> ! s o s > 7 % <<< @ >>>> ! > 11 m <<<<< <<<<< < @ >>>>> >>>>> >> ! a o > 22 m a > 451 d < o <<<<< @ >>>>> > ! a o > 7 m s > 114 a   c > 31 % + o > 31 d   {yyyy/mm/dd form} <<<<< <<<<< <<<<< < n >>>>> >>>>> >>>>> > 47. < n 47. < n 10. q with a run of

$ ./cbrainrun computus.cb   Year? 2014   2014/4/20

ASCII chart
{Display an ASCII chart} 0 > 65 > 83 > 67 > 73 c > 32 > 67 > 104 > 97 > 114 > 116 > 10 > 45 c c c c c c c c c c > 10 > 0 <[<] >[.>] <[<]   32 > 128 o s [ > 5 @ [ <          o n >9.32.61.32.<. >9.<          << + > -           > ! - @        ] <        o n >9.32.61.32.<. >10.<        << + > -    ]

giving

ASCII Chart ---   32   =      33       = !    34       = "    35       = #    36       = $    37       = %    38   = &    39       = '    40       = (    41       = )    42       = *    43       = +    44   =,    45       = -    46       = .    47       = /    48       = 0    49       = 1    50   = 2    51       = 3    52       = 4    53       = 5    54       = 6    55       = 7    56   = 8    57       = 9    58       = :    59       = ;    60       = <    61       = =    62   = >    63       = ?    64       = @    65       = A    66       = B    67       = C    68   = D    69       = E    70       = F    71       = G    72       = H    73       = I    74   = J    75       = K    76       = L    77       = M    78       = N    79       = O    80   = P    81       = Q    82       = R    83       = S    84       = T    85       = U    86   = V    87       = W    88       = X    89       = Y    90       = Z    91       = [ 92  = \    93       = ]    94       = ^    95       = _    96       = `    97       = a    98   = b    99       = c    100      = d    101      = e    102      = f    103      = g    104  = h    105      = i    106      = j    107      = k    108      = l    109      = m    110  = n    111      = o    112      = p    113      = q    114      = r    115      = s    116  = t    117      = u    118      = v    119      = w    120      = x    121      = y    122  = z    123      = {    124      = |    125      = }    126      = ~    127      =

Built with OpenCOBOL
Tested using CALL from OpenCOBOL and compiled with each of

cobc -x callcbrain.cob cbrain.c cobc -x cbrainrun.cob subcranial.cob cbrain.c -lreadline

and from C with

gcc -o cbrainmain cbrainmain.c

or with the COBOL compiler

cobc -x cbrainmain.c -lreadline cobc -x cbrainmain.c subcranial.cob -lreadline

cbrain adds
reserved words MUST start in column one of the source text

cbrain interpreter
Many thanks to Daniel B Christofani and Paul M Park.

Well, the central interpreter is

/* cbrain */ /* pbrain interpreter in old-style C       This is an interpreter for Paul M. Parks's pbrain programming language, a variant of Urban Mueller's programming language. Do anything you want with this program. I welcome bug reports and feature requests. Daniel B Cristofani (http://www.hevanet.com/cristofd/) 20130327, extended and put into service with OpenCOBOL as      cbrain btiffin (https://sourceforge.net/users/btiffin) ...   */    scale=0; for(q=0;q<length;q++){ switch(code[q]){ case '(': case '[': s[sp++]=q; break;           case ')': if(!sp--||code[s[sp]]!='(') {e(7); return(0);} t[s[sp]]=q; break;            case ']': if(!sp--||code[t[t[s[sp]]=q]=s[sp]]!='[') {e(5); return(0);} break;        }    }    if(sp) e(code[s[--sp]]=='['?4:6);    for(q=0;q<=PROCEDURES;q++) ptable[q]=-1;    for(q=0;q': if(++p>=SIZE) {e(3); p=SIZE; return(-1);} scale=0; break;            case '.': putchar(a[p]==10?'\n':a[p]); scale=0; break;            case ',': if((c=getchar)!=EOF) a[p]=c=='\n'?10:c; scale=0; break; case '[': if(!a[p]) q=t[q]; scale=0; break; case ']': if(a[p]) q=t[q]; scale=0; break; /* pbrain */ case '(': ptable[a[p]]=q; q=t[q]; scale=0; break;           case ')': q=s[--sp]; scale=0; break; case ':': s[sp++]=q; if((q=ptable[a[p]])<0) e(2); scale=0; break; /* cbrain */ case '{': tmp=1; while(tmp&&q++<length) {tmp-=(code[q]=='}'); tmp+=(code[q]=='{');} if(tmp) {e(9); return(0);} scale=0; break; case '}': e(10); return(0); scale=0; break; case '*': a[p]*=10; scale=0; break; case '/': a[p]/=10; scale=0; break; case '&': if(p<1) {e(3); return(0);} a[--p]&=a[p+1]; scale=0; break; case '|': if(p<1) {e(3); return(0);} a[--p]|=a[p+1]; scale=0; break; case '^': if(p<1) {e(3); return(0);} a[--p]^=a[p+1]; scale=0; break; case '~': a[p]=~a[p]; scale=0; break; case 'a': if(p<1) {e(3); return(0);} a[--p]+=a[p+1]; scale=0; break; case 's': if(p<1) {e(3); return(0);} a[--p]-=a[p+1]; scale=0; break; case 'm': if(p<1) {e(3); return(0);} a[--p]*=a[p+1]; scale=0; break; case 'd': if(p<1) {e(3); return(0);} if(a[p]) {tmp=a[p-1]; a[p-1]/=a[p]; a[p]=tmp-a[p]*a[p-1];} scale=0; break; case '%': if(p<1) {e(3); return(0);} a[--p]%=a[p+1]; scale=0; break; case 'r': if(p<1) {e(3); return(0);} a[--p]>>=a[p+1]; scale=0; break; case 'l': if(p<1) {e(3); return(0);} a[--p]<<=a[p+1]; scale=0; break; case '0': a[p]*=(scale++>0)?10:0; break; case '1': a[p]*=(scale++>0)?10:0; a[p]+=1; break; case '2': a[p]*=(scale++>0)?10:0; a[p]+=2; break; case '3': a[p]*=(scale++>0)?10:0; a[p]+=3; break; case '4': a[p]*=(scale++>0)?10:0; a[p]+=4; break; case '5': a[p]*=(scale++>0)?10:0; a[p]+=5; break; case '6': a[p]*=(scale++>0)?10:0; a[p]+=6; break; case '7': a[p]*=(scale++>0)?10:0; a[p]+=7; break; case '8': a[p]*=(scale++>0)?10:0; a[p]+=8; break; case '9': a[p]*=(scale++>0)?10:0; a[p]+=9; break; case '=': scanf("%d", &a[p]); scale=0; break; case 'n': printf("%d", a[p]); scale=0; break; case '#': printf("%020ld ", a[p]); scale=0; break; case 'b': printf("%64s", long_to_binary(a[p])); scale=0; break; case 'x': tmp=a[p];a[p]=a[p-1];a[p-1]=tmp; scale=0; break; case 'c': if(p>=SIZE) {e(3); return(0);} a[++p]=a[p-1]; scale=0; break; case 'o': if(p<1||p>=SIZE) {e(3); return(0);} a[++p]=a[p-2]; scale=0; break; case '@': memreg=a[p]; scale=0; break; case '!': a[p]=memreg; scale=0; break; case '"': a[p]=opencobol(a[p]); scale=0; break;           case '?': tmp=p; while(tmp-->=0) printf("[%05d is %020ld]\n", tmp+1, a[tmp+1]); scale=0; break;            case 't': tracer=(tracer?0:1); scale=0; break;            case 'g': return (p+1);            case 'q': return(-1);            default: scale=0;        }        if (tracing && !isspace(code[q])) {            fprintf(stderr, " after %05d is %020ld]\n", p, a[p]);            tracing=0;        }    }    /* COBOL is an ordinal language, first is 1 */    return(p+1);

OpenCOBOL test head
OCOBOL >>SOURCE FORMAT IS FIXED *> *******************************************************         *> Author:    Brian Tiffin *> Date:     20130326 *> Purpose:  cbrain *> Tectonics: cobc -x callcbrain.cob cbrain.c         *> ******************************************************* identification division. program-id. callcbrain. data division. working-storage section. 01 cbrain-cmd          pic x(132). 01 string-cell         pic z(19)9. 01 fielded-variable    pic xxx. 01 cell                pic s9(8). 01 looper              pic s9(8). 01 brain-cells. 05 brain-cell usage binary-c-long occurs 65536 times. *> *******************************************************          procedure division. *call "cbrain" using brain-cells *   by content "file hoc.cb" & x"00" *end-call initialize brain-cells call "cbrain" using brain-cells by content "file bitwise.cb" & x"00" returning cell end-call display "OC: from bitwise.cb " brain-cell(cell) end-display call "cbrain" using brain-cells by content "127 > 85 ^" & x"00" returning cell end-call display "OC: from expression " brain-cell(cell) end-display call "cbrain" using brain-cells "{127 xor 85}" & "{define procedure 1 for newline}" & "0+(@ 10 . !)" &              "{place 127 in memory 0," & " place 85 in memory 1," & " bitwise XOR," & " display as number." &              "  Then, call procedure 1 for a newline," & " fetching and restoring current afterwards}" & "127" &              "> 85 ^ #" &               "@ 1 : !" & x"00" returning cell end-call display "OC: 127 xor 85 = " brain-cell(cell) end-display initialize brain-cells call "cbrain" using brain-cells by content "file morehello.cb" & x"00" returning cell on exception continue end-call initialize brain-cells call "cbrain" using brain-cells by content "file pbrains.cb" & x"00" returning cell on exception continue end-call *> this is why bitwise might actually get written someday move 123 to fielded-variable initialize brain-cells call "cbrain" using brain-cells by content function concatenate(                  fielded-variable                    "> 31 &", x"00") returning cell end-call display "OC: fielded-variable " fielded-variable " and 31 is " brain-cell(cell) end-display perform varying looper from 1 by 1 until looper > 5 move looper to string-cell string string-cell delimited by size " > 91 a # > 38 . 32 . <  > 31 # &  > 61 . 32 . < # b" & " @ 10 . !" delimited by size x"00" delimited by size into cbrain-cmd on overflow display "too much brain" end-display end-string initialize brain-cells call "cbrain" using brain-cells by content cbrain-cmd returning cell on exception continue end-call *   display "OC: " brain-cell(cell) end-display end-perform goback. end program callcbrain.

Giving a run sample on Fedora 18 and OpenCOBOL 1.1CE

+00000008    +00000014     +00000015     -00000009     +00000015     +00000001     +00000003     +555000000     OC: from bitwise.cb +00000000000555000000 OC: from expression +00000000000000000042 +00000042    OC: 127 xor 85 = +00000000000000000042 Hello OpenCOBOL! 'Sup earth Hello cbrain niarbc olleH 8   ABCDE EsoAPI required OC: fielded-variable 123 and 31 is +00000000000000000027 +00000092 & +00000031 = +00000028 0000000000000000000000000000000000000000000000000000000000011100    +00000093 & +00000031 = +00000029 0000000000000000000000000000000000000000000000000000000000011101     +00000094 & +00000031 = +00000030 0000000000000000000000000000000000000000000000000000000000011110     +00000095 & +00000031 = +00000031 0000000000000000000000000000000000000000000000000000000000011111     +00000096 & +00000031 = +00000000 0000000000000000000000000000000000000000000000000000000000000000

and steps trace on standard error of

[00244 0 at 00014 was        1,  after 00014 is         0] [00246 { at 00014 was        0,  after 00014 is         0] [00293 + at 00014 was        0,  after 00014 is         1] [00294 + at 00014 was        1,  after 00014 is         2] [00295 + at 00014 was        2,  after 00014 is         3] [00296 + at 00014 was        3,  after 00014 is         4] [00297 + at 00014 was        4,  after 00014 is         5] [00299 > at 00014 was        5,  after 00015 is        10] [00301 0 at 00015 was       10,  after 00015 is         0] [00303 + at 00015 was        0,  after 00015 is         1] [00304 + at 00015 was        1,  after 00015 is         2] [00305 + at 00015 was        2,  after 00015 is         3] [00306 + at 00015 was        3,  after 00015 is         4] [00307 + at 00015 was        4,  after 00015 is         5] [00308 + at 00015 was        5,  after 00015 is         6] [00309 + at 00015 was        6,  after 00015 is         7] [00310 + at 00015 was        7,  after 00015 is         8] [00311 + at 00015 was        8,  after 00015 is         9] [00312 + at 00015 was        9,  after 00015 is        10] [00314 * at 00015 was       10,  after 00015 is       100] [00316 m at 00015 was      100,  after 00014 is       500] [00318 > at 00014 was      500,  after 00015 is       100] [00320 5 at 00015 was      100,  after 00015 is         5] [00321 5 at 00015 was        5,  after 00015 is        55] [00323 a at 00015 was       55,  after 00014 is       555] [00325 * at 00014 was      555,  after 00014 is      5550] [00326 * at 00014 was     5550,  after 00014 is     55500] [00327 * at 00014 was    55500,  after 00014 is    555000] [00328 * at 00014 was   555000,  after 00014 is   5550000] [00329 * at 00014 was  5550000,  after 00014 is  55500000] [00330 * at 00014 was 55500000,  after 00014 is 555000000] [00332 # at 00014 was 555000000, after 00014 is 555000000] [00334 t at 00014 was 555000000, after 00014 is 555000000]

with morehello.cb

[-][bf style] +++++ +++++            {initialize counter (cell #0) to 10} [                      {use loop to set the next four cells to 70/100/30/10} > +++++ ++             {add  7 to cell #1} > +++++ +++++          {add 10 to cell #2} > +++                  {add  3 to cell #3} > +                    {add  1 to cell #4} <<<< -                 {decrement counter (cell #0)} ]                      > ++ .                  {print 'H'} > + .                  {print 'e'} +++++ ++ .             {print 'l'} .                      {print 'l'} +++ .                  {print 'o'} > ++ .                 {print ' '} << +++++ ++ .          {print 'O'} > + .                  {print 'p'} - - - .        {print 'e'} +++++ ++++ .           {print 'n'} < - - -- .     {print 'C'} +++++ +++++ ++ .       {print 'O'} - - --- .      {print 'B'} +++++ +++++ +++ .      {print 'O'} --- .                  {print 'L'} >> + .                 {print '!'} > .                    {print '\n'} 0[eso style] 39 > 83 > 117 > 112 > 32 > 101 > 97 > 114 > 116 > 104 > 0   < < < < < < < < < <    [. >] > 01 * .    {cbrain style} 0 (<<<<< <<<<<)   > 72 > 101 > 7 o a c c +++ > 32 > 99 c -> 114 o - > 105 c > 5 a > 32 > 0 : <<< [. >] << [. <] 10.

displayed as

Hello OpenCOBOL! 'Sup earth Hello cbrain niarbc olleH

help
help is built into a sub module system

OCOBOL >>SOURCE FORMAT IS FREE *> ********************************************************         *> Author:    Brian Tiffin *> Date:     20130331 *> Purpose:  submodule for cbrain *> Tectonics: cobc -x cbrainrun.cob subcranial.cob cbrain.c -lreadline *>           cb: 23 # "subcranial" # *> ********************************************************          identification division. program-id. subcranial. data division. linkage section. 01 brain-cell usage binary-long. *> ********************************************************          procedure division using by value brain-cell. move 104 to return-code >>D display >>D    "OC: got " brain-cell " returning " return-code >>D end-display goback. end program subcranial. *> ********************************************************         *> ********************************************************           identification division. program-id. cbrainhelp. environment division. configuration section. repository. function all intrinsic. data division. working-storage section. 01 jars                value "012345678901234567890". 03 flies. 05 fly           pic 9 occurs 21 times. linkage section. 01 brain-cell usage binary-long. *> ********************************************************          procedure division using by value brain-cell. evaluate brain-cell when 104 display "10-4 back expect 10-2" end-display display "cbrain 10 code special helps are:" end-display display "   10-4  : ok, help help" end-display display "   10-28 : identify station" end-display display "   10-34 : send help" end-display display "   10-36 : correct time is ..." end-display display "   10-94 : request for long count, frogsort and quit" end-display display "   other : cbrain help" end-display move 102 to return-code goback when 1028 display "10-28 received, cbrain v0.42, Apr 2013, expect 10-4" end-display display "Daniel B Cristofani posted pbrain.c, modified for cbrain by Brian Tiffin" end-display display "Tectonics:" &x"0a" "   cobc -x cbrainmain.c subcranial.cob -lreadline -g -debug -fdebugging-line" end-display display "   cobc -x cbrainrun.cob subcranial.cob cbrain.c -lreadline" end-display move 104 to return-code goback when 1034 display "10-4 good buddy" end-display display "CB 10-codes: " end-display display "---" end-display display "10-1 receiving poorly " end-display display "10-2 receiving well " end-display display "10-3 stop transmitting" end-display display "10-4 OK, got message" end-display display "10-5 relay message" end-display display "10-6 busy, please stand by" end-display display "10-7 out of service, and off air" end-display display "10-8 in service, ready" end-display display "10-9 please repeat" end-display display "10-10 completed and standing by" end-display display "10-11 talking too fast" end-display display "10-12 visitors present" end-display display "10-13 how's the weather and road?" end-display display "10-16 pick up at ..." end-display display "10-17 urgent" end-display display "10-18 do you have anything?" end-display display "10-19 nothing for you, come on in" end-display display "10-20 location is ..." end-display display "10-21 call by phone" end-display display "10-22 come on in and see ..." end-display display "10-23 please stand by" end-display display "10-24 last assignment complete" end-display display "10-25 can you contact ..." end-display display "10-26 disregard last" end-display display "10-27 moving to channel ..." end-display display "10-28 identify yourself" end-display display "10-29 time's up" end-display display "10-30 radio use not conforming to rules" end-display display "10-32 will give radio check" end-display display "10-33 emergency traffic on channel" end-display display "10-34 trouble, help requested" end-display display "10-35 confidential" end-display display "10-36 correct time is ..." end-display display "10-37 tow requested at ..." end-display display "10-38 ambulance requested at ..." end-display display "10-39 message delivered" end-display display "10-41 go to channel" end-display display "10-42 traffic accident at ..." end-display display "10-43 traffic congestion at ..." end-display display "10-44 message for you " end-display display "10-45 all units please report" end-display display "10-50 break channel" end-display display "10-60 what is next message number?" end-display display "10-62 unable to hear, use alternate" end-display display "10-63 net redirect to ..." end-display display "10-64 net clear" end-display display "10-65 awaiting next message" end-display display "10-67 all units follow" end-display display "10-70 fire reported at ..." end-display display "10-71 proceed in sequence " end-display display "10-77 negative contact" end-display display "10-81 are you drunk?" end-display display "10-82 need room for ..." end-display display "10-84 telephone number is ..." end-display display "10-85 address is ..." end-display display "10-91 closer to the mike please" end-display display "10-93 hows my frequency on this channel?" end-display display "10-94 can I get a long count?" end-display display "10-99 mission complete" end-display display "10-100 rest stop" end-display display "10-200 police needed at ..." end-display display "" x"0a" end-display move 102 to return-code goback when 1036 display locale-date(current-date(1:8)) " " locale-time(current-date(9:6)) end-display move 104 to return-code goback when 1094 call "frogsort" using flies end-call when other display "cbrainhelp received " brain-cell " and will return 10-4 on successful completion." end-display end-evaluate display x"0a" & "===From bf===" end-display display "+, increment current cell" end-display display "-, decrement current cell" end-display display ">, advance data cell index up 1" end-display display "<, retreat data cell index down 1" end-display display "[, if current cell zero, scan source index forward to next ]" end-display display "], if current cell non-zero, scan source index backwards to previous [" end-display display "., output current cell" end-display display ",, accept key value to current cell" end-display display x"0a" & "===From pbrain===" end-display display "(, define procedure using current cell value as label" end-display          display "), end procedure definition" end-display display ":, evalute labelled procedure using current cell value" end-display display x"0a" & "===cbrain adds===" end-display display "digits, 0 though 9, if last operation was digit, scale current cell up by 10, otherwise zero out and add in digit" end-display display "{, scan through source text to position past next balanced end brace }" end-display display "*, multiply current value by 10" end-display display "/, integer divide current value by 10" end-display display "a, add current cell into previous cell and retreat" end-display display "s, subtract current cell from previous cell and retreat" end-display display "m, multiply current cell by previous cell into previous cell and retreat" end-display display "d, divide previous cell by current cell leaving quotient in previous and remainder in current, no retreat" end-display display "^, bitwise xor current cell with previous cell and retreat" end-display display "&, bitwise and current cell with previous cell and retreat" end-display display "|, bitwise or current cell with previous cell and retreat" end-display display "~, bitwise not of current cell into current cell" end-display display "r, right shift previous cell by current cell bits and retreat" end-display display "l, left shift previous cell by current cell bits and retreat" end-display display "%, compute modulus of previous cell by current cell into previous cell and retreat" end-display display "@, fetch current cell value and place in memory register" end-display display "!, store content of memory register in current cell" end-display display "x, exchange current cell with previous" end-display display "o, copy previous cell over to next and advance" end-display display "c, copy current cell to next cell and advance" end-display display "n, output current cell as integer" end-display display "#, output current cell as formatted integer" end-display display "b, output current cell as base 2" end-display display "=, input integer and place value in current cell" end-display display '", scan forward to ", call that COBOL module, passing current and then replacing with RETURN-CODE' end-display display "?, display memory up to current" end-display display "t, toggle step trace" end-display display "g, goback" end-display display "q, quit" end-display display "reserved word 'help'" ', calls "cbrainhelp", the OpenCOBOL module using cbrain quoted string.' end-display display "reserved word 'file ' loads script using rest of source text as filename." end-display move 104 to return-code goback. end program cbrainhelp. *> ********************************************************         *> ********************************************************          *>  frogSort, called for help with 10-94, request for count *> ********************************************************          identification division. program-id. frogsort. data division. working-storage section. 01 opinion         usage binary-long. 01 shared-value    pic 99. 88 fair         value 1. 01 caveman-count   pic x(12) value "[-]+++++++++". 01 spacer          pic x(10) value spaces. linkage section. 01 jars. 05 flies       pic 9 occurs 21 times. *> ********************************************************          procedure division using jars. start-here. move function length(jars) to shared-value display "Grog sort jars. frogSort" end-display display "http://www.smbc-comics.com/?id=2831" end-display .          forkyourself. call "fork" returning opinion end-call if opinion is zero then subtract 1 from shared-value if not fair then go forkyourself. .          call "sleep" using by value flies(shared-value) end-call display "Jar: " function char(shared-value + 65) " reporting " caveman-count(1 : flies(shared-value) + 3) " flies," spacer(1 : 10 - flies(shared-value)) "that would be " flies(shared-value) " to you, futureman." end-display call "wait" using by value 0 end-call stop run returning 107. end program frogsort.

with a run sample of

$ cat Makefile cbrainrun: cbrainrun.cob subcranial.cob cbrain.c           cobc -x cbrainrun.cob subcranial.cob cbrain.c -lreadline -g -debug [cbrain]$ ./cbrainrun 10-12 Welcome to cbrain v0.42 cb: 104 cb: help

10-4 back expect 10-2 cbrain 10 code special helps are: 10-4 : ok, help help 10-28 : identify station 10-34 : send help 10-36 : correct time is ... 10-94 : request for long count, frogsort and quit 10-7 other : cbrain help

cb: help cbrainhelp received +0000000102 and will return 10-4 on successful completion. ===From bf=== +, increment current cell -, decrement current cell >, advance data cell index up 1 <, retreat data cell index down 1 [, if current cell zero, scan source index forward to matching ] ], if current cell non-zero, scan source index backwards to previous [ ., output current cell ,, accept key value to current cell ===From pbrain=== (, define procedure using current cell value as label   ), end procedure definition :, evalute procedure using current cell value as label ===cbrain adds=== {, scan through source text to position past next encountered } digits, 0 though 9, if last operation was digit, scale current cell up by 10, otherwise zero out and add in digit *, multiply current value by 10 /, integer divide current value by 10 a, add current cell into previous cell and retreat s, subtract current cell from previous cell and retreat m, multiply current cell by previous cell into previous cell and retreat d, divide previous cell by current cell leaving quotient in previous and remainder in current, no retreat ^, bitwise xor current cell with previous cell and retreat &, bitwise and current cell with previous cell and retreat |, bitwise or current cell with previous celll and retreat ~, bitwise not of current cell into current cell r, right shift previous cell by current cell bits and retreat l, left shift previous cell by current cell bits and retreat %, compute modulus of previous cell by current cell into previous cell and retreat @, fetch current cell value and place in memory register !, place content of memory register in current cell x, exchange current cell with previous o, copy previous cell over to next and advance c, copy current cell to next cell and advance n, output current cell as integer #, output current cell as formatted integer b, output current cell as base 2 =, input integer and place value in current cell ", scan forward to ", call that COBOL module, passing current and then replacing with RETURN-CODE t, toggle step trace g, goback q, quit reserved word 'help', calls "cbrainhelp", the OpenCOBOL module using cbrain quoted string. reserved word 'file ' loads script using rest of source text as filename.

cb: 1036 cb: help 04/02/2013 07:17:19 AM

cb: 1028 cb: help 10-28 received, cbrain v0.42, May 2013, expect 10-4 Daniel B Cristofani posted pbrain.c, modified for cbrain Tectonics: cobc -x cbrainmain.c subcranial.cob -lreadline -g -debug -fdebugging-line cobc -x cbrainrun.cob subcranial.cob cbrain.c -lreadline

cb: 1094 cb: help Grog sort jars. frogSort http://www.smbc-comics.com/?id=2831 Jar: U reporting [-] flies,         that would be 0 to you, futureman. Jar: K reporting [-] flies,         that would be 0 to you, futureman. Jar: A reporting [-] flies,         that would be 0 to you, futureman. Jar: L reporting [-]+ flies,        that would be 1 to you, futureman. Jar: B reporting [-]+ flies,        that would be 1 to you, futureman. Jar: M reporting [-]++ flies,       that would be 2 to you, futureman. Jar: C reporting [-]++ flies,       that would be 2 to you, futureman. Jar: N reporting [-]+++ flies,      that would be 3 to you, futureman. Jar: D reporting [-]+++ flies,      that would be 3 to you, futureman. Jar: O reporting [-]++++ flies,     that would be 4 to you, futureman. Jar: E reporting [-]++++ flies,     that would be 4 to you, futureman. Jar: P reporting [-]+++++ flies,    that would be 5 to you, futureman. Jar: F reporting [-]+++++ flies,    that would be 5 to you, futureman. Jar: Q reporting [-]++++++ flies,   that would be 6 to you, futureman. Jar: G reporting [-]++++++ flies,   that would be 6 to you, futureman. Jar: R reporting [-]+++++++ flies,  that would be 7 to you, futureman. Jar: H reporting [-]+++++++ flies,  that would be 7 to you, futureman. Jar: S reporting [-]++++++++ flies, that would be 8 to you, futureman. Jar: I reporting [-]++++++++ flies, that would be 8 to you, futureman. Jar: T reporting [-]+++++++++ flies, that would be 9 to you, futureman. Jar: J reporting [-]+++++++++ flies, that would be 9 to you, futureman.

The 10-94 help displays a frog sort of 21 digits, using sleep sort technology.

Criticism
Totally breaks the BF tradition and adds numbers. Comments trip as well.

Implementation
OpenCOBOL and C sources posted to the OpenCOBOL project space on SourceForge at OpenCOBOL discussion on SourceForge

Based on the pbrain implementation. The pbrain page has

A concise interpreter in C is available at http://www.hevanet.com/cristofd/pbrain.c. I have tried to complete the semantics the cleanest way I could.

And yes, Daniel wrote a superb little engine.

External resources

 * Release tarball
 * Files