Return to cin.m CVS log

Up to [Research Unix] / researchv10dc / vol2 / cin

Annotation of researchv10dc/vol2/cin/cin.m, revision 1.1

1.1     ! root        1: |make(rp)
        !             2: 
        !             3: |insert(../monk/monk.mac)
        !             4: 
        !             5: |comment(VOL2HEADER)|set_counter(page 325-1)|set_string(page_headers "'''")|set_string(even_headers "'The C Interpreter: A Tutorial for Cin Version 0.18''\f(NIcin\fP'")|set_string(odd_headers "'\f(NIcin\fP''The C Interpreter: A Tutorial for Cin Version 0.18'")|set_string(even_footers "_\\nP__UNIX Papers_")|set_string(odd_footers "'Research Tenth Edition''\\nP'")
        !             6: 
        !             7: |environment(computeroutput;
        !             8:        verbatim on, file.information, line.spacing 1,
        !             9:        fill off, size -1, space -1, font cw, blank.lines -1,
        !            10:        tab.stops "\w'        'u 2u*\w'        'u 3u*\w'        'u 4u*\w'        'u 5u*\w'        'u 6u*\w'        'u 7u*\w'        'u 8u*\w'        'u 9u*\w'        'u 10u*\w'        'u 11u*\w'        'u";
        !            11: 
        !            12:        tab.stops, blank.lines -1, SPACE)
        !            13: 
        !            14: |author(name "T. J. Kowalski", initials TJK, location MH, department 11229,
        !            15:        extension x2771, room 2C-568)
        !            16: |document(number 11229-880606-07TMS, file_case 25952,
        !            17:        work_program 311401-2199)
        !            18: 
        !            19: |author(name "H. H. Goguen", initials HHG, location MH, department 11229,
        !            20:        extension x2771, room 2C-568)
        !            21: |document(number 11229-880606-07TMS, file_case 25952,
        !            22:        work_program 311401-2199)
        !            23: 
        !            24: |author(name "J. J. Puttress", initials JJP, location MH, department 11229,
        !            25:        extension x7290, room 2C-577)
        !            26: |document(number 11229-880606-07TMS, file_case 25952,
        !            27:        work_program 311401-2199)
        !            28: 
        !            29: |date(June 6, 1988)
        !            30: 
        !            31: |title(The C Interpreter:
        !            32: A Tutorial for Cin Version 0.18)
        !            33: 
        !            34: |begin(abstract)
        !            35: The C interpreter, |i(cin), is the core of an interactive programming environment for
        !            36: the C programming language.
        !            37: We believe that by providing integrated facilities to create,
        !            38: edit,
        !            39: browse,
        !            40: execute,
        !            41: and debug programs,
        !            42: this environment should enhance the productivity
        !            43: of C programmers at |s(AT&T) and improve the quality of their code.
        !            44: Furthermore,
        !            45: we feel that |i(cin) provides an easy-to-use instructional environment.
        !            46: |p
        !            47: This memorandum is a tutorial guide to help users get started.
        !            48: Although it does not cover everything,
        !            49: it provides enough information for most users' daily needs.
        !            50: Topics discussed include
        !            51: creating simple programs,
        !            52: testing individual functions and expressions,
        !            53: inspecting and modifying variables,
        !            54: using program views, and setting breakpoints.
        !            55: |end(abstract)
        !            56: 
        !            57: |titlebox
        !            58: 
        !            59: |style(two_column)
        !            60: 
        !            61: |unnumbered_section(Introduction)
        !            62: 
        !            63: Interactive programming environments are common for |s(LISP),
        !            64: |reference(Teitelman Masinter Interlisp Programming Environment)
        !            65: |reference(Sandewall Programming in an Interactive Environment 1978)
        !            66: |s(PASCAL),
        !            67: |reference(Delisle Menicosy Schwartz Viewing a Programming Environment)
        !            68: |reference(Reiss Graphical Program Development with PECAN)
        !            69: |reference(Brown Sedgewick A System for Algorithm Animation)
        !            70: |s(PL/C),
        !            71: |reference(Archer Conway COPE: A Cooperative Programming Environment)
        !            72: |reference(Teitelbaum Reps The Cornell Program Synthesizer 1981)
        !            73: and Smalltalk.
        !            74: |reference(Goldberg Robson Smalltalk-80: The Language and Its Implementation)
        !            75: |reference(Tesler The Smalltalk Environment)
        !            76: Some work has been done on various pieces of a C program environment, including
        !            77: syntax directed editors,
        !            78: |reference(Horgan Moore Techniques for Improving Language-Based Editors)
        !            79: interpreters,
        !            80: |reference(Saber-C 1988)
        !            81: |reference(Feuer si - An Interpreter for the C Language)
        !            82: |reference(Ostby A C interpreter)
        !            83: debuggers,|reference(Adams Muchnick Dbxtool A Window-Based Symbolic Debugger)
        !            84: |reference(Cargill The Feel of Pi)
        !            85: and browsers.
        !            86: |reference(Steffen Interactive Examination of a C Program with Cscope)
        !            87: |p
        !            88: |i(Cin) is a C interpreter: an interactive program
        !            89: for creating, testing, modifying, and debugging a C program,
        !            90: using directions provided by a user at a terminal.
        !            91: The program can be a single function in a single file,
        !            92: or a large collection of files and functions as in System 75.
        !            93: |reference(System 75: Project Development Environment 1985)
        !            94: |i(Cin) is part of the Integrated C Programming Environment,
        !            95: |cw(cens),
        !            96: currently being developed by Department 11229.
        !            97: It implements correct full C,
        !            98: enables rapid prototyping,
        !            99: permits extensive error checking,
        !           100: facilitates incremental update,
        !           101: manages multiple software views,
        !           102: and
        !           103: provides a programmable command language.
        !           104: |p
        !           105: This tutorial is meant to simplify learning |i(cin).
        !           106: We suggest that you read this document,
        !           107: simultaneously using |i(cin) to follow the examples,
        !           108: then read the manual page in the appendix
        !           109: while continuing to experiment with |i(cin).
        !           110: Furthermore,
        !           111: we strongly recommend completing the exercises.
        !           112: They both reinforce material covered in the text
        !           113: and explore material not thoroughly discussed.
        !           114: |p
        !           115: This is an introduction and a tutorial.
        !           116: For that reason,
        !           117: no attempt is made to cover
        !           118: more than a part of the facilities that |i(cin) offers
        !           119: (although this fraction includes the most useful and frequently needed parts).
        !           120: Explanations of the C language and the |s(UNIX)|sp(registered) system
        !           121: are beyond the scope of this paper.
        !           122: We assume that you know how to log on to a |s(UNIX) system
        !           123: and how to express algorithms in C.
        !           124: Information on both the |s(UNIX) system
        !           125: and C is readily available from a variety of sources.
        !           126: |reference(Kernighan Pike Prentice-Hall)
        !           127: |reference(Kernighan Ritchie Prentice-Hall)
        !           128: 
        !           129: |section(Getting Started)
        !           130: 
        !           131: We'll assume you have logged in to a |s(UNIX) system
        !           132: and have just received the shell prompt, e.g. ``$''.
        !           133: The easiest way to start |i(cin) is to type
        !           134: 
        !           135: |begin(computeroutput)
        !           136: |i($ )cin -i
        !           137: |i(cin>)
        !           138: |end(computeroutput)
        !           139: 
        !           140: You are now ready to go
        !           141: |sp(Em dash) |i(cin) is waiting for your instructions.
        !           142: |i(Cin) shows this by echoing a
        !           143: 
        !           144: |begin(computeroutput)
        !           145: |i(cin>)
        !           146: |end(computeroutput)
        !           147: 
        !           148: to your terminal.
        !           149: Throughout this tutorial, responses from |i(cin) are in |i(italics).
        !           150: |p
        !           151: This section shows how to use the interactive mode of |i(cin),
        !           152: that is, a mode where we can enter and execute programs interactively.
        !           153: Later we'll talk about changing and debugging programs.
        !           154: As our first problem,
        !           155: let's leap the hurdle of creating, compiling, loading, and running
        !           156: a program that prints ``hello, world'' on our terminal.
        !           157: Though this is a painful task when we use the normal editor, compiler,
        !           158: loader, and shell to run the program,
        !           159: it's easy in |i(cin).
        !           160: |p
        !           161: When |i(cin) is started with the |cw(-i) option,
        !           162: it is like working with a blank piece
        !           163: of paper |sp(Em dash) there is no program or data present.
        !           164: They must be supplied by the person using |i(cin).
        !           165: The program,
        !           166: with its data,
        !           167: can be entered interactively
        !           168: or read into |i(cin) from a file.
        !           169: We will start by typing in a program
        !           170: and return shortly to the reading of files.
        !           171: |p
        !           172: First a bit of terminology.
        !           173: In |i(cin) jargon,
        !           174: the program currently worked on is said to be
        !           175: ``kept in the current |cw(view)''.
        !           176: Think of the |cw(view) as a work space,
        !           177: if you like,
        !           178: or simply as the information that you are going to be
        !           179: using.
        !           180: The |cw(view) is like a piece of paper,
        !           181: on which we will write things,
        !           182: then change some of them,
        !           183: and finally file the whole thing away for another day.
        !           184: |p
        !           185: The user tells |i(cin) what to do to the |cw(view)
        !           186: by typing C expressions and declarations.
        !           187: C expressions are executed immediately,
        !           188: while declarations are stored in the |cw(view).
        !           189: When an expression is executed,
        !           190: |i(cin) uses both local and global variables.
        !           191: |p
        !           192: Now we're ready to solve our problem.
        !           193: The easiest way is to write a C expression that calls the |cw(printf)
        !           194: library routine.
        !           195: 
        !           196: |begin(computeroutput)
        !           197: |i(cin>) printf("hello, world|sp(\)n");
        !           198: |i(hello, world
        !           199: cin>)
        !           200: |end(computeroutput)
        !           201: 
        !           202: |p
        !           203: Another way to solve our problem is to write a declaration for a |cw(main) function
        !           204: and call it using a C expression.
        !           205: 
        !           206: |begin(computeroutput)
        !           207: |i(cin>) void main()
        !           208: {
        !           209:   printf("hello, world|sp(\)n");
        !           210: }
        !           211: |i(cin>) main();
        !           212: |i(hello, world
        !           213: cin>)
        !           214: |end(computeroutput)
        !           215: 
        !           216: |p
        !           217: We draw your attention to the |cw(void main) declaration.
        !           218: When you're in |i(cin)'s interactive mode,
        !           219: you need to declare a return type for each function.
        !           220: This allows |i(cin)'s interactive mode
        !           221: to tell the difference between an expression calling |cw(main)
        !           222: and a declaration of |cw(main).
        !           223: Don't panic!
        !           224: You don't have to change all your C programs.
        !           225: This is only true when typing directly to interactive mode.
        !           226: The normal default declaration, |cw(int), still applies when files are read in.
        !           227: We could have designed |i(cin) to work like the
        !           228: C interpreters referenced in the introduction, which require you to
        !           229: type a special character to enter and leave a command mode,
        !           230: but we felt that declaring a return type was more consistent with C syntax.
        !           231: |p
        !           232: You also saw that |i(cin) prompts only for a C expression
        !           233: or a declaration.
        !           234: Thus, there are no prompts for the function body of |cw(main).
        !           235: This silence is preferred by experienced users,
        !           236: but sometimes disturbs beginners.
        !           237: |p
        !           238: Finally finished with our problem, we'd like to return to our shell.
        !           239: Exit |i(cin) by typing
        !           240: 
        !           241: |begin(computeroutput)
        !           242: |i(cin>) cin_quit();
        !           243: |i($)
        !           244: |end(computeroutput)
        !           245: 
        !           246: or by typing the end-of-file character (hold the |s(CTRL) key down
        !           247: and press |cw(d)).
        !           248: 
        !           249: |section(I Seemed To Have Confused It)
        !           250: 
        !           251: If you didn't get a ``hello, world'',
        !           252: then |i(cin) is confused by the directions it got.
        !           253: Let's look at some possible problems that may have occurred
        !           254: and how to correct them.
        !           255: |p
        !           256: One possibility is
        !           257: 
        !           258: |begin(computeroutput)
        !           259: |i($) cin -i
        !           260: |i(cin: not found)
        !           261: |i($)
        !           262: |end(computeroutput)
        !           263: 
        !           264: The C interpreter, |i(cin), is not available on your system in the
        !           265: directories specified by your |s(PATH) shell variable.
        !           266: Please contact your system administrator.
        !           267: If your system has |s(EXPTOOLS),
        !           268: the administrator can get |i(cin) from Alan Hastings.
        !           269: Otherwise,
        !           270: your administrator can ask for |i(cin) by sending mail to |cw(research!frodo),
        !           271: including his/her name,
        !           272: department number,
        !           273: telephone number,
        !           274: location,
        !           275: and room number.
        !           276: |p
        !           277: Another possibility is
        !           278: 
        !           279: |begin(computeroutput)
        !           280: |i($) cin -i
        !           281: |i(cin>) printff("hello, world|sp(\)n");
        !           282: |i(interactive mode: 1: warning: 'printff' undefined
        !           283: breakpoint in function 'cin_system'
        !           284:  at line 1 of file 'interactive mode'
        !           285: cin>)
        !           286: |end(computeroutput)
        !           287: 
        !           288: |cw(printf) was misspelled.
        !           289: Whenever |i(cin) encounters an undefined function or variable,
        !           290: it recursively calls a breakpoint function, |cw(cin_system),
        !           291: which places you in |i(cin)'s interactive mode waiting for input.
        !           292: The simplest corrective action is to return and ignore the problem.
        !           293: We can do this by typing
        !           294: 
        !           295: |begin(computeroutput)
        !           296: |i(cin>) cin_return();
        !           297: |i[interactive mode: 2: warning:
        !           298:  call of undefined function (returning 0L)
        !           299: cin>]
        !           300: |end(computeroutput)
        !           301: 
        !           302: or by typing the end-of-file character.
        !           303: This acts as if you decided to define a function, |cw(printff),
        !           304: that returns a |cw(long) zero.
        !           305: A future release of |i(cin) will allow you to modify the prompt to show
        !           306: the number of recursive calls to |cw(cin_system).
        !           307: Later we'll talk about additional corrective actions and
        !           308: other predefined |cw(cin_) functions and variables.
        !           309: |p
        !           310: Yet another possibility is
        !           311: 
        !           312: |begin(computeroutput)
        !           313: |i($) cin -i
        !           314: |i(cin>) printf("hello, world|sp(\)n")
        !           315: |end(computeroutput)
        !           316: 
        !           317: Neither ``hello, world'', nor the |cw(|i(cin>)) prompt appears.
        !           318: You probably forgot to type the last semicolon (|cw(;)).
        !           319: Even experienced users forget the terminating semicolon (|cw(;))
        !           320: sometimes.
        !           321: If |i(cin) seems to be ignoring you,
        !           322: 
        !           323: |begin(computeroutput)
        !           324: |i($) cin -i
        !           325: |i(cin>) printf("hello, world|sp(\)n);
        !           326: |i(interactive mode: 1: newline in string)
        !           327: |end(computeroutput)
        !           328: 
        !           329: type an extra line with just a semicolon (|cw(;)) on it,
        !           330: or in some rare cases
        !           331: 
        !           332: |begin(computeroutput)
        !           333: |i($) cin -i
        !           334: |i(cin>) void main()
        !           335: {
        !           336:        printf("hello, world|sp(\)n);
        !           337: }
        !           338: |i(interactive mode: 3: newline in string
        !           339: interactive mode: 4: syntax error
        !           340:  in parameter list of function call)
        !           341: |end(computeroutput)
        !           342: 
        !           343: an extra line with just a semicolon (|cw(;))
        !           344: followed by an extra line with just a closing curly brace (|cw(})) on it.
        !           345: Isn't error recovery wonderful!
        !           346: The next release of |i(cin) will be more friendlier.
        !           347: |p
        !           348: Throughout the rest of the tutorial,
        !           349: we will assume that our typing is perfect.
        !           350: We use the |cw(samuel)|reference(Puttress 1986 browser)
        !           351: editor to remember C statements and declarations in a scratch pad,
        !           352: sending them to |i(cin) whenever we are happy with the syntax.
        !           353: However, you can also remember and send
        !           354: C statements and declarations with |cw(sam), |cw(jim), |cw(emacs), or |cw(inedit).
        !           355: 
        !           356: |subsection(Exercise 1)
        !           357: 
        !           358: Enter |i(cin) and use the formula |e<degree~ F ~=~ ( 9 / 5 ) ~*~ degree~ C ~+~ 32>
        !           359: to create a conversion table from centigrade or Celsius temperatures to Fahrenheit
        !           360: for 20|sp(degree) C to 30|sp(degree) C.
        !           361: Do this exercise in two different ways:
        !           362: |begin(number_list)
        !           363: |item Write a C expression that calls the |cw(printf) library routine.
        !           364: |item Declare a |cw(main) function and run it in |i(cin).
        !           365: |end(number_list)
        !           366: 
        !           367: |section(Writing A Small Program)
        !           368: 
        !           369: Our next problem is to write a few routines to
        !           370: print algebraic expression trees.
        !           371: Let's start by declaring the template |cw(node) for our tree.
        !           372: 
        !           373: |begin(computeroutput)
        !           374: |i(cin>) struct node {
        !           375:   struct node *left;
        !           376:   struct node *right;
        !           377:   char *value;
        !           378:   int type;
        !           379: };
        !           380: |i(cin>)
        !           381: |end(computeroutput)
        !           382: 
        !           383: |p
        !           384: The |cw(left) and |cw(right) fields are pointers to other |cw(node)s.
        !           385: The |cw(value) field holds a character string representing
        !           386: the operator, variable, or constant associated with the node.
        !           387: The |cw(type) field shows the kind of operator,
        !           388: variable, or constant held in |cw(value) field.
        !           389: The allowable types are:
        !           390: 
        !           391: |begin(computeroutput)
        !           392: |i(cin>) #define       ADD     1
        !           393: #define        SUB     2
        !           394: #define        MUL     3
        !           395: #define        DIV     4
        !           396: #define        EXPT    5
        !           397: #define        UMINUS  6
        !           398: #define        CONST   7
        !           399: #define        VAR     8
        !           400: |end(computeroutput)
        !           401: 
        !           402: |p
        !           403: We'd like to pause and talk about prompts once again.
        !           404: You're probably puzzled why there was only one |i(cin>) for the above set
        !           405: of pre-processor statements.
        !           406: Well,
        !           407: in the 0.18 release |i(cin) prompts only for a C expression
        !           408: or a declaration, and C pre-processor statements are a little different.
        !           409: We think this is a botch and will change it in the next release,
        !           410: but until then it's a feature.|dagnote(Features are
        !           411: bugs that are not yet fixed.)
        !           412: |p
        !           413: Now that we have a data structure,
        !           414: let's write a |cw(prt) routine to display the tree
        !           415: in the format normally used for an equation.
        !           416: This requires an in-order walk; in other words |sp(Em dash)
        !           417: go left as far as you can,
        !           418: print the node,
        !           419: then go right as far as you can.
        !           420: 
        !           421: |begin(computeroutput)
        !           422: |i(cin>) void
        !           423: prt(n)
        !           424: struct node *n;
        !           425: {
        !           426:   switch(n->type) {
        !           427: 
        !           428:   default:
        !           429:     prt(n->left);
        !           430:     printf("%s ", n->value);
        !           431:     prt(n->right);
        !           432:     break;
        !           433: 
        !           434:   case UMINUS:
        !           435:     printf("%s ", n->value);
        !           436:     prt(n->right);
        !           437:     break;
        !           438: 
        !           439:   case CONST:
        !           440:   case VAR:
        !           441:     printf("%s ", n->value);
        !           442:     break;
        !           443: 
        !           444:   }
        !           445: }
        !           446: |i(cin>)
        !           447: |end(computeroutput)
        !           448: 
        !           449: |p
        !           450: A powerful feature of |i(cin) enables a routine
        !           451: to be tested as soon it is written.
        !           452: This way you can make sure it does what you want
        !           453: before incorporating it into a large program.
        !           454: |i(Cin) also takes care of allocating and deallocating
        !           455: data structures for testing.
        !           456: |p
        !           457: Let's test the |cw(prt) function.
        !           458: First we'll include the standard I/O header file
        !           459: so we can turn off output buffering.
        !           460: 
        !           461: |begin(computeroutput)
        !           462: |i(cin>) #include <stdio.h>
        !           463: |i(cin>) setbuf(stdout, NULL);
        !           464: |i(cin>) setbuf(stderr, NULL);
        !           465: |i(cin>)
        !           466: |end(computeroutput)
        !           467: 
        !           468: Next we let |i(cin) allocate storage space for a sample node,
        !           469: |cw(a1),
        !           470: and set it to hold a constant, |cw(CONST), with a value of |cw(17).
        !           471: Finally,
        !           472: we call |cw(prt) and see it print |cw(17).
        !           473: 
        !           474: |begin(computeroutput)
        !           475: |i(cin>) struct node a1;
        !           476: |i(cin>) a1.type = CONST;
        !           477: |i(cin>) a1.value = "17";
        !           478: |i(cin>) prt(&a1);
        !           479: |i(17 cin>)
        !           480: |end(computeroutput)
        !           481: 
        !           482: For constants,
        !           483: |cw(left) and |cw(right) are unused.
        !           484: |p
        !           485: It's likely that we'll want to save our work for later use.
        !           486: A simple and easy way to do this
        !           487: is to save an image of our program and data definitions as an executable file.
        !           488: Let's do this by calling the predefined function |cw(cin_dump)
        !           489: with the name of a file, |cw(./saved).
        !           490: 
        !           491: |begin(computeroutput)
        !           492: |i(cin>) cin_dump("./saved");
        !           493: |i(cin>) cin_quit();
        !           494: |i($)
        !           495: |end(computeroutput)
        !           496: 
        !           497: Any time afterwards we can invoke our saved executable and use the program
        !           498: and data definitions we have just entered.
        !           499: 
        !           500: |begin(computeroutput)
        !           501: |i($) ./saved
        !           502: |i(cin>) prt(&a1);
        !           503: |i(17 cin>)
        !           504: |end(computeroutput)
        !           505: 
        !           506: This feature is useful for customizing our |i(cin) environment,
        !           507: but in the 0.18 release of |i(cin) there is no way to print out
        !           508: the definition of a given function.
        !           509: We plan to enhance |i(cin) to do this in the future,
        !           510: but for now we recommend using an editor to keep your functions
        !           511: in files.
        !           512: |p
        !           513: Thus, we need to learn how to
        !           514: load source or object files into |i(cin).
        !           515: We'll assume you've returned to your shell,
        !           516: placed the definition for |cw(node)
        !           517: and its |cw(#define)s in |cw(node.h),
        !           518: and placed |cw(#include "node.h")
        !           519: along with the definition for |cw(prt) in |cw(prt.c).
        !           520: |p
        !           521: Now let's go back to |i(cin) and load in the |cw(prt) function.
        !           522: 
        !           523: |begin(computeroutput)
        !           524: |i($) cin -i
        !           525: |i(cin>) cin_load("prt.c");
        !           526: |i(cin>)
        !           527: |end(computeroutput)
        !           528: 
        !           529: |p
        !           530: When |i(cin) loaded |cw(prt.c), it placed
        !           531: the structure definition for |cw(node),
        !           532: the |cw(#define)s,
        !           533: and the definition for |cw(prt)
        !           534: in a |cw(view) called |cw(prt.c).
        !           535: A |cw(view) is the internal representation of a C source file |sp(Em dash)
        !           536: |cw(#define)s, static variables and functions, and global declarations.
        !           537: Outside |i(cin), the functions and data of a C program are packaged in a file;
        !           538: inside |i(cin) they are contained in a |cw(view).
        !           539: Earlier, when we typed declarations directly into the interpreter,
        !           540: they were placed into a default |cw(view) called ``interactive mode''.
        !           541: To use the declarations,
        !           542: we need to be in the |cw(view) where they are stored.
        !           543: So if we are sure we defined something, but |i(cin) can't find it,
        !           544: we have probably gotten into the wrong |cw(view).
        !           545: We can see what |cw(view)s are available by using the predefined function
        !           546: |cw(cin_views), and we can change our |cw(view) by using |cw(cin_view).
        !           547: 
        !           548: |begin(computeroutput)
        !           549: |i(cin>) cin_views();
        !           550: |i(   prt.c
        !           551:  |sp(*) interactive mode
        !           552: cin>) cin_view("prt.c");
        !           553: |i(cin>) cin_views();
        !           554: |i( |sp(*) prt.c
        !           555:    interactive mode
        !           556: cin>)
        !           557: |end(computeroutput)
        !           558: 
        !           559: |p
        !           560: We have just seen that |cw(cin_views) marks our current |cw(view)
        !           561: with an asterisk (|cw(*)).
        !           562: Do not confuse the ``interactive mode'' session,
        !           563: which is entered by typing |cw(cin -i),
        !           564: with the default interactive mode |cw(view).
        !           565: In interactive mode,
        !           566: you may access any |cw(view)
        !           567: and enter C expressions or declarations in the context of that |cw(view).
        !           568: The interactive mode |cw(view) is simply the default |cw(view),
        !           569: used for storing C declarations not associated with an external file.
        !           570: |p
        !           571: Let's use the declaration of |cw(struct node)
        !           572: and the |cw(#define) for |cw(CONST) in the current or |cw(prt.c) |cw(view)
        !           573: to initialize a |cw(struct node a1).
        !           574: 
        !           575: |begin(computeroutput)
        !           576: |i(cin>) struct node a1;
        !           577: |i(cin>) a1.type = CONST;
        !           578: |i(cin>) a1.value = "17";
        !           579: |i(cin>)
        !           580: |end(computeroutput)
        !           581: 
        !           582: |p
        !           583: Although we said our typing would be prefect,|dagnote(as you can see it's not)
        !           584: let's see what happens if we make the common mistake of passing
        !           585: a structure instead of a pointer to the structure.
        !           586: 
        !           587: |begin(computeroutput)
        !           588: |i(cin>) prt(a1);
        !           589: |i(prt.c: 7: null pointer access
        !           590: breakpoint in function 'prt' at line 7 of file 'prt.c'
        !           591: cin>)
        !           592: |end(computeroutput)
        !           593: 
        !           594: |p
        !           595: At this point we can escape to our shell and print a numbered listing
        !           596: of |cw(prt.c).
        !           597: 
        !           598: |begin(computeroutput)
        !           599: |i(cin>) system("pr -n -t prt.c");
        !           600: |i[ 1  #include "node.h"
        !           601:  2
        !           602:  3     void
        !           603:  4     prt(n)
        !           604:  5     struct node |sp(*)n;
        !           605:  6     {
        !           606:  7       switch(n|cw(->)type) {
        !           607:  8
        !           608:  9       default:
        !           609: 10         prt(n|cw(->)left);
        !           610: 11         printf("%s ", n|cw(->)value);
        !           611: 12         prt(n|cw(->)right);
        !           612: 13         break;
        !           613: 14
        !           614: 15       case UMINUS:
        !           615: 16         printf("%s ", n|cw(->)value);
        !           616: 17         prt(n|cw(->)right);
        !           617: 18         break;
        !           618: 19
        !           619: 20       case CONST:
        !           620: 21       case VAR:
        !           621: 22         printf("%s ", n|cw(->)value);
        !           622: 23         break;
        !           623: 24
        !           624: 25       }
        !           625: 26     }
        !           626: cin>]
        !           627: |end(computeroutput)
        !           628: 
        !           629: |p
        !           630: By a quick process of elimination,
        !           631: we realize that
        !           632: |cw(n) must be our problem,
        !           633: because line 7 only has one pointer variable.
        !           634: When you are in a |i(cin) breakpoint function,
        !           635: |i(cin) computes the value of expressions in the current execution context
        !           636: |sp(Em dash) an expression is evaluated just as though
        !           637: it were placed in the program source at the current point of execution.
        !           638: Thus, we can check to see if |cw(n) is zero by printing its value.
        !           639: 
        !           640: |begin(computeroutput)
        !           641: |i(cin>) printf("%d|sp(\)n", n);
        !           642: |i(0)
        !           643: |i(cin>)
        !           644: |end(computeroutput)
        !           645: 
        !           646: |p
        !           647: If we failed to notice our ``passing
        !           648: a structure instead of a pointer to the structure'' typo,
        !           649: we might think that |cw(prt) got into trouble because it called itself.
        !           650: We can check this by using the predefined function |cw(cin_where).
        !           651: 
        !           652: |begin(computeroutput)
        !           653: |i(cin>) cin_where();
        !           654: |i{cin_system()   [prt.c:1]
        !           655: prt(n = 0x0)   [prt.c:7]
        !           656: cin_system()   [interactive mode:32]
        !           657: cin>}
        !           658: |end(computeroutput)
        !           659: 
        !           660: This tells us that we are currently in |i(cin)'s breakpoint function,
        !           661: |cw(cin_system),
        !           662: looking at a call of |cw(prt) that was made from
        !           663: interactive mode.
        !           664: Because there are not two calls to |cw(prt),
        !           665: we are assured it didn't recursively call itself.
        !           666: |p
        !           667: As you can see from the reference to line number 32,
        !           668: the authors need to struggle further with what line numbers should mean in
        !           669: interactive mode.
        !           670: In particular, |cw(cin_where) and |cw(cin_break),
        !           671: discussed later,
        !           672: don't seem to use sensible line numbers for functions defined in interactive mode.
        !           673: |p
        !           674: Let's fix the problem with |cw(n) by modifying its value to be
        !           675: |cw(&a1) and allowing the program to continue.
        !           676: 
        !           677: |begin(computeroutput)
        !           678: |i(cin>) n = &a1;
        !           679: |i(cin>) cin_return();
        !           680: |i(17 cin>)
        !           681: |end(computeroutput)
        !           682: 
        !           683: Most debuggers don't permit you to continue after a serious error.
        !           684: Whenever possible,
        !           685: |i(cin) allows you to recover from an error
        !           686: once you've taken corrective action.
        !           687: If we don't want to take corrective action,
        !           688: we can remove all calls of |i(cin)'s breakpoint function by calling |cw(exit).
        !           689: 
        !           690: |begin(computeroutput)
        !           691: |i(cin>) exit(0);
        !           692: |i(cin>)
        !           693: |end(computeroutput)
        !           694: 
        !           695: Sometimes there is no way to fix the problem
        !           696: and all we can do is |cw(cin_quit).
        !           697: |p
        !           698: Now let's define a function that creates a node,
        !           699: placing the function in |cw(create.c).
        !           700: We can enter our favorite editor by
        !           701: 
        !           702: |begin(computeroutput)
        !           703: |i(cin>) system("${EDITOR-/bin/ed} foo.c");
        !           704: |i(?foo.c)
        !           705: |end(computeroutput)
        !           706: 
        !           707: and printing out our file
        !           708: 
        !           709: |begin(computeroutput)
        !           710: |i(cin>) system("pr -n -t create.c");
        !           711: |i[ 1  #include <stdio.h>
        !           712:  2     #include "node.h"
        !           713:  3
        !           714:  4     struct node |sp(*)
        !           715:  5     create(left, right, type, value)
        !           716:  6     struct node |sp(*)left, |sp(*)right;
        !           717:  7     char |sp(*)value;
        !           718:  8     {
        !           719:  9       struct node |sp(*)n;
        !           720: 10       struct node |sp(*)memory();
        !           721: 11
        !           722: 12       if (n = memory(
        !           723: 13        sizeof(struct node))) {
        !           724: 14         n|cw(->)left = left;
        !           725: 15         n|cw(->)right = right;
        !           726: 16         n|cw(->)type = type;
        !           727: 17         n|cw(->)value = value;
        !           728: 18         return(n);
        !           729: 19       }
        !           730: 20
        !           731: 21       fprintf(stderr,
        !           732: 22        "No memory to create a node|sp(\)n");
        !           733: 23       exit(1);
        !           734: 24     }
        !           735: cin>] cin_load("create.c");
        !           736: |i[create.c: 8: warning: function 'create'
        !           737: has implicit return and 'return e;' (line 18)
        !           738: cin>]
        !           739: |end(computeroutput)
        !           740: 
        !           741: |p
        !           742: The error message warns us that the function |cw(create),
        !           743: which is declared starting on line 8,
        !           744: ends without returning a value.
        !           745: This is fine, because the function |cw(exit)
        !           746: would never let us get to the end of the routine.
        !           747: |p
        !           748: Now let's change our |cw(view) to the |cw(create.c) declarations,
        !           749: make a few nodes, and print the expression tree
        !           750: for |cw[2 * (17 - x)].
        !           751: We can represent the expression tree graphically as
        !           752: 
        !           753: |begin(here)
        !           754: |begin(picture)
        !           755: scale=100
        !           756: box invis ht 96 wid 144 with .sw at 0,0
        !           757: "\fR\s10\&|sp(-) (t1)\f1\s0" at 122,42
        !           758: "\fR\s10\&x (t3)\f1\s0" at 160,-10
        !           759: "\fR\s10\&17 (t2)\f1\s0" at 80,-10
        !           760: line from 104,40 to 144,0
        !           761: line from 104,40 to 64,0
        !           762: "\fR\s10\&2 (t5)\f1\s0" at 24,26
        !           763: "\fR\s10\&|sp(*) (t4)\f1\s0" at 80,86
        !           764: line from 64,80 to 104,40
        !           765: line from 64,80 to 24,40
        !           766: |end(picture)
        !           767: |end(here)
        !           768: 
        !           769: where the labels in parentheses are the variable names for the |cw(struct node)
        !           770: pointers
        !           771: and the other symbols are the |cw(value)s for the |cw(node)s.
        !           772: 
        !           773: |begin(computeroutput)
        !           774: |i(cin>) cin_view("create.c");
        !           775: |i(cin>) struct node *t1, *t2, *t3;
        !           776: |i(cin>) t3 = create((struct node *)0,
        !           777: (struct node *)0, VAR, "x");
        !           778: |i(create.c: 12: warning: 'memory' undefined
        !           779: breakpoint in function 'create'
        !           780: at line 12 of file 'create.c'
        !           781: cin>)
        !           782: |end(computeroutput)
        !           783: 
        !           784: |p
        !           785: A common programming practice is to leave ``stubs'',
        !           786: or functions to be defined at a later date.
        !           787: |i(Cin) will stop when it encounters functions or variables that are not defined,
        !           788: permitting you to define them.
        !           789: Here |i(cin) has stopped because it can't find a definition for |cw(memory).
        !           790: 
        !           791: |begin(computeroutput)
        !           792: |i(cin>) struct node *
        !           793: memory(n)
        !           794: unsigned n;
        !           795: {
        !           796:   struct node *malloc();
        !           797:   return malloc(n);
        !           798: }
        !           799: |i(cin>) cin_return();
        !           800: |i(cin>) t2 = create((struct node *)0,
        !           801: (struct node *)0, CONST, "17");
        !           802: |i(cin>) t1 = create(t2, t3, ADD, "+");
        !           803: |i(cin>) struct node *t4, *t5;
        !           804: |i(cin>) t5 = create((struct node *)0,
        !           805: (struct node *)0, CONST, "2");
        !           806: |i(cin>) t4 = create(t5, t1, MUL, "*");
        !           807: |i(cin>) prt(t4);
        !           808: |i(2 |sp(*) 17 + x cin>)
        !           809: |end(computeroutput)
        !           810: 
        !           811: We'd like to emphasize that declarations can be mixed
        !           812: with C expressions in interactive mode.
        !           813: 
        !           814: |subsection(Exercise 2)
        !           815: 
        !           816: Use |i(cin) and your favorite editor to enhance the |cw(prt) function
        !           817: by adding parentheses to the output that show the nesting levels;
        !           818: e.g., |cw<prt(t4)> should output |cw<( 2 * ( 17 + x ) )>.
        !           819: 
        !           820: |section(Debugging With Breakpoints)
        !           821: 
        !           822: We've already seen that any legal C expression can be used
        !           823: when |i(cin) enters the breakpoint function,
        !           824: but we haven't seen how to force |i(cin)
        !           825: to enter a breakpoint function.
        !           826: The easiest way is to use your editor and insert calls to the
        !           827: predefined function |cw(cin_system) into your program.
        !           828: 
        !           829: |begin(computeroutput)
        !           830: 1      hello()
        !           831: 2      {
        !           832: 3        int i;
        !           833: 4        i = 17;
        !           834: 5        printf("hello, %d", i);
        !           835: 6        cin_system();
        !           836: 7        printf("world %d times|sp(\)n", i);
        !           837: 8      }
        !           838: |end(computeroutput)
        !           839: 
        !           840: |p
        !           841: So if we were to load in |cw(hello.c) and run it:
        !           842: 
        !           843: |begin(computeroutput)
        !           844: cin> |i($) cin -i
        !           845: |i(cin>) cin_load("hello.c");
        !           846: |i(cin>) hello();
        !           847: |i(breakpoint in function 'hello' at line 6 of file 'hello.c'
        !           848: hello, 17cin>) i = 3;
        !           849: |i(cin>) cin_return();
        !           850: |i(world 3 times
        !           851: cin>)
        !           852: |end(computeroutput)
        !           853: 
        !           854: We'd be able to change the value of |cw(i),
        !           855: or anything else, for that matter,
        !           856: to whatever we want.
        !           857: This is like placing |cw(printf)'s in our code that allow us
        !           858: to print or modify anything.
        !           859: |p
        !           860: We can obtain a less permanent breakpoint using the predefined function
        !           861: |cw(cin_break), and remove it using |cw(cin_unbreak).
        !           862: Let's return to the original |cw(prt) routine contained in |cw(prt.c),
        !           863: assert a breakpoint on line 7,
        !           864: and run it with |cw(t4).
        !           865: Because we've already debugged |cw(create) and |cw(memory),
        !           866: we can use the C compiler to create object files for them,
        !           867: continuing to debug |cw(prt) in source form.
        !           868: By mixing object files with source files, we get the speed of compiled code
        !           869: for functions that are debugged,
        !           870: combined with the error checking of interpreted code
        !           871: for functions we are testing.
        !           872: 
        !           873: |begin(computeroutput)
        !           874: |i($) cc -O -c create.c memory.c
        !           875: |i(create.c:
        !           876: memory.c:
        !           877: $) cin -i prt.c create.o memory.o
        !           878: |i(cin>) cin_view("prt.c");
        !           879: |i(cin>) struct node *t1, *t2, *t3;
        !           880: |i(cin>) struct node *create();
        !           881: |i(cin>) #include <stdio.h>
        !           882: |i(cin>) t3 = create((struct node *)0,
        !           883: (struct node *)0, VAR, "x");
        !           884: |i(cin>) t2 = create((struct node *)0,
        !           885: (struct node *)0, CONST, "17");
        !           886: |i(cin>) t1 = create(t2, t3, ADD, "+");
        !           887: |i(cin>) struct node *t4, *t5;
        !           888: |i(cin>) t5 = create((struct node *)0,
        !           889: (struct node *)0, CONST, "2");
        !           890: |i(cin>) t4 = create(t5, t1, MUL, "*");
        !           891: |i(cin>)
        !           892: |end(computeroutput)
        !           893: 
        !           894: |p
        !           895: |cw(Cin_break) and |cw(cin_unbreak) both require us to be in the
        !           896: |cw(view) where the function is defined and restrict us to functions
        !           897: that are being interpreted.
        !           898: We plan to enhance |i(cin) to remove these restrictions in the future.
        !           899: 
        !           900: |begin(computeroutput)
        !           901: |i(cin>) cin_break("prt", 7);
        !           902: |i(breakpoint in function prt at line 7
        !           903: cin>) prt(t4);
        !           904: |i(breakpoint in function 'prt' at line 7 of file 'prt.c'
        !           905: cin>) cin_return();
        !           906: |i(breakpoint in function 'prt' at line 7 of file 'prt.c'
        !           907: cin>) cin_return();
        !           908: |i(breakpoint in function 'prt' at line 7 of file 'prt.c'
        !           909: 2 |sp(*) cin>) cin_where();
        !           910: |i{cin_system()   [prt.c:1]
        !           911: prt(n = 0x9382C)   [prt.c:7]
        !           912: prt(n = 0x93854)   [prt.c:12]
        !           913: cin_system()   [stdio.h:50]
        !           914: cin>} cin_unbreak("prt", 7);
        !           915: |i(breakpoint removed from line 7 in prt
        !           916: cin>) cin_return();
        !           917: |i(17 + x cin>) cin_quit();
        !           918: |i($)
        !           919: |end(computeroutput)
        !           920: 
        !           921: We plan to enhance |i(cin) by adding another argument to |cw(cin_break).
        !           922: This argument will be a string that is executed when the breakpoint function
        !           923: is entered.
        !           924: This will let us set breakpoints that remove themselves,
        !           925: print interesting things,
        !           926: or even set other breakpoints.
        !           927: 
        !           928: |section(Program Equals Data)
        !           929: 
        !           930: A common trick of interpreters,
        !           931: especially in the |s(LISP) world,
        !           932: is to use the same representation for data handled by a program
        !           933: and the program text itself.
        !           934: |p
        !           935: As our last programming task in this tutorial,
        !           936: let's write a simple desk calculator.
        !           937: To accomplish this,
        !           938: we need to read a string from the user,
        !           939: wrap it in a |cw(printf) C expression,
        !           940: and pass it to the predefined function |cw(cin_eval).
        !           941: 
        !           942: |begin(computeroutput)
        !           943: |i($) cin -i -lm
        !           944: |i(cin>) #include <stdio.h>
        !           945: |i(cin>) #include <math.h>
        !           946: |i(cin>) char buf[1024], buf2[1024];
        !           947: |i(cin>) while(gets(buf) != NULL) {
        !           948:   sprintf(buf2,
        !           949:    "printf(|sp(\)"%%g|sp(\)|sp(\)n|sp(\)",(double)(%s));",
        !           950:    buf);
        !           951:   cin_eval(buf2);
        !           952: }
        !           953: sqrt(2.0) * sqrt(2.0)
        !           954: |i(2)
        !           955: |end(computeroutput)
        !           956: 
        !           957: In writing the |cw(printf) expression shown above,
        !           958: the trickiest part was ensuring that the argument would be appropriate
        !           959: to the |cw(g) format.
        !           960: That's what the |cw<(double)> accomplished.
        !           961: This example is also plagued with getting the right number of
        !           962: |sp(\)s and |cw(%)s.
        !           963: 
        !           964: |subsection(Exercise 3)
        !           965: 
        !           966: Enhance the desk calculator C expression to remember the
        !           967: last value as |cw(t)
        !           968: and make it into a shell file that can be easily executed.
        !           969: 
        !           970: |section(Bugs)
        !           971: 
        !           972: |center(You find 'em.
        !           973: We squash 'em!)
        !           974: |p
        !           975: The interactive mode is new with the 0.18 release of |i(cin).
        !           976: It's hard to anticipate all the errors you may encounter,
        !           977: and because of this we need your help to improve our tool.
        !           978: Thus, we welcome bug reports sent to research!frodo.
        !           979: Please include a short program along with the terminal input and
        !           980: output that creates the |i(cin) problem.
        !           981: 
        !           982: |section(Summary Of Predefined Functions)
        !           983: 
        !           984: Several pre-defined functions are provided for the user,
        !           985: where |i(name), |i(string), |i(file), |i(line), |i(func), |i(func_mod),
        !           986: and |i(func_ref) are declared as:
        !           987: 
        !           988: |begin(computeroutput)
        !           989: char *|i(name), *|i(string), *|i(file);
        !           990: int |i(line);
        !           991: long (*|i(func))(), (*|i(func_mod))(), (*|i(func_ref))();
        !           992: |end(computeroutput)
        !           993: 
        !           994: |blank_space(-1)
        !           995: |begin(computeroutput)
        !           996: void cin_bind(|i(name), |i(func))
        !           997: |end(computeroutput)
        !           998: |blank_space(-1)
        !           999: Set an alias of |i(name) for the function |i(func).
        !          1000: 
        !          1001: |begin(computeroutput)
        !          1002: int cin_break(|i(name), |i(line))
        !          1003: |end(computeroutput)
        !          1004: |blank_space(-1)
        !          1005: Set a breakpoint in function |i(name) at line number |i(line) in the current
        !          1006: |cw(view).
        !          1007: Returns 0 if breakpoint cannot be set.
        !          1008: 
        !          1009: |begin(computeroutput)
        !          1010: int cin_dump(|i(name))
        !          1011: |end(computeroutput)
        !          1012: |blank_space(-1)
        !          1013: Create an |cw(a.out) and place it in the file |i(name).
        !          1014: Returns 0 if |i(name) cannot be created.
        !          1015: 
        !          1016: |begin(computeroutput)
        !          1017: int cin_eval(|i(string))
        !          1018: |end(computeroutput)
        !          1019: |blank_space(-1)
        !          1020: Execute the C statement |i(string)
        !          1021: as if it were present in the program where the |cw(cin_eval) is located.
        !          1022: Returns 0 if |i(string) could not be parsed.
        !          1023: 
        !          1024: |begin(computeroutput)
        !          1025: int cin_load(|i(file))
        !          1026: |end(computeroutput)
        !          1027: |blank_space(-1)
        !          1028: Load |i(file) into a new |cw(view),
        !          1029: using the standard file-naming conventions for |i(cc)(1).
        !          1030: Returns 0 if |i(file) can not be loaded.
        !          1031: 
        !          1032: |begin(computeroutput)
        !          1033: void cin_return()
        !          1034: |end(computeroutput)
        !          1035: |blank_space(-1)
        !          1036: Return from a breakpoint.
        !          1037: 
        !          1038: |begin(computeroutput)
        !          1039: int cin_spy(|i(name), |i(func_mod), |i(func_ref))
        !          1040: |end(computeroutput)
        !          1041: |blank_space(-1)
        !          1042: Call the function |i(func_mod) whenever the variable |i(name) is modified.
        !          1043: Call the function |i(func_ref) whenever the variable |i(name) is referenced.
        !          1044: Either |i(func_mod) or |i(func_ref) can be |cw<(long (*)())0>.
        !          1045: Returns 0 if there are no spies active.
        !          1046: 
        !          1047: |begin(computeroutput)
        !          1048: void cin_system()
        !          1049: |end(computeroutput)
        !          1050: |blank_space(-1)
        !          1051: Enter ``interactive mode''.
        !          1052: 
        !          1053: |begin(computeroutput)
        !          1054: int cin_unbreak(|i(name), |i(line))
        !          1055: |end(computeroutput)
        !          1056: |blank_space(-1)
        !          1057: Remove a breakpoint in function |i(name) at line number |i(line) in the current
        !          1058: |cw(view).
        !          1059: Returns 0 if the breakpoint was not set.
        !          1060: 
        !          1061: |begin(computeroutput)
        !          1062: int cin_view(|i(name))
        !          1063: |end(computeroutput)
        !          1064: |blank_space(-1)
        !          1065: Change the current |cw(view) to |i(name).
        !          1066: Returns 0 if the |cw(view) was not found.
        !          1067: 
        !          1068: |begin(computeroutput)
        !          1069: void cin_views()
        !          1070: |end(computeroutput)
        !          1071: |blank_space(-1)
        !          1072: Print the available |cw(view)s.
        !          1073: The current |cw(view) is marked with an asterisk (|cw(*)).
        !          1074: 
        !          1075: |begin(computeroutput)
        !          1076: void cin_whatis(|i(name))
        !          1077: |end(computeroutput)
        !          1078: |blank_space(-1)
        !          1079: Print the type of the variable |i(name).
        !          1080: 
        !          1081: |begin(computeroutput)
        !          1082: void cin_where()
        !          1083: |end(computeroutput)
        !          1084: |blank_space(-1)
        !          1085: Print the trace of subroutine calls.
        !          1086: 
        !          1087: |begin(computeroutput)
        !          1088: void cin_quit()
        !          1089: |end(computeroutput)
        !          1090: |blank_space(-1)
        !          1091: Exit |i(cin).
        !          1092: 
        !          1093: |section(Summary Of Predefined Variables)
        !          1094: 
        !          1095: Several predefined variables are provided for the user.
        !          1096: 
        !          1097: |begin(computeroutput)
        !          1098: extern char *cin_libpath
        !          1099: |end(computeroutput)
        !          1100: |blank_space(-1)
        !          1101: A colon (|cw(:)) -separated list of libraries to search for undefined routines
        !          1102: (defaults to libraries specified on the command line and
        !          1103: ``|cw(-lc)'').
        !          1104: 
        !          1105: |begin(computeroutput)
        !          1106: extern char *cin_prompt
        !          1107: |end(computeroutput)
        !          1108: |blank_space(-1)
        !          1109: The ``interactive mode'' prompt (default ``|cw(cin>) '').
        !          1110: 
        !          1111: |section(Answers)
        !          1112: 
        !          1113: |subsection(Answer 1)
        !          1114: 
        !          1115: |blank_space(-1)
        !          1116: |begin(computeroutput)
        !          1117: |i($) cin -i
        !          1118: |i(cin>) int i;
        !          1119: |i(cin>) for (i = 20; i <= 30; ++i)
        !          1120:  printf("%d %g|sp(\)n",
        !          1121:   i, 9. / 5. * i + 32.);
        !          1122: |i(20 68
        !          1123: 21 69.8
        !          1124: 22 71.6
        !          1125: 23 73.4
        !          1126: 24 75.2
        !          1127: 25 77
        !          1128: 26 78.8
        !          1129: 27 80.6
        !          1130: 28 82.4
        !          1131: 29 84.2
        !          1132: 30 86
        !          1133: cin>) void main()
        !          1134: {
        !          1135:   int i;
        !          1136: 
        !          1137:   for (i = 20; i <= 30; ++i)
        !          1138:    printf("%d %g|sp(\)n",
        !          1139:      i, 9. / 5. * i + 32.);
        !          1140: }
        !          1141: |i(cin>) main();
        !          1142: |i(20 68
        !          1143: 21 69.8
        !          1144: 22 71.6
        !          1145: 23 73.4
        !          1146: 24 75.2
        !          1147: 25 77
        !          1148: 26 78.8
        !          1149: 27 80.6
        !          1150: 28 82.4
        !          1151: 29 84.2
        !          1152: 30 86
        !          1153: cin>) cin_quit();
        !          1154: |i($)
        !          1155: |end(computeroutput)
        !          1156: |blank_space(-1)
        !          1157: 
        !          1158: |subsection(Answer 2)
        !          1159: 
        !          1160: |blank_space(-1)
        !          1161: |begin(computeroutput)
        !          1162: void
        !          1163: prt(n)
        !          1164: struct node *n;
        !          1165: {
        !          1166:   switch(n->type) {
        !          1167: 
        !          1168:   default:
        !          1169:     printf("( ");
        !          1170:     prt(n->left);
        !          1171:     printf("%s ", n->value);
        !          1172:     prt(n->right);
        !          1173:     printf(") ");
        !          1174:     break;
        !          1175: 
        !          1176:   case UMINUS:
        !          1177:     printf("%s ", n->value);
        !          1178:     prt(n->right);
        !          1179:     break;
        !          1180: 
        !          1181:   case CONST:
        !          1182:   case VAR:
        !          1183:     printf("%s ", n->value);
        !          1184:     break;
        !          1185: 
        !          1186:   }
        !          1187: }
        !          1188: |end(computeroutput)
        !          1189: |blank_space(-1)
        !          1190: 
        !          1191: |subsection(Answer 3)
        !          1192: 
        !          1193: |blank_space(-1)
        !          1194: |begin(computeroutput)
        !          1195: (echo 'extern char *cin_prompt;
        !          1196: cin_prompt="";
        !          1197: #include <stdio.h>
        !          1198: #include <math.h>
        !          1199: char buf[1024], buf2[1024];
        !          1200: double t;
        !          1201: while(gets(buf) != NULL) {
        !          1202:   sprintf(buf2,
        !          1203:    "printf(|sp(\)"%%g|sp(\)|sp(\)n|sp(\)",t=(double)(%s));",
        !          1204:    buf);
        !          1205:     cin_eval(buf2);
        !          1206: }'; cat ) | cin -i
        !          1207: |end(computeroutput)
        !          1208: |blank_space(-1)
        !          1209: 
        !          1210: |section(Acknowledgements)
        !          1211: 
        !          1212: We thank Brian Kernighan
        !          1213: for permission to draw inspiration and borrow phrases from his editor tutorial.
        !          1214: We also thank
        !          1215: Sumit Bandyopadhyay,
        !          1216: Bill Carpenter,
        !          1217: Paul De Bra,
        !          1218: Alan Hastings,
        !          1219: Jonathan Helfman,
        !          1220: Andrew Hume,
        !          1221: Leonard Kasday,
        !          1222: Brian Kernighan,
        !          1223: Tom Kirk,
        !          1224: David Korn,
        !          1225: Lisa Kowalski,
        !          1226: Richard Maus,
        !          1227: Lawrence Mayka,
        !          1228: Doug McIlroy,
        !          1229: Marcel Meth,
        !          1230: Eric Muehrcke,
        !          1231: Jishnu Mukerji,
        !          1232: Rob Murray,
        !          1233: Sharon Peeters,
        !          1234: Mike Riley,
        !          1235: Larry Satz,
        !          1236: Judy Schmidt,
        !          1237: Timothy Schroeder,
        !          1238: Jonathan Shapiro,
        !          1239: Joe Steffen,
        !          1240: Andy Tripp,
        !          1241: Tom Walsh,
        !          1242: William Wetzel,
        !          1243: and
        !          1244: Myron Wish
        !          1245: for useful comments on previous versions of this paper.
        !          1246: 
        !          1247: |comment<
        !          1248: |style(one_column)
        !          1249: 
        !          1250: |signature(MH-11229-TJK/HHG/JJP-tjk/hhg/jjp)
        !          1251: >
        !          1252: 
        !          1253: |comment<
        !          1254: |notation(Att.
        !          1255: References)
        !          1256: 
        !          1257: |other
        !          1258: >
        !          1259: 
        !          1260: |reference_placement
        !          1261: 
        !          1262: |keywords(Rapid Prototyping,
        !          1263: Incremental Update,
        !          1264: C Programming)
        !          1265: 
        !          1266: |comment<
        !          1267: |mercury(cmp, elc)
        !          1268: 
        !          1269: |att(is_release yes)
        !          1270: 
        !          1271: |distribute_complete_memo(Executive Directors 112
        !          1272: Directors 112
        !          1273: Department Heads 1122
        !          1274: Sumit Bandyopadhyay
        !          1275: Bill Carpenter
        !          1276: Paul De Bra
        !          1277: Alan Hastings
        !          1278: Jonathan Helfman
        !          1279: Yean-Ming Huang
        !          1280: Andrew Hume
        !          1281: Leonard Kasday
        !          1282: Brian Kernighan
        !          1283: Tom Kirk
        !          1284: David Korn
        !          1285: Lisa Kowalski
        !          1286: Richard Maus
        !          1287: Lawrence Mayka
        !          1288: Doug McIlroy
        !          1289: Marcel Meth
        !          1290: Eric Muerhcke
        !          1291: Jishnu Mukerji
        !          1292: Rob Murray
        !          1293: Sharon Peeters
        !          1294: Mike Riley
        !          1295: Larry Satz
        !          1296: Judy Schmidt
        !          1297: Timothy Schroeder
        !          1298: Jonathan Shapiro
        !          1299: Joe Steffen
        !          1300: Andy Tripp
        !          1301: Tom Walsh
        !          1302: William Wetzel)
        !          1303: 
        !          1304: |distribute_cover_sheet(A. A. Penzias
        !          1305: 1122 MTS
        !          1306: Miguel Abdo
        !          1307: Tom Beattie
        !          1308: Jim Burnash
        !          1309: Tom Cargill
        !          1310: John Carter
        !          1311: Craig Cleaveland
        !          1312: Don deCourcelle
        !          1313: Helen Diamantidis
        !          1314: Laura Eaves
        !          1315: Faiq Fazal
        !          1316: Tom Foregger
        !          1317: Carol Franklin
        !          1318: Narain Gehani
        !          1319: Richard Greer
        !          1320: John Gregg
        !          1321: Jim Grenier
        !          1322: Inars Gruntals
        !          1323: Roy Harkness
        !          1324: Kurt Haserodt
        !          1325: Alan Hewett
        !          1326: Viet Hoang
        !          1327: James Holmes
        !          1328: Mike Hudson
        !          1329: Douglas Johnston
        !          1330: Jon Kaplowitz
        !          1331: Kevin Kinnear
        !          1332: Peter Kirslis
        !          1333: Balachander Krishnamurthy
        !          1334: Ajoy Kumar
        !          1335: David Lubinsky
        !          1336: Robert Lyons
        !          1337: John Malleo-Roach
        !          1338: Pat McGowan
        !          1339: Al McPherson
        !          1340: Douglas Miller
        !          1341: Datta Miruke
        !          1342: John Mocenigo
        !          1343: Dave Neal
        !          1344: Eric Olson
        !          1345: Joseph Patterson
        !          1346: Virginia Piccininni
        !          1347: Thomas Pisciotta
        !          1348: David Potter
        !          1349: Demetri Prountzos
        !          1350: Benjamin Reytblat
        !          1351: Ernie Rice
        !          1352: James Rowland
        !          1353: Ed Schan
        !          1354: William Schell
        !          1355: Carl Seaquist
        !          1356: Steve Shepherd
        !          1357: John Sherman
        !          1358: Tyrone Shiu
        !          1359: Les Shupe
        !          1360: David Smull
        !          1361: G. Mark Stewart
        !          1362: Art Storm
        !          1363: Rich Struse
        !          1364: Mark Swartz
        !          1365: Rick Thomas
        !          1366: Tim Thompson
        !          1367: Peter Ting
        !          1368: Gregg Vesonder
        !          1369: Yu-Lien Yen
        !          1370: John Young
        !          1371: Avi Zahavi)
        !          1372: 
        !          1373: |add_totals(other 4)
        !          1374: 
        !          1375: |cover_sheet
        !          1376: >

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.