Databases
StackOverflow2013
Postsdbo
PO
 

Note that there are some explanatory texts on larger screens.

plurals
  1. PO
    primarykey
    data
    text
    <p>What you want is a syntax-directed <a href="http://en.wikipedia.org/wiki/Structure_editor" rel="nofollow">structure editor</a>. This is one that combines parsing with AST building and uses the parser to predict what you can type next (either syntax completion), or has a tie to the compiler's last run, so that it can interpret the edit point to see what valid identifiers might come next by inspecting the compiler's symbol table that was last relevant at that point in the code. </p> <p>The most difficult part is offering the user a seamless experience; she pretty much has to believe she is editing text or (experience with structure editors shows) she will reject it as awkward.</p> <p>This is a lot of machinery to coordinate and quite a big effort. The good news is that you need a parser anyway for the compiler; if editing also parses, the AST needed by the compiler is essentially available. (Of course you have to worry about batch compiling, too). The compiler has to build a symbol table; so you can use that in the editing completion process. The more difficult news is that the parsers are a lot harder to build; they can't just declare a user-visible syntax error and quit; rather they have to be tolerant of a number of errors extant at the same moment, hold partial ASTs for the pieces, and stitch them together as the errors are removed by the user.</p> <p>The <a href="http://harmonia.cs.berkeley.edu/" rel="nofollow">Berkeley Harmonia</a> people are doing good work in this area. It is well worth your trouble to read some of their papers to get a detailed sense of the problems and one approach to handling them.</p> <p>THe other major approach people (notably <a href="http://en.wikipedia.org/wiki/Intentional_programming" rel="nofollow">Intentional Programming</a> and <a href="http://www.eclipse.org/Xtext" rel="nofollow">XText</a>) seem to be trying are object-oriented editors, where you attach editing actions to each AST node, and associate every point on the screen with an AST node. Then editing actions invoke AST-node specific actions (insert-character, go right, go up, ...) and it can decide how to act and how to modify the screen. Arguably you can make these editors do anything; its a little harder in practice. I've used these editors; they don't feel like text editors. There are some enthusiastic users, but YMMV.</p> <p>I think you probably ought to choose between trying to build such an editor, vs. trying to define a new langauge. Doing both at once is likely to overwhelm you with troubles.</p>
    singulars
    1. This table or related slice is empty.
    1. PORelationship between parsing, highlighting and completion
      singulars
      1. PTQuestion
    1. PTAnswer
    1. USIra Baxter
    1. USIra Baxter
    plurals
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    1. PORelationship between parsing, highlighting and completion
      singulars
      1. PTQuestion
    1. This table or related slice is empty.
    1. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTUpMod
    2. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTUpMod
    3. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTAcceptedByOriginator
    1. COThanks for the answer. While you provide some valuable links, I still miss some insight on the extent of the differences you mention between the parser in the compiler and the parser in the IDE. For instance I imagine the parser in the IDE as some function of the whole code + current line -> possible completions which is already present in some compilers (gcc for instance, proposes alternatives when you provide the wrong argument types to a function).
      singulars
      1. PO
      1. USGiovanni Funchal
    2. COThe IDE parser has to "do more" than the compiler parser, in the sense (as you've noted) it needs to know what is *legal* next (as the compiler does) and what is *probable* next (which the compiler generally doesn't care about at all). "Probable" is based on the context of the entire application; mostly that comes from symbol table data constructed from the compiler and arguably updated by the IDE as you use it. (GCC giving you alternatives is actually doing this "probable" kind of diagnosis. Sure, its helpful, which is why you wanted it in the IDE, too :)
      singulars
      1. PO
      1. USIra Baxter
 

Querying!

 
Guidance
A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload