Changeset 87


Ignore:
Timestamp:
06/05/08 17:05:48 (16 years ago)
Author:
ra33
Message:

Fixed some stuff with the SIMPLE debugger
Refactored the way the interpretor works to make it easier to give better error messages.

Location:
trunk
Files:
1 added
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/expeditee/actions/Misc.java

    r86 r87  
    270270                Frame current = DisplayIO.getCurrentFrame();
    271271                Item text = current.getStatsTextItem(itemText);
     272                text.setSelectedMode(Item.SelectedMode.Normal);
     273                text.setSelectedMode(Item.SelectedMode.None);
    272274                FrameMouseActions.pickup(text);
    273275                FrameGraphics.Repaint();
  • trunk/src/org/expeditee/actions/Simple.java

    r86 r87  
    3232import org.expeditee.items.Text;
    3333import org.expeditee.items.Item.SelectedMode;
     34import org.expeditee.simple.AboveMaxParametreCountException;
    3435import org.expeditee.simple.BelowMinParametreCountException;
    3536import org.expeditee.simple.Context;
     
    116117        private static boolean _step;
    117118
    118         private static int _stepPause = 0;
     119        private static int _stepPause = -1;
    119120
    120121        private static Color _stepColor;
     
    123124
    124125        public static void KeyStroke(char c) {
    125                
    126                
    127126                _KeyStrokes.add(c);
    128127        }
     
    180179
    181180        public static void RunSimpleTests(String frameset) {
    182                 RunSimpleTests(frameset, false);
     181                RunSimpleTests(frameset, false, true);
    183182        }
    184183
    185184        public static void RunSimpleTestsVerbose(String frameset) {
    186                 RunSimpleTests(frameset, true);
     185                RunSimpleTests(frameset, true, true);
    187186        }
    188187
     
    197196
    198197        public void run() {
     198                runSuite();
     199        }
     200
     201        public boolean runSuite() {
    199202                int testsPassed = 0;
    200203                int testsFailed = 0;
     
    222225                                continue;
    223226                        if (actions.get(0).toLowerCase().equals("runframe")) {
     227                                boolean passed = true;
     228                                String errorMessage = null;
    224229                                try {
    225230                                        title.setLink(nextFrameName);
     
    232237                                        RunFrameAndReportError(title, new Context());
    233238                                        _programsRunning--;
     239                                        // if the throws exception annotation is on the frame then
     240                                        // it passes only if an exception is thrown
     241                                        if (title.getParentOrCurrentFrame().getThrowsException()) {
     242                                                errorMessage = "Expected exception " + title.toString();
     243                                                passed = false;
     244                                        }
     245                                } catch (Exception e) {
     246                                        _programsRunning--;
     247                                        if (!title.getParentOrCurrentFrame().getThrowsException()) {
     248                                                errorMessage = e.getMessage();
     249                                                passed = false;
     250                                        }
     251                                }
     252                                if (passed) {
    234253                                        if (_verbose)
    235254                                                FrameGraphics.DisplayMessage("Test passed: "
    236255                                                                + title.toString(), Item.GREEN);
    237256                                        testsPassed++;
    238                                 } catch (Exception e) {
     257                                } else {
    239258                                        testsFailed++;
    240                                         _programsRunning--;
    241259                                        // Print out the reason for failed tests
    242                                         FrameGraphics.LinkedErrorMessage(e.getMessage());
     260                                        FrameGraphics.LinkedErrorMessage(errorMessage);
    243261                                        if (Simple._stop) {
    244262                                                Simple._stop = false;
    245                                                 return;
     263                                                return false;
    246264                                        }
    247265                                }
     
    260278                // Remove items from the cursor...
    261279                Frame.FreeItems.clear();
    262         }
    263 
    264         public static void RunSimpleTests(String frameset, boolean verbose) {
     280
     281                return testsFailed == 0;
     282        }
     283
     284        /**
     285         * Runs a suite of tests stored in a given frameset.
     286         *
     287         * @param frameset
     288         * @param verbose
     289         * @param newThread
     290         *            false if tests should be run on the current frame
     291         */
     292        public static void RunSimpleTests(String frameset, boolean verbose,
     293                        boolean newThread) {
    265294                _stop = false;
    266                 Thread t = new Thread(new Simple(frameset, verbose));
    267                 t.setPriority(Thread.MIN_PRIORITY);
    268                 t.start();
     295                Simple testSuite = new Simple(frameset, verbose);
     296                if (newThread) {
     297                        Thread t = new Thread(testSuite);
     298                        t.setPriority(Thread.MIN_PRIORITY);
     299                        t.start();
     300                } else {
     301                        assert (testSuite.runSuite());
     302                }
     303
    269304        }
    270305
     
    290325                        _KeyStrokes.clear();
    291326
    292                         _programsRunning++;
    293327                        Thread t = new Thread(current);
    294328                        t.setPriority(Thread.MIN_PRIORITY);
    295329                        t.start();
    296                         // _programsRunning--;
    297330                } catch (Exception e) {
    298                         // _programsRunning--;
    299331                }
    300332        }
     
    330362
    331363        public static void DebugFrame(Item current) {
    332                 DebugFrame(current, 0.2, null);
     364                DebugFrame(current, -1.0, null);
    333365        }
    334366
     
    370402                }
    371403
    372                 // loop through non-title, non-name, non-annotation text items
    373                 List<Text> body = child.getBodyTextItems(false);
     404                // loop through non-title, non-name, text items
     405                List<Text> body = child.getBodyTextItems(true);
    374406
    375407                // if no item was found
     
    383415                                Color oldColor = item.getBackgroundColor();
    384416                                if (_step) {
    385                                         if (item.getLink() == null) {
     417                                        if (item.getLink() != null) {
     418                                                pause(item);
     419                                                item.setSelectedMode(Item.SelectedMode.Normal,
     420                                                                _stepColor);
     421                                        } else {
    386422                                                item.setBackgroundColor(_stepColor);
    387                                         }else{
    388                                                 item.setSelectedMode(Item.SelectedMode.Normal,_stepColor);
    389423                                        }
    390424                                        FrameGraphics.Repaint();
     
    392426                                lastItemStatus = RunItem(item, context, lastItemStatus);
    393427                                if (_step) {
    394                                         if (item.getLink() != null) {
    395                                                 item.setBackgroundColor(_stepColor);
     428                                        if (item.getLink() == null) {
     429                                                item.setBackgroundColor(oldColor);
     430                                                pause(item);
     431                                        } else {
    396432                                                item.setSelectedMode(Item.SelectedMode.None);
    397                                                 FrameGraphics.Repaint();
    398433                                        }
    399                                         int timeRemaining;
    400                                         if (_stepPause < 0)
    401                                                 timeRemaining = Integer.MAX_VALUE;
    402                                         else
    403                                                 timeRemaining = _stepPause;
    404 
    405                                         while (timeRemaining > 0 && !_nextStatement) {
    406                                                 if (_stop) {
    407                                                         item.setBackgroundColor(oldColor);
    408                                                         item.setSelectedMode(SelectedMode.Normal,_stepColor);
    409                                                         throw new Exception("Program terminated");
    410                                                 }
    411                                                 Thread.sleep(DefaultAgent.TIMER_RESOLUTION);
    412                                                 timeRemaining -= DefaultAgent.TIMER_RESOLUTION;
    413                                         }
    414                                         _nextStatement = false;
    415                                         // Turn off the highlighting
    416                                         item.setBackgroundColor(oldColor);
    417434                                }
    418435
     
    447464
    448465        /**
     466         * @param item
     467         * @param oldColor
     468         * @throws Exception
     469         * @throws InterruptedException
     470         */
     471        private static void pause(Text item) throws Exception, InterruptedException {
     472                if (!_step)
     473                        return;
     474
     475                Color oldColor = item.getBackgroundColor();
     476                item.setBackgroundColor(_stepColor);
     477                item.setSelectedMode(Item.SelectedMode.None);
     478
     479                // Make sure we are on the frame with this item
     480                Frame parent = item.getParentOrCurrentFrame();
     481                if (!parent.equals(DisplayIO.getCurrentFrame())) {
     482                        DisplayIO.setCurrentFrame(parent);
     483                }
     484
     485                FrameGraphics.Repaint();
     486
     487                int timeRemaining;
     488                if (_stepPause < 0)
     489                        timeRemaining = Integer.MAX_VALUE;
     490                else
     491                        timeRemaining = _stepPause;
     492
     493                while (timeRemaining > 0 && !_nextStatement) {
     494                        if (_stop) {
     495                                item.setBackgroundColor(oldColor);
     496                                item.setSelectedMode(SelectedMode.Normal, _stepColor);
     497                                throw new Exception("Program terminated");
     498                        }
     499                        Thread.sleep(DefaultAgent.TIMER_RESOLUTION);
     500                        timeRemaining -= DefaultAgent.TIMER_RESOLUTION;
     501                }
     502                _nextStatement = false;
     503                // Turn off the highlighting
     504                item.setBackgroundColor(oldColor);
     505        }
     506
     507        private static void pause(double time) throws Exception {
     508                for (int i = 0; i < time * 10; i++) {
     509                        if (_stop) {
     510                                throw new Exception("Program terminated");
     511                        }
     512                        Thread.yield();
     513                        Thread.sleep(100);
     514                }
     515        }
     516
     517        /**
    449518         * This method should be modified to parse strings correctly
    450519         *
     
    453522         */
    454523        private static String[] parseStatement(Text code) throws Exception {
    455                 String statement = code.getText();
     524                String statement = code.getText().trim();
    456525                ArrayList<String> tokens = new ArrayList<String>();
     526
     527                // Check special annotation tags for programs
     528                if (statement.length() > 0 && statement.charAt(0) == '@') {
     529                        statement = statement.toLowerCase();
     530                        // Flags the next unit test as being required to throw an exception
     531                        if (statement.equals("@throwsexception")) {
     532                                code.getParentOrCurrentFrame().setThrowsException(true);
     533                        }
     534                        return null;
     535                }
    457536
    458537                for (int i = 0; i < statement.length(); i++) {
     
    643722                }
    644723
    645                 // Comments without links are a no-op
    646                 if (tokens.length == 0) {
     724                // Annotation items are ignored after parsing running options
     725                if (tokens == null) {
     726                        return Status.OK;
     727                        // Comments without links are ignored
     728                } else if (tokens.length == 0) {
    647729                        if (code.getLink() == null)
    648730                                return Status.OK;
     
    665747                                                        && tokens.length == 3) {
    666748                                                context.getPrimitives().set(tokens[1], tokens[2]);
    667                                                 return Status.OK;
    668749                                        }
    669750                                        // Otherwise we are setting a variable with a literal
     
    675756                                                                        new SString(tokens[2].substring(1,
    676757                                                                                        tokens[2].length() - 1)));
    677                                                         return Status.OK;
    678 
    679758                                                        // set a literal
    680759                                                } else if (tokens.length == 3) {
    681760                                                        context.getPrimitives().setValue(tokens[1],
    682761                                                                        tokens[2]);
    683                                                         return Status.OK;
    684762                                                }
    685763                                        }
     
    688766                                }
    689767                        } else if (tokens[0].equals("setassociation")) {
    690                                 assertMinParametreCount(tokens, 3);
     768                                assertExactParametreCount(tokens, 3);
    691769
    692770                                Map map = (Map) context.getPointers().getVariable(tokens[1])
     
    697775                                                .getStringValue(tokens[3]);
    698776                                map.put(attribute, value);
    699                                 return Status.OK;
    700777                        } else if (tokens[0].equals("setframevalue")) {
    701778                                assertMinParametreCount(tokens, 3);
     
    754831                                        }
    755832                                }
    756 
    757                                 return Status.OK;
    758833                        } else if (tokens[0].startsWith("setitem")) {
    759834                                if (tokens[0].equals("setitemposition")) {
     
    838913                                        throw new Exception("Unsupported setItem command: "
    839914                                                        + code.toString());
    840                                 return Status.OK;
    841915                        } else if (tokens[0].equals("setstrchar")) {
    842916                                assertExactParametreCount(tokens, 3);
     
    854928                                context.getPrimitives().setValue(tokens[1],
    855929                                                new SString(s.toString()));
    856                                 return Status.OK;
    857930                        } else if (tokens[0].equals("setcharinitem")) {
    858931                                assertExactParametreCount(tokens, 4);
     
    883956                                itemText.set(row, sb.toString());
    884957                                item.setTextList(itemText);
    885 
    886                                 return Status.OK;
    887958                        }
    888959                } else if (tokens[0].startsWith("assert")) {
     
    891962                                if (!context.getPrimitives().getBooleanValue(tokens[1]))
    892963                                        throw new UnitTestFailedException("true", "false");
    893                                 return Status.OK;
    894964                        } else if (tokens[0].equals("assertfalse")) {
    895965                                assertExactParametreCount(tokens, 1);
    896966                                if (context.getPrimitives().getBooleanValue(tokens[1]))
    897967                                        throw new UnitTestFailedException("false", "true");
    898                                 return Status.OK;
    899                         }
    900                         if (tokens[0].equals("assertfail")) {
     968                        } else if (tokens[0].equals("assertfail")) {
    901969                                assertExactParametreCount(tokens, 0);
    902970                                throw new UnitTestFailedException("pass", "fail");
     
    907975                                if (value != null)
    908976                                        throw new UnitTestFailedException("null", value.toString());
    909                                 return Status.OK;
    910977                        } else if (tokens[0].equals("assertnotnull")) {
    911978                                assertExactParametreCount(tokens, 1);
     
    914981                                if (value == null)
    915982                                        throw new UnitTestFailedException("not null", "null");
    916                                 return Status.OK;
    917983                        } else if (tokens[0].equals("assertdefined")) {
    918984                                assertExactParametreCount(tokens, 1);
    919985                                if (!context.isDefined(tokens[1]))
    920986                                        throw new UnitTestFailedException("defined", "not defined");
    921                                 return Status.OK;
    922987                        } else if (tokens[0].equals("assertnotdefined")) {
    923988                                assertExactParametreCount(tokens, 1);
    924989                                if (context.isDefined(tokens[1]))
    925990                                        throw new UnitTestFailedException("defined", "not defined");
    926                                 return Status.OK;
    927991                        } else if (tokens[0].equals("assertequals")) {
    928992                                assertExactParametreCount(tokens, 2);
     
    931995                                                        .getStringValue(tokens[1]), context.getPrimitives()
    932996                                                        .getStringValue(tokens[2]));
    933                                 return Status.OK;
    934997                        } else if (tokens[0].equals("assertdefined")) {
    935998                                assertExactParametreCount(tokens, 1);
     
    9381001                                                        "not defined");
    9391002                                }
    940                                 return Status.OK;
    9411003                        }
    9421004                } else if (tokens[0].startsWith("goto")) {
     
    9491011                                        frameNameVar);
    9501012                        NavigationActions.Goto(frameName);
    951                         return Status.OK;
    9521013                } else if (tokens[0].startsWith("get")) {
    9531014                        if (tokens[0].startsWith("getframe")) {
     
    10111072                                                }
    10121073                                        }
    1013                                         return Status.OK;
    10141074                                } else if (tokens[0].startsWith("getframename")) {
    10151075                                        String frameNameVar = DEFAULT_STRING;
     
    10261086                                        context.getPrimitives().setValue(frameNameVar,
    10271087                                                        frame.getName());
    1028                                         return Status.OK;
    10291088                                } else if (tokens[0].startsWith("getframefilepath")) {
    10301089                                        assertExactParametreCount(tokens, 2);
     
    10351094                                                        frameName);
    10361095                                        context.getPrimitives().setValue(tokens[2], filePath);
    1037                                         return Status.OK;
    10381096                                } else if (tokens[0].equals("getframelog")) {
    10391097                                        assertExactParametreCount(tokens, 1);
     
    10461104                                                        .getValue();
    10471105                                        t.setText(log);
    1048 
    1049                                         return Status.OK;
    10501106                                }
    10511107                        } else if (tokens[0].equals("getassociation")) {
     
    10571113                                String newValue = map.get(attribute).toString();
    10581114                                context.getPrimitives().setValue(tokens[3], newValue);
    1059                                 return Status.OK;
    10601115                        } else if (tokens[0].startsWith("getcurrent")) {
    10611116                                if (tokens[0].equals("getcurrentframe")) {
     
    10711126                                                                new SString(currentFrame.getName()));
    10721127                                        }
    1073                                         return Status.OK;
    10741128                                }
    10751129                        } else if (tokens[0].startsWith("getitem")) {
     
    11621216                                        throw new Exception("Unsupported getItem command: "
    11631217                                                        + code.toString());
    1164 
    1165                                 return Status.OK;
    11661218                        } else if (tokens[0].equals("getstrchar")) {
    11671219                                assertExactParametreCount(tokens, 3);
     
    11721224                                context.getPrimitives().setValue(tokens[3],
    11731225                                                new SCharacter(s.charAt(pos - 1)));
    1174                                 return Status.OK;
    11751226                        } else if (tokens[0].equals("getstrlength")) {
    11761227                                assertExactParametreCount(tokens, 2);
     
    11791230                                context.getPrimitives().setValue(tokens[2],
    11801231                                                new SInteger(s.length()));
    1181                                 return Status.OK;
    11821232                        } else if (tokens[0].equals("getelapsedtime")) {
    11831233                                assertExactParametreCount(tokens, 1);
    11841234                                context.getPrimitives().setValue(tokens[1],
    11851235                                                new SInteger(AgentStats.getMilliSecondsElapsed()));
    1186                                 return Status.OK;
    11871236                        } else if (tokens[0].equals("getlastnumberinframeset")) {
    11881237                                String framesetNameVar = DEFAULT_STRING;
     
    11971246                                long count = FrameIO.getLastNumber(frameset);
    11981247                                context.getPrimitives().setValue(countVar, new SInteger(count));
    1199                                 return Status.OK;
    12001248                        } else if (tokens[0].equals("getlistofframesets")) {
    12011249                                String stringVar = DEFAULT_ITEM;
     
    12061254                                context.getPrimitives().setValue(stringVar,
    12071255                                                FrameIO.getFramesetList());
    1208                                 return Status.OK;
    12091256                        } else if (tokens[0].equals("getsessionstats")) {
    12101257                                assertExactParametreCount(tokens, 1);
     
    12121259
    12131260                                String stats = SessionStats.getCurrentStats();
    1214                                 Text t;
    1215                                 // try {
    1216                                 t = (Text) context.getPointers().getVariable(tokens[1])
     1261                                Text t = (Text) context.getPointers().getVariable(tokens[1])
    12171262                                                .getValue();
    12181263                                t.setText(stats);
    1219                                 // } catch (Exception e) {
    1220                                 // t = new Text(-1, stats);
    1221                                 // context.getPointers().setObject(tokens[1], t);
    1222                                 // }
    1223 
    1224                                 return Status.OK;
    12251264                        } else if (tokens[0].equals("getrandominteger")) {
    12261265                                assertExactParametreCount(tokens, 3);
     
    12341273                                context.getPrimitives().setValue(tokens[3],
    12351274                                                new SInteger(result));
    1236                                 return Status.OK;
    12371275                        } else if (tokens[0].equals("getrandomreal")) {
    12381276                                assertExactParametreCount(tokens, 3);
     
    12451283                                                + lowerBound;
    12461284                                context.getPrimitives().setValue(tokens[3], new SReal(result));
    1247                                 return Status.OK;
    12481285                        } else if (tokens[0].equals("getrandomtextitem")) {
    12491286                                assertExactParametreCount(tokens, 2);
     
    12561293                                context.getPointers()
    12571294                                                .setObject(tokens[2], items.get(itemIndex));
    1258                                 return Status.OK;
    12591295                        }
    12601296                } else if (tokens[0].equals("or")) {
     
    12701306                        context.getPrimitives().setValue(tokens[tokens.length - 1],
    12711307                                        new SBoolean(false));
    1272                         return Status.OK;
    12731308                } else if (tokens[0].equals("and")) {
    12741309                        for (int i = 1; i < tokens.length - 1; i++) {
     
    12831318                        context.getPrimitives().setValue(tokens[tokens.length - 1],
    12841319                                        new SBoolean(true));
    1285                         return Status.OK;
    12861320                } else if (tokens[0].equals("messagelnitem")
    12871321                                || tokens[0].equals("messagelineitem")) {
     
    13051339                                // Just ignore other errors
    13061340                        }
    1307                         return Status.OK;
    13081341                } else if (tokens[0].equals("messageln")
    13091342                                || tokens[0].equals("messageline")
     
    13181351                        else
    13191352                                FrameGraphics.DisplayMessageAlways(message);
    1320                         return Status.OK;
    13211353                } else if (tokens[0].equals("typeatrate")) {
    13221354                        assertMinParametreCount(tokens, 1);
     
    13271359                                Thread.sleep((int) (delay * 1000));
    13281360                        }
    1329                         return Status.OK;
    13301361                } else if (tokens[0].equals("type") || tokens[0].equals("typenospaces")) {
    13311362
     
    13361367                                Thread.sleep(25);
    13371368                        }
    1338                         return Status.OK;
    13391369                } else if (tokens[0].equals("runstring")) {
    13401370                        String codeText = getMessage(tokens, context, code.toString(), " ",
     
    13421372                        Text dynamicCode = new Text(1, codeText);
    13431373                        RunItem(dynamicCode, context, Status.OK);
    1344                         return Status.OK;
    13451374                } else if (tokens[0].equals("runoscommand")) {
    13461375                        String command = getMessage(tokens, context, code.toString(), " ",
    13471376                                        1);
    13481377                        Runtime.getRuntime().exec(command);
    1349                         return Status.OK;
    13501378                } else if (tokens[0].equals("executeoscommand")) {
    13511379                        String command = getMessage(tokens, context, code.toString(), " ",
     
    13691397                                throw new RuntimeException(e.getMessage());
    13701398                        }
    1371                         return Status.OK;
    13721399                } else if (tokens[0].startsWith("else")) {
    13731400                        // if the if statement was false then run the else statement
     
    15131540                        }
    15141541                        return Status.FalseIf;
    1515 
    15161542                } // Look for variable length methods
    15171543                else if (tokens[0].equals("attachitemtocursor")) {
     
    15291555                                                        FrameMouseActions.MouseY);
    15301556                        FrameMouseActions.pickup(item);
    1531                         return Status.OK;
    15321557                } else if (tokens[0].equals("attachstrtocursor")) {
    15331558                        String stringVar = DEFAULT_STRING;
     
    15441569                                                        FrameMouseActions.MouseY);
    15451570                        FrameMouseActions.pickup(item);
    1546                         // DisplayIO.repaint();
    1547                         return Status.OK;
    15481571                } else if (tokens[0].equals("additemtoframe")) {
    15491572                        String itemVar = DEFAULT_ITEM;
     
    15621585                                        .getValue();
    15631586                        frame.addItem(item);
    1564 
    1565                         return Status.OK;
    15661587                } else if (tokens[0].equals("connectdots")) {
    15671588                        assertMinParametreCount(tokens, 2);
     
    15841605                        Frame frame = dot1.getParent();
    15851606                        frame.addItem(new Line(dot1, dot2, frame.getNextItemID()));
    1586                         return Status.OK;
    15871607                } else if (tokens[0].equals("createitem")
    15881608                                || tokens[0].equals("createtext")) {
     
    16151635                        }
    16161636                        context.getPointers().setObject(tokens[4], newItem);
    1617 
    1618                         return Status.OK;
    16191637                } else if (tokens[0].equals("deleteitem")) {
    16201638                        assertMinParametreCount(tokens, 1);
     
    16231641                                        .getValue();
    16241642                        item.delete();
    1625                         return Status.OK;
    16261643                } else if (tokens[0].equals("deleteframe")) {
    16271644                        assertMinParametreCount(tokens, 1);
     
    16351652                                                new SBoolean(success));
    16361653                        }
    1637 
    1638                         return Status.OK;
    16391654                } else if (tokens[0].equals("deleteframeset")) {
    16401655                        assertMinParametreCount(tokens, 1);
     
    16471662                                                new SBoolean(success));
    16481663                        }
    1649 
    1650                         return Status.OK;
    16511664                } else if (tokens[0].equals("copyitem")) {
    16521665                        assertMinParametreCount(tokens, 2);
     
    16571670                        Item copy = item.copy();
    16581671                        context.getPointers().setObject(tokens[2], copy);
    1659 
    1660                         return Status.OK;
    16611672                } else if (tokens[0].equals("copyframeset")) {
    16621673                        assertMinParametreCount(tokens, 2);
     
    16721683                                                new SBoolean(success));
    16731684                        }
    1674 
    1675                         return Status.OK;
    16761685                } else if (tokens[0].equals("copyframe")) {
    16771686                        assertMinParametreCount(tokens, 2);
     
    16981707                                                new SBoolean(success));
    16991708                        }
    1700                         return Status.OK;
    17011709                } else if (tokens[0].equals("createframe")) {
    17021710
     
    17151723                        } else
    17161724                                context.createFrame(framesetName, frameVar, null);
    1717 
    1718                         return Status.OK;
    17191725                } else if (tokens[0].equals("closeframe")) {
    17201726                        String frameVar = DEFAULT_FRAME;
     
    17301736                        } else
    17311737                                context.closeFrame(frameVar, null);
    1732 
    1733                         return Status.OK;
    17341738                } else if (tokens[0].equals("readframe")
    17351739                                || tokens[0].equals("openframe")) {
     
    17511755                        } else
    17521756                                context.readFrame(frameName, frameVar, null);
    1753 
    1754                         return Status.OK;
    17551757                } else if (tokens[0].equals("readkbdcond")) {
    17561758
     
    17721774                                context.getPrimitives().setValue(nextCharVarName,
    17731775                                                new SCharacter(nextChar));
    1774 
    1775                         return Status.OK;
    17761776                } else if (tokens[0].equals("createassociation")) {
    17771777
     
    17841784                        Map<String, String> newMap = new HashMap<String, String>();
    17851785                        context.getPointers().setObject(associationVar, newMap);
    1786                         return Status.OK;
    17871786                } else if (tokens[0].equals("deleteassociation")) {
    17881787
     
    17941793                        }
    17951794                        context.getPointers().delete(associationVar);
    1796                         return Status.OK;
    17971795                } else if (tokens[0].equals("openreadfile")) {
    17981796                        assertVariableType(tokens[1], 1, SString.prefix);
     
    18041802                        } else
    18051803                                context.openReadFile(tokens[1], tokens[2]);
    1806 
    1807                         return Status.OK;
    18081804                } else if (tokens[0].equals("readlinefile")
    18091805                                || tokens[0].equals("readlnfile")) {
     
    18151811                        } else
    18161812                                context.readLineFile(tokens[1], tokens[2]);
    1817 
    1818                         return Status.OK;
    18191813                } else if (tokens[0].equals("readitemfile")) {
    18201814                        assertVariableType(tokens[1], 1, SPointer.filePrefix);
     
    18261820                        } else
    18271821                                context.readItemFile(tokens[1], tokens[2]);
    1828 
    1829                         return Status.OK;
    18301822                } else if (tokens[0].equals("openwritefile")) {
    18311823                        assertVariableType(tokens[1], 1, SString.prefix);
     
    18371829                        } else
    18381830                                context.openWriteFile(tokens[1], tokens[2]);
    1839 
    1840                         return Status.OK;
    18411831                } else if (tokens[0].equals("writefile")
    18421832                                || tokens[0].equals("writelinefile")
     
    18631853                                textToWrite.append('\n');
    18641854                        context.writeFile(tokens[1], textToWrite.toString());
    1865 
    1866                         return Status.OK;
    18671855                } else if (tokens[0].equals("displayframeset")) {
    18681856                        assertMinParametreCount(tokens, 1);
     
    19151903                                }
    19161904                        }
    1917                         return Status.OK;
    19181905                } else if (tokens[0].equals("createframeset")) {
    19191906                        String framesetName = DEFAULT_STRING;
     
    19251912                        }
    19261913                        context.createFrameset(framesetName, successVar);
    1927                         return Status.OK;
    19281914                } else if (tokens[0].equals("writetree")) {
    19291915                        assertMinParametreCount(tokens, 3);
     
    19381924                                wt.run();
    19391925                        }
    1940                         return Status.OK;
    19411926                } else if (tokens[0].equals("concatstr")) {
    19421927                        assertMinParametreCount(tokens, 3);
     
    19511936                        context.getPrimitives().setValue(resultVar,
    19521937                                        new SString(sb.toString()));
    1953                         return Status.OK;
    19541938                } else if (tokens[0].equals("convstrlower")) {
    19551939                        assertExactParametreCount(tokens, 1);
     
    19591943                                        new SString(context.getPrimitives().getStringValue(
    19601944                                                        tokens[1]).toLowerCase()));
    1961                         return Status.OK;
    19621945                } else if (tokens[0].equals("convstrupper")) {
    19631946                        assertExactParametreCount(tokens, 1);
     
    19671950                                        new SString(context.getPrimitives().getStringValue(
    19681951                                                        tokens[1]).toUpperCase()));
    1969                         return Status.OK;
    19701952                } else if (tokens[0].equals("countcharsinstr")) {
    19711953                        assertExactParametreCount(tokens, 3);
     
    19741956                        int count = countCharsInString(s, pattern);
    19751957                        context.getPrimitives().setValue(tokens[3], new SInteger(count));
    1976                         return Status.OK;
    19771958                } else if (tokens[0].equals("countcharsinitem")) {
    19781959                        assertExactParametreCount(tokens, 3);
     
    19851966                                count = countCharsInString(((Text) item).getText(), pattern);
    19861967                        context.getPrimitives().setValue(tokens[3], new SInteger(count));
    1987                         return Status.OK;
    19881968                } else if (tokens[0].equals("parseframename")) {
    19891969                        assertExactParametreCount(tokens, 4);
     
    20071987                        // assertPrimitiveType(tokens[4], 4);
    20081988                        context.getPrimitives().setValue(tokens[4], new SInteger(frameNo));
    2009 
    2010                         return Status.OK;
    20111989                } else if (tokens[0].equals("parsestr")) {
    20121990                        assertMinParametreCount(tokens, 2);
     
    20562034                                }
    20572035                        }
    2058                         return Status.OK;
    20592036                } else if (tokens[0].equals("stripstr")) {
    20602037                        assertExactParametreCount(tokens, 2);
     
    20652042                                s = s.replaceAll(charsToStrip.substring(i, i + 1), "");
    20662043                        context.getPrimitives().setValue(tokens[1], new SString(s));
    2067                         return Status.OK;
    20682044                } else if (tokens[0].equals("subststr")) {
    20692045                        assertExactParametreCount(tokens, 3);
     
    20752051                        result = result.replaceAll(oldString, newString);
    20762052                        context.getPrimitives().setValue(tokens[1], new SString(result));
    2077                         return Status.OK;
    20782053                } else if (tokens[0].equals("substr")) {
    20792054                        assertExactParametreCount(tokens, 4);
     
    20892064                                result = s.substring(startPos);
    20902065                        context.getPrimitives().setValue(tokens[4], new SString(result));
    2091                         return Status.OK;
    20922066                } else if (tokens[0].equals("pause")) {
    20932067                        String lengthVar = DEFAULT_REAL;
     
    20992073
    21002074                        pause(context.getPrimitives().getDoubleValue(lengthVar));
    2101                         return Status.OK;
    21022075                } else if (tokens[0].equals("glidecursorto")) {
    21032076                        assertMinParametreCount(tokens, 2);
     
    21312104                        Thread.sleep(milliseconds % timeInterval);
    21322105                        DisplayIO.setCursorPosition(finalX, finalY);
    2133                         return Status.OK;
    21342106                } else if (tokens[0].equals("glideitemto")) {
    21352107                        assertMinParametreCount(tokens, 3);
     
    21792151                        FrameGraphics.Repaint();
    21802152                        // FrameMouseActions.updateCursor();
    2181                         return Status.OK;
    21822153                }
    21832154                // Now look for fixed parametre statements
    2184                 else if (tokens.length == 1) {
    2185                         if (tokens[0].equals(EXIT_TEXT)) {
    2186                                 return Status.Exit;
    2187                         } else if (tokens[0].equals(LOOP_TEXT)) {
    2188                                 Status status = Status.OK;
    2189                                 // Keep looping until break or exit occurs
    2190                                 while (status == Status.OK || status == Status.Continue)
    2191                                         status = RunFrameAndReportError(code, context);
    2192                                 if (status == Status.Continue || status == Status.Break)
    2193                                         status = Status.OK;
    2194                                 return status;
    2195                         } else if (tokens[0].equals(CONTINUE_TEXT)
    2196                                         || tokens[0].equals(CONTINUE2_TEXT)) {
    2197                                 return Status.Continue;
    2198                         } else if (tokens[0].equals(BREAK_TEXT)
    2199                                         || tokens[0].equals(BREAK2_TEXT)) {
    2200                                 return Status.Break;
    2201                         } else if (tokens[0].equals(RETURN_TEXT)) {
    2202                                 return Status.Return;
    2203                         } else if (tokens[0].equals("pressleftbutton")) {
    2204                                 DisplayIO.pressMouse(InputEvent.BUTTON1_MASK);
    2205                                 return Status.OK;
    2206                         } else if (tokens[0].equals("pressmiddlebutton")) {
    2207                                 DisplayIO.pressMouse(InputEvent.BUTTON2_MASK);
    2208                                 return Status.OK;
    2209                         } else if (tokens[0].equals("pressrightbutton")) {
    2210                                 DisplayIO.pressMouse(InputEvent.BUTTON3_MASK);
    2211                                 return Status.OK;
    2212                         } else if (tokens[0].equals("releaseleftbutton")) {
    2213                                 DisplayIO.releaseMouse(InputEvent.BUTTON1_MASK);
    2214                                 return Status.OK;
    2215                         } else if (tokens[0].equals("releasemiddlebutton")) {
    2216                                 DisplayIO.releaseMouse(InputEvent.BUTTON2_MASK);
    2217                                 return Status.OK;
    2218                         } else if (tokens[0].equals("releaserightbutton")) {
    2219                                 DisplayIO.releaseMouse(InputEvent.BUTTON3_MASK);
    2220                                 return Status.OK;
    2221                         } else if (tokens[0].equals("clickleftbutton")) {
    2222                                 DisplayIO.clickMouse(InputEvent.BUTTON1_MASK);
    2223                                 return Status.OK;
    2224                         } else if (tokens[0].equals("clickmiddlebutton")) {
    2225                                 DisplayIO.clickMouse(InputEvent.BUTTON2_MASK);
    2226                                 return Status.OK;
    2227                         } else if (tokens[0].equals("clickrightbutton")) {
    2228                                 DisplayIO.clickMouse(InputEvent.BUTTON3_MASK);
    2229                                 return Status.OK;
    2230                         } else if (tokens[0].equals("repaint")) {
    2231                                 FrameGraphics.Repaint();
    2232                                 return Status.OK;
    2233                         }
    2234 
    2235                         if (tokens[0].equals("add")) {
     2155                else if (tokens[0].equals(EXIT_TEXT)) {
     2156                        return Status.Exit;
     2157                } else if (tokens[0].equals(LOOP_TEXT)) {
     2158                        Status status = Status.OK;
     2159                        // Keep looping until break or exit occurs
     2160                        while (status == Status.OK || status == Status.Continue) {
     2161                                status = RunFrameAndReportError(code, context);
     2162                                pause(code);
     2163                        }
     2164                        if (status == Status.Continue || status == Status.Break)
     2165                                status = Status.OK;
     2166                        return status;
     2167                } else if (tokens[0].equals(CONTINUE_TEXT)
     2168                                || tokens[0].equals(CONTINUE2_TEXT)) {
     2169                        return Status.Continue;
     2170                } else if (tokens[0].equals(BREAK_TEXT)
     2171                                || tokens[0].equals(BREAK2_TEXT)) {
     2172                        return Status.Break;
     2173                } else if (tokens[0].equals(RETURN_TEXT)) {
     2174                        return Status.Return;
     2175                } else if (tokens[0].equals("pressleftbutton")) {
     2176                        assertExactParametreCount(tokens, 0);
     2177                        DisplayIO.pressMouse(InputEvent.BUTTON1_MASK);
     2178                } else if (tokens[0].equals("pressmiddlebutton")) {
     2179                        assertExactParametreCount(tokens, 0);
     2180                        DisplayIO.pressMouse(InputEvent.BUTTON2_MASK);
     2181                } else if (tokens[0].equals("pressrightbutton")) {
     2182                        assertExactParametreCount(tokens, 0);
     2183                        DisplayIO.pressMouse(InputEvent.BUTTON3_MASK);
     2184                } else if (tokens[0].equals("releaseleftbutton")) {
     2185                        assertExactParametreCount(tokens, 0);
     2186                        DisplayIO.releaseMouse(InputEvent.BUTTON1_MASK);
     2187                } else if (tokens[0].equals("releasemiddlebutton")) {
     2188                        assertExactParametreCount(tokens, 0);
     2189                        DisplayIO.releaseMouse(InputEvent.BUTTON2_MASK);
     2190                } else if (tokens[0].equals("releaserightbutton")) {
     2191                        assertExactParametreCount(tokens, 0);
     2192                        DisplayIO.releaseMouse(InputEvent.BUTTON3_MASK);
     2193                } else if (tokens[0].equals("clickleftbutton")) {
     2194                        assertExactParametreCount(tokens, 0);
     2195                        DisplayIO.clickMouse(InputEvent.BUTTON1_MASK);
     2196                } else if (tokens[0].equals("clickmiddlebutton")) {
     2197                        assertExactParametreCount(tokens, 0);
     2198                        DisplayIO.clickMouse(InputEvent.BUTTON2_MASK);
     2199                } else if (tokens[0].equals("clickrightbutton")) {
     2200                        assertExactParametreCount(tokens, 0);
     2201                        DisplayIO.clickMouse(InputEvent.BUTTON3_MASK);
     2202                } else if (tokens[0].equals("repaint")) {
     2203                        assertExactParametreCount(tokens, 0);
     2204                        FrameGraphics.Repaint();
     2205                } else if (tokens[0].equals("add")) {
     2206                        assertMaxParametreCount(tokens, 3);
     2207                        switch (tokens.length) {
     2208                        case 1:
    22362209                                context.getPrimitives().add(DEFAULT_INTEGER);
    2237                         } else if (tokens[0].equals("subtract")) {
     2210                                break;
     2211                        case 2:
     2212                                context.getPrimitives().add(tokens[1]);
     2213                                break;
     2214                        case 3:
     2215                                context.getPrimitives().add(tokens[2], tokens[1]);
     2216                                break;
     2217                        case 4:
     2218                                context.getPrimitives().add(tokens[1], tokens[2], tokens[3]);
     2219                                break;
     2220                        default:
     2221                                assert (false);
     2222                        }
     2223                } else if (tokens[0].equals("subtract")) {
     2224                        assertMaxParametreCount(tokens, 3);
     2225                        switch (tokens.length) {
     2226                        case 1:
    22382227                                context.getPrimitives().subtract(DEFAULT_INTEGER);
    2239                         } else
    2240                                 throw new RuntimeException("Invalid statement:");
    2241                         return Status.OK;
    2242                 } else if (tokens.length == 2) {
    2243                         if (tokens[0].equals("closewritefile")) {
    2244                                 assertVariableType(tokens[1], 1, SPointer.filePrefix);
    2245                                 context.closeWriteFile(tokens[1]);
    2246 
    2247                                 return Status.OK;
    2248                         } else if (tokens[0].equals("closereadfile")) {
    2249                                 assertVariableType(tokens[1], 1, SPointer.filePrefix);
    2250                                 context.closeReadFile(tokens[1]);
    2251 
    2252                                 return Status.OK;
    2253                         }
    2254 
    2255                         if (Primitives.isPrimitive(tokens[1])) {
    2256                                 if (tokens[0].equals("add")) {
    2257                                         context.getPrimitives().add(tokens[1]);
    2258                                 } else if (tokens[0].equals("subtract")) {
    2259                                         context.getPrimitives().subtract(tokens[1]);
    2260                                 } else
    2261                                         throw new RuntimeException("Invalid statement:");
    2262                                 return Status.OK;
    2263                         }
    2264                 } else if (tokens.length == 3) {
    2265                         if (tokens[0].startsWith("foreach")) {
    2266                                 Class itemType = Object.class;
    2267                                 String type = tokens[0].substring("foreach".length());
    2268                                 // Check the type of foreach loop
    2269                                 // and set the item type to iterate over
    2270                                 if (type.equals("dot")) {
    2271                                         itemType = Dot.class;
    2272                                 } else if (type.equals("text")) {
    2273                                         itemType = Text.class;
    2274                                 } else if (type.equals("line")) {
    2275                                         itemType = Line.class;
    2276                                 }
    2277 
    2278                                 assertVariableType(tokens[2], 2, SPointer.itemPrefix);
    2279                                 assertVariableType(tokens[1], 1, SPointer.framePrefix);
    2280                                 Frame currFrame = (Frame) context.getPointers().getVariable(
    2281                                                 tokens[1]).getValue();
    2282                                 // Create the ip variable
    2283                                 Item frameTitle = currFrame.getTitleItem();
    2284 
    2285                                 for (Item i : currFrame.getItems()) {
    2286                                         if (i == frameTitle)
    2287                                                 continue;
    2288                                         if (!(itemType.isInstance(i)))
    2289                                                 continue;
    2290 
    2291                                         context.getPointers().setObject(tokens[2], i);
    2292                                         Status status = RunFrameAndReportError(code, context);
    2293                                         // check if we need to exit this loop because of
    2294                                         // statements in the code that was run
    2295                                         if (status == Status.Exit || status == Status.Return)
    2296                                                 return status;
    2297                                         else if (status == Status.Break)
    2298                                                 return Status.OK;
    2299                                 }
    2300                                 return Status.OK;
    2301                         }
    2302 
    2303                         if (Primitives.isPrimitive(tokens[1])
    2304                                         && Primitives.isPrimitive(tokens[2])) {
    2305                                 if (tokens[0].equals("movecursorto")) {
    2306                                         assertExactParametreCount(tokens, 2);
    2307                                         int x = (int) context.getPrimitives().getIntegerValue(
    2308                                                         tokens[1]);
    2309                                         int y = (int) context.getPrimitives().getIntegerValue(
    2310                                                         tokens[2]);
    2311                                         DisplayIO.setCursorPosition(x, y);
    2312                                         return Status.OK;
    2313                                 } else if (tokens[0].equals("not")) {
    2314                                         context.getPrimitives().not(tokens[1], tokens[2]);
    2315                                 } else if (tokens[0].equals("exp")) {
    2316                                         context.getPrimitives().exp(tokens[1], tokens[2]);
    2317                                 } else if (tokens[0].equals("log")) {
    2318                                         context.getPrimitives().log(tokens[2], tokens[2]);
    2319                                 } else if (tokens[0].equals("log10")) {
    2320                                         context.getPrimitives().log10(tokens[1], tokens[2]);
    2321                                 } else if (tokens[0].equals("sqrt")) {
    2322                                         context.getPrimitives().sqrt(tokens[1], tokens[2]);
    2323                                 } else if (tokens[0].equals("add")) {
    2324                                         context.getPrimitives().add(tokens[2], tokens[1]);
    2325                                 } else if (tokens[0].equals("subtract")) {
    2326                                         context.getPrimitives().subtract(tokens[2], tokens[1]);
    2327                                 } else if (tokens[0].equals("multiply")) {
    2328                                         context.getPrimitives().multiply(tokens[2], tokens[1]);
    2329                                 } else if (tokens[0].equals("divide")) {
    2330                                         context.getPrimitives().divide(tokens[2], tokens[1]);
    2331                                 } else
    2332                                         throw new RuntimeException("Invalid statement:");
    2333                                 return Status.OK;
    2334                         }
    2335                 } else if (tokens.length == 4) {
     2228                                break;
     2229                        case 2:
     2230                                context.getPrimitives().subtract(tokens[1]);
     2231                                break;
     2232                        case 3:
     2233                                context.getPrimitives().subtract(tokens[2], tokens[1]);
     2234                                break;
     2235                        case 4:
     2236                                context.getPrimitives().subtract(tokens[1], tokens[2],
     2237                                                tokens[3]);
     2238                                break;
     2239                        default:
     2240                                assert (false);
     2241                        }
     2242                } else if (tokens[0].equals("multiply")) {
     2243                        assertMinParametreCount(tokens, 2);
     2244                        assertMaxParametreCount(tokens, 3);
     2245                        switch (tokens.length) {
     2246                        case 3:
     2247                                context.getPrimitives().multiply(tokens[2], tokens[1]);
     2248                                break;
     2249                        case 4:
     2250                                context.getPrimitives().multiply(tokens[1], tokens[2],
     2251                                                tokens[3]);
     2252                                break;
     2253                        default:
     2254                                assert (false);
     2255                        }
     2256                } else if (tokens[0].equals("divide")) {
     2257                        assertMinParametreCount(tokens, 2);
     2258                        assertMaxParametreCount(tokens, 3);
     2259                        switch (tokens.length) {
     2260                        case 3:
     2261                                context.getPrimitives().divide(tokens[2], tokens[1]);
     2262                                break;
     2263                        case 4:
     2264                                context.getPrimitives().divide(tokens[1], tokens[2], tokens[3]);
     2265                                break;
     2266                        default:
     2267                                assert (false);
     2268                        }
     2269                } else if (tokens[0].equals("modulo")) {
     2270                        assertExactParametreCount(tokens, 3);
     2271                        context.getPrimitives().modulo(tokens[1], tokens[2], tokens[3]);
     2272                } else if (tokens[0].equals("power")) {
     2273                        assertExactParametreCount(tokens, 3);
     2274                        context.getPrimitives().power(tokens[1], tokens[2], tokens[3]);
     2275                } else if (tokens[0].equals("not")) {
     2276                        assertExactParametreCount(tokens, 2);
     2277                        context.getPrimitives().not(tokens[1], tokens[2]);
     2278                } else if (tokens[0].equals("exp")) {
     2279                        assertExactParametreCount(tokens, 2);
     2280                        context.getPrimitives().exp(tokens[1], tokens[2]);
     2281                } else if (tokens[0].equals("log")) {
     2282                        assertExactParametreCount(tokens, 2);
     2283                        context.getPrimitives().log(tokens[2], tokens[2]);
     2284                } else if (tokens[0].equals("log10")) {
     2285                        assertExactParametreCount(tokens, 2);
     2286                        context.getPrimitives().log10(tokens[1], tokens[2]);
     2287                } else if (tokens[0].equals("sqrt")) {
     2288                        assertExactParametreCount(tokens, 2);
     2289                        context.getPrimitives().sqrt(tokens[1], tokens[2]);
     2290                } else if (tokens[0].equals("closewritefile")) {
     2291                        assertVariableType(tokens[1], 1, SPointer.filePrefix);
     2292                        context.closeWriteFile(tokens[1]);
     2293                } else if (tokens[0].equals("closereadfile")) {
     2294                        assertVariableType(tokens[1], 1, SPointer.filePrefix);
     2295                        context.closeReadFile(tokens[1]);
     2296                } else if (tokens[0].startsWith("foreach")) {
    23362297                        if (tokens[0].equals("foreachassociation")) {
    23372298                                assertExactParametreCount(tokens, 3);
     
    23452306                                        context.getPrimitives().setValue(tokens[3], value);
    23462307                                        Status status = RunFrameAndReportError(code, context);
     2308                                        pause(code);
     2309                                        // check if we need to exit this loop because of
     2310                                        // statements in the code that was run
     2311                                        if (status == Status.Exit || status == Status.Return)
     2312                                                return status;
     2313                                        else if (status == Status.Break)
     2314                                                break;
     2315                                }
     2316                        } else {
     2317                                Class itemType = Object.class;
     2318                                String type = tokens[0].substring("foreach".length());
     2319                                // Check the type of foreach loop
     2320                                // and set the item type to iterate over
     2321                                if (type.equals("dot")) {
     2322                                        itemType = Dot.class;
     2323                                } else if (type.equals("text")) {
     2324                                        itemType = Text.class;
     2325                                } else if (type.equals("line")) {
     2326                                        itemType = Line.class;
     2327                                } else if (type.equals("item") || type.equals("")) {
     2328                                        itemType = Object.class;
     2329                                } else {
     2330                                        throw new RuntimeException("Invalid ForEach loop type");
     2331                                }
     2332
     2333                                assertVariableType(tokens[2], 2, SPointer.itemPrefix);
     2334                                assertVariableType(tokens[1], 1, SPointer.framePrefix);
     2335                                Frame currFrame = (Frame) context.getPointers().getVariable(
     2336                                                tokens[1]).getValue();
     2337                                // Create the ip variable
     2338                                Item frameTitle = currFrame.getTitleItem();
     2339
     2340                                for (Item i : currFrame.getItems()) {
     2341                                        if (i == frameTitle)
     2342                                                continue;
     2343                                        if (!(itemType.isInstance(i)))
     2344                                                continue;
     2345
     2346                                        context.getPointers().setObject(tokens[2], i);
     2347                                        Status status = RunFrameAndReportError(code, context);
     2348                                        pause(code);
    23472349                                        // check if we need to exit this loop because of
    23482350                                        // statements in the code that was run
     
    23522354                                                return Status.OK;
    23532355                                }
    2354                                 return Status.OK;
    2355                         }
    2356 
    2357                         if (Primitives.isPrimitive(tokens[1])
    2358                                         && Primitives.isPrimitive(tokens[2])
    2359                                         && Primitives.isPrimitive(tokens[3])) {
    2360                                 if (tokens[0].equals("add")) {
    2361                                         context.getPrimitives()
    2362                                                         .add(tokens[1], tokens[2], tokens[3]);
    2363                                 } else if (tokens[0].equals("subtract")) {
    2364                                         context.getPrimitives().subtract(tokens[1], tokens[2],
    2365                                                         tokens[3]);
    2366                                 } else if (tokens[0].equals("divide")) {
    2367                                         context.getPrimitives().divide(tokens[1], tokens[2],
    2368                                                         tokens[3]);
    2369                                 } else if (tokens[0].equals("multiply")) {
    2370                                         context.getPrimitives().multiply(tokens[1], tokens[2],
    2371                                                         tokens[3]);
    2372                                 } else if (tokens[0].equals("modulo")) {
    2373                                         context.getPrimitives().modulo(tokens[1], tokens[2],
    2374                                                         tokens[3]);
    2375                                 } else if (tokens[0].equals("power")) {
    2376                                         context.getPrimitives().power(tokens[1], tokens[2],
    2377                                                         tokens[3]);
    2378                                 } else
    2379                                         throw new Exception("Statement not found: " + tokens[0]
    2380                                                         + " in " + code.toString());
    2381                                 return Status.OK;
    2382                         }
     2356                        }
     2357                } else if (tokens[0].equals("movecursorto")) {
     2358                        assertExactParametreCount(tokens, 2);
     2359                        int x = (int) context.getPrimitives().getIntegerValue(tokens[1]);
     2360                        int y = (int) context.getPrimitives().getIntegerValue(tokens[2]);
     2361                        DisplayIO.setCursorPosition(x, y);
     2362                } else {
     2363                        throw new RuntimeException("Unknown statement");
    23832364                }
    2384                 throw new RuntimeException("Unknown statement: ");
    2385         }
    2386 
    2387         private static void pause(double time) throws Exception {
    2388                 for (int i = 0; i < time * 10; i++) {
    2389                         Thread.yield();
    2390                         Thread.sleep(100);
    2391                 }
     2365                return Status.OK;
    23922366        }
    23932367
     
    24262400                if (tokens.length - 1 != parametreCount)
    24272401                        throw new IncorrectParametreCountException(parametreCount);
     2402        }
     2403
     2404        public static void assertMaxParametreCount(String[] tokens,
     2405                        int parametreCount) throws Exception {
     2406                if (tokens.length - 1 > parametreCount)
     2407                        throw new AboveMaxParametreCountException(parametreCount);
    24282408        }
    24292409
     
    24562436                _nextStatement = true;
    24572437        }
     2438
     2439        public static void ProgramStarted() {
     2440                _programsRunning++;
     2441                AgentStats.reset();
     2442                FrameGraphics.DisplayMessage("Running SimpleProgram...", Color.BLUE);
     2443        }
    24582444}
  • trunk/src/org/expeditee/gui/Frame.java

    r86 r87  
    4646        private String _frameset = null;
    4747
     48        private boolean _throwsException = false;
     49       
    4850        private int _number = -1;
    4951
     
    344346                for (Item i : items) {
    345347                        if (i instanceof Text && i.getX() < UserSettings.TitlePosition
    346                                         && i.getY() < UserSettings.TitlePosition && i.getY() > 0)
     348                                        && i.getY() < UserSettings.TitlePosition /*&& i.getY() > 0*/)
    347349                                return (Text) i;
    348350                }
     
    16581660                return 1 + (backup == null ? 0 : backup.getCometLength());
    16591661        }
     1662
     1663        public void setThrowsException(boolean b) {
     1664                _throwsException = b;
     1665        }
     1666       
     1667        public boolean getThrowsException() {
     1668                return _throwsException;
     1669        }
    16601670}
  • trunk/src/org/expeditee/gui/FrameKeyboardActions.java

    r86 r87  
    1515
    1616import org.expeditee.actions.Actions;
     17import org.expeditee.actions.Misc;
    1718import org.expeditee.actions.NavigationActions;
    1819import org.expeditee.actions.Simple;
     
    3435                                        || (e.isControlDown() && e.getKeyChar() == KeyEvent.VK_C)) {
    3536                                Simple.stop();
    36                         }else if (e.isControlDown() && e.getKeyChar() == KeyEvent.VK_SPACE){
     37                        } else if (e.isControlDown() && e.getKeyChar() == KeyEvent.VK_SPACE) {
    3738                                Simple.nextStatement();
    3839                        }
    39                        
     40
    4041                        Simple.KeyStroke(e.getKeyChar());
    41                        
     42
    4243                        if (Simple.consumeKeyboardInput())
    4344                                return;
     
    6768
    6869                if (e.isAltDown()) {
    69                         if (FrameUtils.getCurrentItem() == null
    70                                         && !Frame.itemAttachedToCursor()) {
    71                                 Item t = DisplayIO.getCurrentFrame().createNewText(ch + ": ");
    72                                 FrameMouseActions.pickup(t);
    73                                 FrameGraphics.Repaint();
    74                         } else {
    75                                 // remove the link for alt+l
    76                                 if (ch == 'l') {
    77                                         Item current = FrameUtils.getCurrentItem();
    78                                         // If its not linked then link it to its self
    79                                         if (current instanceof Text && current.getLink() == null) {
    80                                                 String text = ((Text) current).getText();
    81                                                 if (FrameIO.isValidFrameName(text)) {
    82                                                         current.setLink(text);
    83                                                 } else if (FrameIO.isValidFramesetName(text)) {
    84                                                         current.setLink(text + '1');
    85                                                 }
    86                                         } else {
    87                                                 // If its linked remove the link
    88                                                 current.setLink(null);
    89                                         }
    90                                         FrameGraphics.Repaint();
    91                                 } else if (ch == 'a') {
    92                                         Item current = FrameUtils.getCurrentItem();
    93                                         // If its not linked then link it to its self
    94                                         if (current instanceof Text && current.getAction() == null) {
    95                                                 String text = ((Text) current).getText().trim();
    96                                                 if (text.startsWith("a:")) {
    97                                                         text = text.substring(2).trim();
    98                                                 } else if (text.startsWith("@")) {
    99                                                         text = text.substring(1).trim();
    100                                                 }
    101                                                 current.setAction(text);
    102                                         } else {
    103                                                 // If its linked remove the link
    104                                                 current.setActions(null);
    105                                         }
    106                                         FrameGraphics.Repaint();
    107                                 }
    108                         }
     70
    10971                } else {
    11072                        processChar(ch, e.isShiftDown());
     
    311273
    312274        private void navigateFrame(int direction) {
    313                 DisplayIO.setCursor(Item.DEFAULT_CURSOR);
    314275                switch (direction) {
    315276                case Text.RIGHT:
     
    348309                                Actions.interruptAgent();
    349310                        return;
    350                 } else if (Simple.isProgramRunning()) {
     311                } else if (Simple.consumeKeyboardInput()) {
    351312                        return;
    352313                }
     
    517478                if (ch.length() > 1)
    518479                        return;
    519 
    520                 // if this is a paste command
    521                 if (ch.charAt(0) == KeyEvent.VK_V) {
     480                Logger.Log(Logger.USER, Logger.CONTROL_CHAR, "User pressing: Ctrl+"
     481                                + ch);
     482                //
     483                // if (FrameUtils.getCurrentItem() == null
     484                // && !Frame.itemAttachedToCursor()) {
     485                // Item t = DisplayIO.getCurrentFrame().createNewText(ch + ": ");
     486                // FrameMouseActions.pickup(t);
     487                // } else {
     488                // remove the link for alt+l
     489                Item current = FrameUtils.getCurrentItem();
     490                Frame currentFrame = DisplayIO.getCurrentFrame();
     491                //Link or delink an item
     492                if (ch.charAt(0) ==  KeyEvent.VK_L) {
     493                        // If its not linked then link it to its self
     494                        if (current instanceof Text && current.getLink() == null) {
     495                                String text = ((Text) current).getText();
     496                                if (FrameIO.isValidFrameName(text)) {
     497                                        current.setLink(text);
     498                                } else if (FrameIO.isValidFramesetName(text)) {
     499                                        current.setLink(text + '1');
     500                                }
     501                        } else {
     502                                // If its linked remove the link
     503                                current.setLink(null);
     504                        }
     505                } else if (ch.charAt(0) ==  KeyEvent.VK_G) {
     506                        // If its not linked then link it to its self
     507                        if (current instanceof Text) {
     508                                String text = ((Text) current).getText();
     509                                if (FrameIO.isValidFrameName(text)) {
     510                                        current.setLink(text);
     511                                } else if (FrameIO.isValidFramesetName(text)) {
     512                                        current.setLink(text + '1');
     513                                }
     514                        }
     515                        if (current.getLink() != null){
     516                                NavigationActions.Goto(current.getAbsoluteLink());
     517                                return;
     518                        }
     519                } else if (ch.charAt(0) ==  KeyEvent.VK_A) {
     520                        // If its not linked then link it to its self
     521                        if (current instanceof Text && current.getAction() == null) {
     522                                String text = ((Text) current).getText().trim();
     523                                if (text.startsWith("a:")) {
     524                                        text = text.substring(2).trim();
     525                                } else if (text.startsWith("@")) {
     526                                        text = text.substring(1).trim();
     527                                }
     528                                current.setAction(text);
     529                        } else {
     530                                // If its linked remove the link
     531                                current.setActions(null);
     532                        }
     533                } else if (ch.charAt(0) == KeyEvent.VK_V) {
    522534                        try {
    523535                                // read in the data from the clipboard
     
    568580                                        addTextItemToCurrentFrame(temp, y);
    569581                                }
    570 
    571                                 FrameGraphics.Repaint();
    572582                        } catch (Exception ex) {
    573583                        }
    574                         return;
    575 
    576584                        // if this is a copy command
    577585                } else if (ch.charAt(0) == KeyEvent.VK_C) {
     
    603611                        Toolkit.getDefaultToolkit().getSystemClipboard().setContents(
    604612                                        selection, null);
    605 
    606613                        FrameGraphics.DisplayMessage("Item copied to clipboard");
    607614                        return;
     
    609616                        // perform a delete operation
    610617                        processChar((char) KeyEvent.VK_DELETE, e.isShiftDown());
    611                         FrameGraphics.Repaint();
     618                        FrameMouseActions.delete(current);
     619                }else if (ch.charAt(0) == KeyEvent.VK_F) {
     620                        // perform a delete operation
     621                        Actions.PerformAction(currentFrame, null, "Format");
     622                        return;
    612623                } else if (ch.charAt(0) == KeyEvent.VK_J) {
    613624
     
    621632
    622633                        text.setJustification(Item.JUSTIFICATION_LEFT);
    623 
    624                         FrameGraphics.Repaint();
    625                         return;
    626634                } else if (ch.charAt(0) == KeyEvent.VK_S) {
    627635                        // split the current text item
     
    641649                                y += newText.getBoundsHeight();
    642650                                newText.setY(y);
    643 
    644                                 Frame current = DisplayIO.getCurrentFrame();
    645651                                // update the items ID to prevent conflicts with the current
    646652                                // frame
    647                                 newText.setID(current.getNextItemID());
    648 
    649                                 current.addItem(newText);
    650                         }
     653                                newText.setID(currentFrame.getNextItemID());
     654                                currentFrame.addItem(newText);
     655                        }
     656                }
    651657                        FrameGraphics.Repaint();
    652 
    653                         return;
    654                 }
    655 
    656                 Logger.Log(Logger.USER, Logger.CONTROL_CHAR, "User pressing: Ctrl+"
    657                                 + ch);
    658658        }
    659659
  • trunk/src/org/expeditee/gui/FrameMouseActions.java

    r86 r87  
    16761676        }
    16771677
    1678         private static void delete(Item toDelete) {
     1678        public static void delete(Item toDelete) {
    16791679                FrameUtils.LastEdited = null;
    16801680                _offX = _offY = 0;
     
    20112011                                        }
    20122012                                } else {
    2013                                         if (mergee instanceof Dot || mergee instanceof Text) {
     2013                                        if (mergee.isLineEnd()) {
    20142014                                                DisplayIO.setCursorPosition(mergee.getPosition());
    20152015                                        }
  • trunk/src/org/expeditee/gui/FrameUtils.java

    r86 r87  
    383383                Parse(toDisplay);
    384384                DisplayIO.setCurrentFrame(toDisplay);
    385 
     385                FrameMouseActions.updateCursor();
    386386                // update response timer
    387387                _LastResponse = ResponseTimer.getElapsedSeconds();
  • trunk/src/org/expeditee/items/Item.java

    r86 r87  
    10111011        public void run() {
    10121012                try {
    1013                         AgentStats.reset();
    1014                         FrameGraphics
    1015                                         .DisplayMessage("Running SimpleProgram...", Color.BLUE);
     1013                        Simple.ProgramStarted();
    10161014                        Simple.RunFrameAndReportError(this, new Context());
    10171015                        Simple.ProgramFinished();
  • trunk/src/org/expeditee/items/Text.java

    r86 r87  
    15111511
    15121512                if (merger.isLineEnd()) {
     1513                        //Merging line ends onto non line end text is a no-op
     1514                        if(!isLineEnd())
     1515                                return null;
     1516                       
    15131517                        if (merger instanceof Text)
    15141518                                insertText(((Text) merger).getText(), mouseX, mouseY);
  • trunk/src/org/expeditee/simple/Primitives.java

    r80 r87  
    4949         *             if the variable name is invalid
    5050         */
    51         public void add(String name, SPrimitive value) throws IncorrectTypeException {
     51        public void add(String name, SPrimitive value)
     52                        throws IncorrectTypeException {
    5253                // figure out the type and add it...
    5354                SPrimitive newVar;
     
    159160        /**
    160161         * Increments a variable.
    161          * @param var the name of the variable to increment
     162         *
     163         * @param var
     164         *            the name of the variable to increment
    162165         * @throws Exception
    163166         */
     
    168171        /**
    169172         * Decrements a variable.
    170          * @param var the name of the variable to decrement
     173         *
     174         * @param var
     175         *            the name of the variable to decrement
    171176         * @throws Exception
    172177         */
  • trunk/tests/org/expeditee/actions/SimpleTest.java

    r80 r87  
    7676                try {
    7777                        runSimpleTest("SimpleTest10");
    78                         assertTrue(context.getPrimitives().getIntegerValue("$i.1") == 24);
    79                         assertTrue(context.getPrimitives().getIntegerValue("$i.2") == 42);
     78                        assertEquals(24,context.getPrimitives().getIntegerValue("$i.1"));
     79                        assertEquals(42,context.getPrimitives().getIntegerValue("$i.2"));
    8080
    8181                        runSimpleTest("SimpleTest11");
     
    120120                try {
    121121                        runSimpleTest("SimpleTest23");
    122                         assertEquals(context.getPrimitives().getIntegerValue("$i.Result"),
    123                                         243);
    124                         assertEquals(
    125                                         context.getPrimitives().getIntegerValue("$i.Exponent"), 0);
     122                        assertEquals(243,context.getPrimitives().getIntegerValue("$i.Result"));
     123                        assertEquals(0,context.getPrimitives().getIntegerValue("$i.Exponent"));
    126124
    127125                        runSimpleTest("SimpleTest30");
    128                         assertEquals(context.getPrimitives().getIntegerValue("$i.Result"),
    129                                         243);
    130                         assertEquals(
    131                                         context.getPrimitives().getIntegerValue("$i.Exponent"), 0);
     126                        assertEquals(243,context.getPrimitives().getIntegerValue("$i.Result"));
     127                        assertEquals(0,context.getPrimitives().getIntegerValue("$i.Exponent"));
    132128                } catch (Exception e) {
    133129                        System.out.println("EVALUATION ERROR: " + e.getMessage());
     
    193189        public void testSimpleTestSuite() {
    194190                try {
    195                         Simple.RunSimpleTests("SimpleTestSuite");
     191                        Simple.RunSimpleTests("SimpleTestSuite",true,false);
    196192                } catch (Exception e) {
    197193                        System.out.println("EVALUATION ERROR: " + e.getMessage());
Note: See TracChangeset for help on using the changeset viewer.