FFI:\r
\r
-- wordpreview: don't show for string literals and comments\r
- listener: use console shell api\r
- add a socket timeout\r
- fix error postoning -- not all errors thrown by i/o code are\r
postponed\r
-- file responder: don't show full path in title\r
- quit responder breaks with multithreading\r
\r
+ compiler/ffi:\r
--- /dev/null
+IN: stack-effect
+USE: lists
+USE: stack
+USE: math
+USE: combinators
+USE: kernel
+USE: test
+USE: errors
+
+: s* ( [ a | b ] [ c | d ] )
+ #! Stack effect composition.
+ >r uncons r> uncons >r -
+ dup 0 < [ neg + r> cons ] [ r> + cons ] ifte ;
+
+: list* ( list [ a | b ] -- list )
+ #! Right composition with a list and stack effect.
+ swap [ over s* ] map nip prune ;
+
+: *list ( [ a | b ] list -- list )
+ #! Left composition with a list and stack effect.
+ [ dupd s* ] map nip prune ;
+
+: <> ( [ a | b ] )
+ #! Stack height equivelence.
+ uncons - ;
+
+: balanced? ( list -- ? )
+ #! Is this a balanced set?
+ [ unswons <> swap [ <> over = ] all? nip ] [ t ] ifte* ;
+
+: car> ( [ a | b ] [ c | d ] )
+ swap car swap car > ;
+
+: car-max ( [ a | b ] [ c | d ] )
+ 2dup car> [ drop ] [ nip ] ifte ;
+
+: point ( list -- [ a | b ] )
+ #! The point of a balanced set.
+ [ -1 | -1 ] swap [ car-max ] each ;
+
+: s+ ( [ a | b ] [ c | d ] -- )
+ #! Stack effect addition.
+ 2list dup balanced? [ point ] [ "Not balanced" throw ] ifte ;
+
+[ t ] [ [ [ 1 | 2 ] [ 3 | 4 ] ] balanced? ] unit-test
+[ f ] [ [ [ 4 | 2 ] [ 3 | 4 ] ] balanced? ] unit-test
+[ t ] [ [ [ 1 | 5 ] ] balanced? ] unit-test
+[ t ] [ [ ] balanced? ] unit-test
+[ [ 3 | 4 ] ] [ [ [ 1 | 2 ] [ 3 | 4 ] ] point ] unit-test
+
+[ [ [ 1 | 1 ] [ 2 | 2 ] [ 3 | 3 ] ] ]
+[ [ [ 1 | 2 ] [ 2 | 3 ] [ 3 | 4 ] ] [ 1 | 0 ] list* ] unit-test
+
+[ [ 1 | 1 ] ] [ [ 1 | 2 ] [ 2 | 1 ] s* ] unit-test
+
+[ [ 4 | 5 ] ] [ [ 4 | 5 ] [ 3 | 4 ] s+ ] unit-test
{
private FactorInterpreter interp;
private WordPreview wordPreview;
+ private Map previewMap;
/**
* When we parse a file, we store the <word,worddef> pairs in this
{
super("factor");
interp = FactorPlugin.getInterpreter();
- wordPreview = new WordPreview(this);
+ previewMap = new HashMap();
worddefs = new HashMap();
} //}}}
public void activate(EditPane editPane)
{
super.activate(editPane);
- editPane.getTextArea().addCaretListener(wordPreview);
+ WordPreview preview = new WordPreview(this,
+ editPane.getTextArea());
+ previewMap.put(editPane,preview);
+ editPane.getTextArea().addCaretListener(preview);
} //}}}
//{{{ deactivate() method
public void deactivate(EditPane editPane)
{
super.deactivate(editPane);
- editPane.getTextArea().removeCaretListener(wordPreview);
+ WordPreview preview = (WordPreview)previewMap
+ .remove(editPane);
+ if(preview != null)
+ editPane.getTextArea().removeCaretListener(preview);
} //}}}
//{{{ parse() method
package factor.jedit;
import factor.*;
+import java.awt.event.*;
import java.util.*;
import javax.swing.event.*;
+import javax.swing.Timer;
+import org.gjt.sp.jedit.syntax.*;
import org.gjt.sp.jedit.textarea.*;
import org.gjt.sp.jedit.*;
import org.gjt.sp.util.Log;
import sidekick.*;
-public class WordPreview implements CaretListener
+public class WordPreview implements ActionListener, CaretListener
{
private FactorSideKickParser parser;
+ private Timer timer;
+ private JEditTextArea textArea;
+
+ private static String[] IGNORED_RULESETS = {
+ "factor::LITERAL",
+ "factor::STACK_EFFECT",
+ "factor::COMMENT"
+ };
//{{{ WordPreview constructor
- public WordPreview(FactorSideKickParser parser)
+ public WordPreview(FactorSideKickParser parser,
+ JEditTextArea textArea)
{
this.parser = parser;
+ this.textArea = textArea;
+ this.timer = new Timer(0,this);
+ timer.setRepeats(false);
} //}}}
//{{{ caretUpdate() method
public void caretUpdate(CaretEvent e)
{
- showPreview((JEditTextArea)e.getSource());
+ timer.stop();
+ timer.setInitialDelay(100);
+ timer.start();
} //}}}
+ //{{{ public void actionPerformed() method
+ public void actionPerformed(ActionEvent evt)
+ {
+ showPreview();
+ } //}}}
+
//{{{ showPreview() method
- private void showPreview(JEditTextArea textArea)
+ private void showPreview()
{
View view = textArea.getView();
- String word = FactorPlugin.getWordAtCaret(textArea);
- if(word == null)
- return;
+
SideKickParsedData data = SideKickParsedData
.getParsedData(view);
if(data instanceof FactorParsedData)
{
+ int line = textArea.getCaretLine();
+ int caret = textArea.getCaretPosition();
+
+ DefaultTokenHandler h = new DefaultTokenHandler();
+ textArea.getBuffer().markTokens(line,h);
+ Token tokens = h.getTokens();
+
+ Token token = TextUtilities.getTokenAtOffset(tokens,
+ caret - textArea.getLineStartOffset(line));
+
+ String name = token.rules.getName();
+
+ for(int i = 0; i < IGNORED_RULESETS.length; i++)
+ {
+ if(name.equals(IGNORED_RULESETS[i]))
+ return;
+ }
+
+ String word = FactorPlugin.getWordAtCaret(textArea);
+ if(word == null)
+ return;
+
FactorParsedData fdata = (FactorParsedData)data;
FactorInterpreter interp = fdata.parser
.getInterpreter();
"method" get "head" = [
drop
] [
- dup [ directory. ] simple-html-document
+ "request" get [ directory. ] simple-html-document
] ifte ;
: serve-directory ( filename -- )
USE: vectors
: 2list ( a b -- [ a b ] )
- #! Construct a proper list of 2 elements.
unit cons ;
: 3list ( a b c -- [ a b c ] )
- #! Construct a proper list of 3 elements.
2list cons ;
: append ( [ list1 ] [ list2 ] -- [ list1 list2 ] )
over [ >r uncons r> append cons ] [ nip ] ifte ;
: contains? ( element list -- remainder )
- #! If the proper list contains the element, push the
- #! remainder of the list, starting from the cell whose car
- #! is elem. Otherwise push f.
dup [
2dup car = [ nip ] [ cdr contains? ] ifte
] [
dup cdr cons? [ cdr last* ] when ;
: last ( list -- last )
- #! Pushes last element of a list.
last* car ;
: list? ( list -- boolean )
inline interpret-only
: reverse ( list -- list )
- #! Push a new list that is the reverse of a proper list.
[ ] swap [ swons ] each ;
: map ( list quot -- list )
[ dupd = not ] subset nip ;
: length ( list -- length )
- #! Pushes the length of the given proper list.
0 swap [ drop succ ] each ;
+: prune ( list -- list )
+ #! Remove duplicate elements.
+ dup [
+ uncons prune 2dup contains? [ nip ] [ cons ] ifte
+ ] when ;
+
: all? ( list pred -- ? )
#! Push if the predicate returns true for each element of
#! the list.
[ [ 0 1 2 3 ] ] [ 4 count ] unit-test
[ [ 1 2 3 ] ] [ [ 1 4 2 5 3 6 ] [ 4 < ] subset ] unit-test
+
+[ [ 43 "a" [ ] ] ] [ [ "a" 43 43 43 [ ] 43 "a" [ ] ] prune ] unit-test
projects / factor.git / commitdiff