30 |
53 | );
54 | }
55 |
56 | private onLogoClick(): void {
57 | if (this.props.location.pathname !== "/editor") {
58 | this.props.history.push("/editor");
59 | }
60 | }
61 | }
62 |
63 | function mapStateToProps(_: AppState): PropsFromState {
64 | return {
65 | };
66 | }
67 |
68 | function mapDispatchToProps(_: Dispatch
31 |
36 |
37 | {this.props.sideBar ?
38 |
32 | {this.props.toolbar.map((item, i) =>
34 |
35 | {item}
)}
33 |
39 |
47 | :
48 |
40 | {this.props.masterContainer}
41 |
42 |
43 |
44 | {this.props.sideBar}
45 |
46 |
49 | {this.props.masterContainer}
50 |
51 | }
52 | this.editorDiv = div!}
41 | style={{ height: "100%", width: "100%" }} />;
42 | }
43 |
44 | public componentDidMount(): void {
45 | const options: monaco.editor.IEditorConstructionOptions = {
46 | language: "sb",
47 | scrollBeyondLastLine: false,
48 | readOnly: this.props.readOnly,
49 | value: this.props.initialValue,
50 | fontFamily: "Consolas, monospace, Hack",
51 | fontSize: 18,
52 | glyphMargin: true,
53 | minimap: {
54 | enabled: false
55 | }
56 | };
57 |
58 | this.editor = (window as any).monaco.editor.create(this.editorDiv, options);
59 |
60 | this.onResize = () => {
61 | this.editor!.layout();
62 | };
63 |
64 | window.addEventListener("resize", this.onResize);
65 | }
66 |
67 | public componentWillUnmount(): void {
68 | this.editor!.dispose();
69 | window.removeEventListener("resize", this.onResize!);
70 | }
71 |
72 | public undo(): void {
73 | this.editor!.trigger("", "undo", "");
74 | }
75 |
76 | public redo(): void {
77 | this.editor!.trigger("", "redo", "");
78 | }
79 |
80 | public setDiagnostics(diagnostics: ReadonlyArray): void {
81 | this.decorations = this.editor!.deltaDecorations(this.decorations, diagnostics.map(diagnostic => {
82 | return {
83 | range: EditorUtils.compilerRangeToEditorRange(diagnostic.range),
84 | options: {
85 | className: "wavy-line",
86 | glyphMarginClassName: "error-line-glyph"
87 | }
88 | };
89 | }));
90 | }
91 |
92 | public highlightLine(line: number): void {
93 | const range = EditorUtils.compilerRangeToEditorRange(CompilerRange.fromValues(line, 0, line, Number.MAX_VALUE));
94 |
95 | this.decorations = this.editor!.deltaDecorations(this.decorations, [{
96 | range: range,
97 | options: {
98 | className: "debugger-line-highlight"
99 | }
100 | }]);
101 |
102 | this.editor!.revealLine(range.startLineNumber);
103 | }
104 | }
105 |
--------------------------------------------------------------------------------
/src/compiler/services/completion-service.ts:
--------------------------------------------------------------------------------
1 | import { RuntimeLibraries } from "../runtime/libraries";
2 | import { CompilerPosition } from "../syntax/ranges";
3 | import { Compilation } from "../compilation";
4 | import { CompilerUtils } from "../utils/compiler-utils";
5 | import { SyntaxNodeVisitor, ObjectAccessExpressionSyntax, SyntaxKind, IdentifierExpressionSyntax } from "../syntax/syntax-nodes";
6 | import { CommandsParser } from "../syntax/command-parser";
7 |
8 | export module CompletionService {
9 | export enum ResultKind {
10 | Class,
11 | Method,
12 | Property
13 | }
14 |
15 | export interface Result {
16 | kind: ResultKind;
17 | title: string;
18 | description: string;
19 | }
20 |
21 | export function provideCompletion(compilation: Compilation, position: CompilerPosition): Result[] {
22 | const objectAccessExpression = compilation.getSyntaxNode(position, SyntaxKind.ObjectAccessExpression);
23 | if (objectAccessExpression) {
24 | const visitor = new CompletionVisitor();
25 | visitor.visit(objectAccessExpression);
26 | return visitor.results;
27 | }
28 |
29 | const identifierExpression = compilation.getSyntaxNode(position, SyntaxKind.IdentifierExpression);
30 | if (identifierExpression) {
31 | const visitor = new CompletionVisitor();
32 | visitor.visit(identifierExpression);
33 | return visitor.results;
34 | }
35 |
36 | return [];
37 | }
38 |
39 | class CompletionVisitor extends SyntaxNodeVisitor {
40 | private _allResults: Result[] = [];
41 |
42 | public get results(): Result[] {
43 | return this._allResults;
44 | }
45 |
46 | private addResult(result: Result): void {
47 | this._allResults.push(result);
48 | }
49 |
50 | public visitObjectAccessExpression(node: ObjectAccessExpressionSyntax): void {
51 | if (node.baseExpression.kind !== SyntaxKind.IdentifierExpression) {
52 | return;
53 | }
54 |
55 | const libraryName = (node.baseExpression as IdentifierExpressionSyntax).identifierToken.token.text;
56 | const library = RuntimeLibraries.Metadata[libraryName];
57 | if (!library) {
58 | return;
59 | }
60 |
61 | let memberName = node.identifierToken.token.text;
62 | if (memberName === CommandsParser.MissingTokenText) {
63 | memberName = "";
64 | }
65 |
66 | CompilerUtils.values(library.methods).forEach(method => {
67 | if (CompilerUtils.stringStartsWith(method.methodName, memberName)) {
68 | this.addResult({
69 | title: method.methodName,
70 | description: method.description,
71 | kind: ResultKind.Method
72 | });
73 | }
74 | });
75 |
76 | CompilerUtils.values(library.properties).forEach(property => {
77 | if (CompilerUtils.stringStartsWith(property.propertyName, memberName)) {
78 | this.addResult({
79 | title: property.propertyName,
80 | description: property.description,
81 | kind: ResultKind.Property
82 | });
83 | }
84 | });
85 | }
86 |
87 | public visitIdentifierExpression(node: IdentifierExpressionSyntax): void {
88 | const libraryName = node.identifierToken.token.text;
89 |
90 | CompilerUtils.values(RuntimeLibraries.Metadata).forEach(library => {
91 | if (CompilerUtils.stringStartsWith(library.typeName, libraryName)) {
92 | this.addResult({
93 | title: library.typeName,
94 | description: library.description,
95 | kind: ResultKind.Class
96 | });
97 | }
98 | });
99 | }
100 | }
101 | }
102 |
--------------------------------------------------------------------------------
/src/compiler/runtime/libraries/math.ts:
--------------------------------------------------------------------------------
1 | import { LibraryTypeInstance, LibraryMethodInstance, LibraryPropertyInstance, LibraryEventInstance } from "../libraries";
2 | import { BaseValue, ValueKind } from "../values/base-value";
3 | import { NumberValue } from "../values/number-value";
4 | import { ExecutionEngine, ExecutionMode, ExecutionState } from "../../execution-engine";
5 | import { CompilerRange } from "../../syntax/ranges";
6 | import { Diagnostic, ErrorCode } from "../../utils/diagnostics";
7 |
8 | export class MathLibrary implements LibraryTypeInstance {
9 | private getPi(): BaseValue {
10 | return new NumberValue(Math.PI);
11 | }
12 |
13 | private executeCalculation(engine: ExecutionEngine, calculation: (...values: number[]) => number): void {
14 | const args: number[] = new Array(calculation.length);
15 | for (let i = args.length - 1; i >= 0; i--) {
16 | const value = engine.popEvaluationStack().tryConvertToNumber();
17 |
18 | if (value.kind === ValueKind.Number) {
19 | args[i] = (value as NumberValue).value;
20 | } else {
21 | engine.pushEvaluationStack(new NumberValue(0));
22 | return;
23 | }
24 | }
25 |
26 | const result = calculation(...args);
27 | if (engine.state !== ExecutionState.Terminated) {
28 | engine.pushEvaluationStack(new NumberValue(result));
29 | }
30 | }
31 |
32 | private executeRemainder(engine: ExecutionEngine, _: ExecutionMode, range: CompilerRange): void {
33 | return this.executeCalculation(engine, (dividend, divisor) => {
34 | if (divisor === 0) {
35 | engine.terminate(new Diagnostic(ErrorCode.CannotDivideByZero, range));
36 | return 0;
37 | }
38 |
39 | return dividend % divisor;
40 | });
41 | }
42 |
43 | public readonly methods: { readonly [name: string]: LibraryMethodInstance } = {
44 | Abs: { execute: engine => this.executeCalculation(engine, Math.abs) },
45 | Remainder: { execute: this.executeRemainder.bind(this) },
46 |
47 | Cos: { execute: engine => this.executeCalculation(engine, Math.cos) },
48 | Sin: { execute: engine => this.executeCalculation(engine, Math.sin) },
49 | Tan: { execute: engine => this.executeCalculation(engine, Math.tan) },
50 |
51 | ArcCos: { execute: engine => this.executeCalculation(engine, Math.acos) },
52 | ArcSin: { execute: engine => this.executeCalculation(engine, Math.asin) },
53 | ArcTan: { execute: engine => this.executeCalculation(engine, Math.atan) },
54 |
55 | Ceiling: { execute: engine => this.executeCalculation(engine, Math.ceil) },
56 | Floor: { execute: engine => this.executeCalculation(engine, Math.floor) },
57 | Round: { execute: engine => this.executeCalculation(engine, Math.round) },
58 |
59 | GetDegrees: { execute: engine => this.executeCalculation(engine, angle => 180 * angle / Math.PI % 360) },
60 | GetRadians: { execute: engine => this.executeCalculation(engine, angle => angle % 360 * Math.PI / 180) },
61 |
62 | GetRandomNumber: { execute: engine => this.executeCalculation(engine, maxNumber => Math.floor(Math.random() * (Math.max(1, maxNumber) - 1)) + 1) },
63 |
64 | Log: { execute: engine => this.executeCalculation(engine, value => Math.log(value) / Math.LN10) },
65 | NaturalLog: { execute: engine => this.executeCalculation(engine, Math.log) },
66 |
67 | Max: { execute: engine => this.executeCalculation(engine, (value1, value2) => Math.max(value1, value2)) },
68 | Min: { execute: engine => this.executeCalculation(engine, (value1, value2) => Math.min(value1, value2)) },
69 |
70 | Power: { execute: engine => this.executeCalculation(engine, (baseNumber, exponent) => Math.pow(baseNumber, exponent)) },
71 | SquareRoot: { execute: engine => this.executeCalculation(engine, value => value < 0 ? 0 : Math.sqrt(value)) }
72 | };
73 |
74 | public readonly properties: { readonly [name: string]: LibraryPropertyInstance } = {
75 | Pi: { getter: this.getPi.bind(this) }
76 | };
77 |
78 | public readonly events: { readonly [name: string]: LibraryEventInstance } = {};
79 | }
80 |
--------------------------------------------------------------------------------
/src/app/components/run/index.tsx:
--------------------------------------------------------------------------------
1 | import { MasterLayoutComponent } from "../common/master-layout";
2 | import { ToolbarButton } from "../common/toolbar-button";
3 | import * as React from "react";
4 | import { EditorResources } from "../../../strings/editor";
5 | import { RouteComponentProps, withRouter } from "react-router";
6 | import { Compilation } from "../../../compiler/compilation";
7 | import { AppState } from "../../store";
8 | import { Dispatch, connect } from "react-redux";
9 | import { ExecutionMode, ExecutionEngine } from "../../../compiler/execution-engine";
10 | import { TextWindowComponent } from "../common/text-window/index";
11 | import { GraphicsWindowComponent } from "../common/graphics-window/index";
12 |
13 | const StopIcon = require("../../content/buttons/stop.png");
14 |
15 | interface PropsFromState {
16 | compilation: Compilation;
17 | appInsights: Microsoft.ApplicationInsights.IAppInsights;
18 | }
19 |
20 | interface PropsFromDispatch {
21 | }
22 |
23 | interface PropsFromReact {
24 | }
25 |
26 | type PresentationalComponentProps = PropsFromState & PropsFromDispatch & PropsFromReact & RouteComponentProps;
27 |
28 | interface PresentationalComponentState {
29 | engine: ExecutionEngine;
30 | }
31 |
32 | class PresentationalComponent extends React.Component {
33 | private isAlreadyMounted: boolean = false;
34 |
35 | public constructor(props: PresentationalComponentProps) {
36 | super(props);
37 |
38 | if (!this.props.compilation.isReadyToRun) {
39 | this.props.history.push("/editor");
40 | }
41 |
42 | this.state = {
43 | engine: new ExecutionEngine(this.props.compilation)
44 | };
45 | }
46 |
47 | public componentDidMount(): void {
48 | this.isAlreadyMounted = true;
49 | this.props.appInsights.trackPageView("RunPage");
50 | setTimeout(this.execute.bind(this));
51 | }
52 |
53 | public componentWillUnmount(): void {
54 | this.isAlreadyMounted = false;
55 | }
56 |
57 | private execute(): void {
58 | if (this.isAlreadyMounted) {
59 | this.state.engine.execute(ExecutionMode.RunToEnd);
60 | setTimeout(this.execute.bind(this));
61 | }
62 | }
63 |
64 | public render(): JSX.Element {
65 | return (
66 | this.props.history.push("/editor")} />
73 | ]}
74 | masterContainer={
75 | this.props.compilation.kind.drawsShapes
76 | ?
77 | ): PropsFromDispatch {
103 | return {
104 | };
105 | }
106 |
107 | export const RunComponent = connect(mapStateToProps, mapDispatchToProps)(withRouter(PresentationalComponent as any));
108 |
--------------------------------------------------------------------------------
/gulpfile.ts:
--------------------------------------------------------------------------------
1 | import * as fs from "fs";
2 | import * as gulp from "gulp";
3 | import * as path from "path";
4 | import * as helpers from "./build/gulp-helpers";
5 | import { generateLocStrings } from "./build/generate-loc-strings";
6 |
7 | const userLanguage = "en";
8 |
9 | gulp.task("generate-diagnostics-strings", () => generateLocStrings("DiagnosticsResources", path.resolve(__dirname, `./build/strings/${userLanguage}/diagnostics.json`), path.resolve(__dirname, `./src/strings/diagnostics.ts`)));
10 | gulp.task("generate-compiler-strings", () => generateLocStrings("CompilerResources", path.resolve(__dirname, `./build/strings/${userLanguage}/compiler.json`), path.resolve(__dirname, `./src/strings/compiler.ts`)));
11 | gulp.task("generate-documentation-strings", () => generateLocStrings("DocumentationResources", path.resolve(__dirname, `./build/strings/${userLanguage}/documentation.json`), path.resolve(__dirname, `./src/strings/documentation.ts`)));
12 | gulp.task("generate-app-editor-strings", () => generateLocStrings("EditorResources", path.resolve(__dirname, `./build/strings/${userLanguage}/editor.json`), path.resolve(__dirname, `./src/strings/editor.ts`)));
13 |
14 | gulp.task("generate-loc-strings", [
15 | "generate-diagnostics-strings",
16 | "generate-compiler-strings",
17 | "generate-documentation-strings",
18 | "generate-app-editor-strings",
19 | ]);
20 |
21 | gulp.task("build-source-debug", ["generate-loc-strings"], () => helpers.runWebpack({ projectPath: "./src/app/webpack.config.ts", release: false, watch: false }));
22 | gulp.task("build-source-release", ["generate-loc-strings"], () => helpers.runWebpack({ projectPath: "./src/app/webpack.config.ts", release: true, watch: false }));
23 |
24 | gulp.task("watch-source", () => {
25 | gulp.watch("build/**", ["generate-loc-strings"]);
26 | return helpers.runWebpack({
27 | projectPath: "./src/app/webpack.config.ts",
28 | release: false,
29 | watch: true
30 | });
31 | });
32 |
33 | gulp.task("build-tests-debug", () => helpers.runWebpack({ projectPath: "./tests/webpack.config.ts", release: false, watch: false }));
34 | gulp.task("run-tests-debug", ["build-tests-debug"], () => helpers.cmdToPromise("node", ["./node_modules/jasmine/bin/jasmine.js", "./out/tests/tests.js"]));
35 |
36 | gulp.task("build-tests-release", () => helpers.runWebpack({ projectPath: "./tests/webpack.config.ts", release: true, watch: false }));
37 | gulp.task("run-tests-release", ["build-tests-release"], () => helpers.cmdToPromise("node", ["./node_modules/jasmine/bin/jasmine.js", "./out/tests/tests.js"]));
38 |
39 | gulp.task("watch-tests", () => {
40 | gulp.watch("build/**", ["generate-loc-strings"]);
41 | gulp.watch(["src/**", "tests/**"], ["run-tests-debug"]);
42 | });
43 |
44 | function packageFunction(release: boolean): Promise {
45 | const setupConfigPath = "./out/electron/electron-builder-config.json";
46 | const electronBuilderPath = path.resolve(__dirname, "./node_modules/.bin/electron-builder.cmd");
47 |
48 | return helpers.rimrafToPromise("./out/electron")
49 | .then(() => helpers.runWebpack({
50 | projectPath: "./src/electron/webpack.config.ts",
51 | release: release,
52 | watch: false
53 | }))
54 | .then(() => helpers.streamToPromise(gulp.src("./out/app/**").pipe(gulp.dest("./out/electron"))))
55 | .then(() => helpers.streamToPromise(gulp.src("./package.json").pipe(gulp.dest("./out/electron"))))
56 | .then(() => helpers.rimrafToPromise("./out/installers"))
57 | .then(() => new Promise((resolve, reject) => {
58 | const config = {
59 | productName: "SmallBasic-Online",
60 | directories: {
61 | app: "./out/electron",
62 | output: "./out/installers"
63 | },
64 | win: {
65 | target: [
66 | { target: "nsis", arch: ["ia32"] }
67 | ],
68 | icon: "./src/electron/installer"
69 | }
70 | };
71 | fs.writeFile(setupConfigPath, JSON.stringify(config), "utf8", error => {
72 | if (error) {
73 | reject(error);
74 | } else {
75 | resolve();
76 | }
77 | });
78 | }))
79 | .then(() => helpers.cmdToPromise(electronBuilderPath, ["build", "--config", setupConfigPath, "--publish", "never"]));
80 | }
81 |
82 | gulp.task("package-debug", ["build-source-debug"], () => packageFunction(false));
83 | gulp.task("package-release", ["build-source-release"], () => packageFunction(true));
84 |
--------------------------------------------------------------------------------
/src/compiler/compilation.ts:
--------------------------------------------------------------------------------
1 | import { ModuleEmitter } from "./emitting/module-emitter";
2 | import { BaseInstruction } from "./emitting/instructions";
3 | import { CommandsParser } from "./syntax/command-parser";
4 | import { Diagnostic } from "./utils/diagnostics";
5 | import { ModulesBinder } from "./binding/modules-binder";
6 | import { Scanner } from "./syntax/scanner";
7 | import { Token } from "./syntax/tokens";
8 | import { StatementsParser } from "./syntax/statements-parser";
9 | import { BaseSyntaxNode, ParseTreeSyntax, SyntaxKind, SyntaxNodeVisitor, IdentifierExpressionSyntax } from "./syntax/syntax-nodes";
10 | import { BoundStatementBlock } from "./binding/bound-nodes";
11 | import { CompilerPosition } from "./syntax/ranges";
12 |
13 | export interface CompilationKind {
14 | writesToTextWindow(): boolean;
15 | drawsShapes(): boolean;
16 | }
17 |
18 | export class Compilation {
19 | private _outputKindDetector?: OutputKindDetector;
20 |
21 | public readonly tokens: ReadonlyArray;
22 | public readonly parseTree: ParseTreeSyntax;
23 | public readonly boundSubModules: { [name: string]: BoundStatementBlock };
24 | public readonly diagnostics: Diagnostic[] = [];
25 |
26 | public get isReadyToRun(): boolean {
27 | return !!this.text.trim() && !this.diagnostics.length;
28 | }
29 |
30 | public get kind(): CompilationKind {
31 | if (!this._outputKindDetector) {
32 | this._outputKindDetector = new OutputKindDetector();
33 | this._outputKindDetector.visit(this.parseTree);
34 | }
35 |
36 | return this._outputKindDetector;
37 | }
38 |
39 | public constructor(public readonly text: string) {
40 | this.diagnostics = [];
41 |
42 | this.tokens = new Scanner(this.text, this.diagnostics).result;
43 |
44 | const commands = new CommandsParser(this.tokens, this.diagnostics).result;
45 | this.parseTree = new StatementsParser(commands, this.diagnostics).result;
46 | this.setParentNode(this.parseTree);
47 |
48 | const binder = new ModulesBinder(this.parseTree, this.diagnostics);
49 | this.boundSubModules = binder.boundModules;
50 | }
51 |
52 | public emit(): { readonly [name: string]: ReadonlyArray } {
53 | if (!this.isReadyToRun) {
54 | throw new Error(`Cannot emit an empty or errornous compilation`);
55 | }
56 |
57 | const result: { [name: string]: ReadonlyArray } = {};
58 | for (const name in this.boundSubModules) {
59 | result[name] = new ModuleEmitter(this.boundSubModules[name]).instructions;
60 | }
61 |
62 | return result;
63 | }
64 |
65 | public getSyntaxNode(position: CompilerPosition, kind: SyntaxKind): BaseSyntaxNode | undefined {
66 | function getSyntaxNodeAux(node: BaseSyntaxNode, position: CompilerPosition): BaseSyntaxNode | undefined {
67 | if (node.range.containsPosition(position)) {
68 | let children = node.children();
69 | for (let i = 0; i < children.length; i++) {
70 | const result = getSyntaxNodeAux(children[i], position);
71 | if (result) {
72 | return result;
73 | }
74 | }
75 | if (node.kind === kind) {
76 | return node;
77 | }
78 | }
79 | return undefined;
80 | }
81 |
82 | return getSyntaxNodeAux(this.parseTree, position);
83 | }
84 |
85 | private setParentNode(node: BaseSyntaxNode): void {
86 | node.children().forEach(child => {
87 | child.parentOpt = node;
88 | this.setParentNode(child);
89 | });
90 | }
91 | }
92 |
93 | class OutputKindDetector extends SyntaxNodeVisitor implements CompilationKind {
94 | private _writesToTextWindow: boolean = false;
95 | private _drawsShapes: boolean = false;
96 |
97 | public writesToTextWindow(): boolean {
98 | return this._writesToTextWindow;
99 | }
100 |
101 | public drawsShapes(): boolean {
102 | return this._drawsShapes;
103 | }
104 |
105 | public visitIdentifierExpression(node: IdentifierExpressionSyntax): void {
106 | switch (node.identifierToken.token.text) {
107 | case "TextWindow":
108 | this._writesToTextWindow = true;
109 | break;
110 | case "Shapes":
111 | case "Controls":
112 | case "Turtle":
113 | this._drawsShapes = true;
114 | break;
115 | }
116 | }
117 | }
118 |
--------------------------------------------------------------------------------
/tests/compiler/syntax/statements-parser.ts:
--------------------------------------------------------------------------------
1 | import "jasmine";
2 | import { verifyCompilationErrors } from "../helpers";
3 | import { Diagnostic, ErrorCode } from "../../../src/compiler/utils/diagnostics";
4 | import { CompilerRange } from "../../../src/compiler/syntax/ranges";
5 |
6 | describe("Compiler.Syntax.StatementsParser", () => {
7 | it("reports errors on unfinished modules", () => {
8 | verifyCompilationErrors(`
9 | Sub A`,
10 | // Sub A
11 | // ^^^^^
12 | // Unexpected end of file. I was expecting a command of type 'EndSub'.
13 | new Diagnostic(ErrorCode.UnexpectedEOF_ExpectingCommand, CompilerRange.fromValues(1, 0, 1, 5), "EndSub"));
14 | });
15 |
16 | it("reports errors on defining sub inside another one", () => {
17 | verifyCompilationErrors(`
18 | Sub A
19 | Sub B
20 | EndSub`,
21 | // Sub B
22 | // ^^^^^
23 | // You cannot define a sub-module inside another sub-module.
24 | new Diagnostic(ErrorCode.CannotDefineASubInsideAnotherSub, CompilerRange.fromValues(2, 0, 2, 5)));
25 | });
26 |
27 | it("reports errors on ending sub without starting one", () => {
28 | verifyCompilationErrors(`
29 | x = 1
30 | EndSub`,
31 | // EndSub
32 | // ^^^^^^
33 | // You cannot write a command of type 'EndSub' without an earlier command of type 'Sub'.
34 | new Diagnostic(ErrorCode.CannotHaveCommandWithoutPreviousCommand, CompilerRange.fromValues(2, 0, 2, 6), "EndSub", "Sub"));
35 | });
36 |
37 | it("reports errors on ElseIf without If", () => {
38 | verifyCompilationErrors(`
39 | x = 1
40 | ElseIf y Then`,
41 | // ElseIf y Then
42 | // ^^^^^^^^^^^^^
43 | // You cannot write a command of type 'ElseIf' without an earlier command of type 'If'.
44 | new Diagnostic(ErrorCode.CannotHaveCommandWithoutPreviousCommand, CompilerRange.fromValues(2, 0, 2, 13), "ElseIf", "If"));
45 | });
46 |
47 | it("reports errors on Else without If", () => {
48 | verifyCompilationErrors(`
49 | x = 1
50 | Else`,
51 | // Else
52 | // ^^^^
53 | // You cannot write a command of type 'Else' without an earlier command of type 'If'.
54 | new Diagnostic(ErrorCode.CannotHaveCommandWithoutPreviousCommand, CompilerRange.fromValues(2, 0, 2, 4), "Else", "If"));
55 | });
56 |
57 | it("reports errors on EndIf without If", () => {
58 | verifyCompilationErrors(`
59 | x = 1
60 | EndIf`,
61 | // EndIf
62 | // ^^^^^
63 | // You cannot write a command of type 'EndIf' without an earlier command of type 'If'.
64 | new Diagnostic(ErrorCode.CannotHaveCommandWithoutPreviousCommand, CompilerRange.fromValues(2, 0, 2, 5), "EndIf", "If"));
65 | });
66 |
67 | it("reports errors on EndFor without For", () => {
68 | verifyCompilationErrors(`
69 | x = 1
70 | EndFor`,
71 | // EndFor
72 | // ^^^^^^
73 | // You cannot write a command of type 'EndFor' without an earlier command of type 'For'.
74 | new Diagnostic(ErrorCode.CannotHaveCommandWithoutPreviousCommand, CompilerRange.fromValues(2, 0, 2, 6), "EndFor", "For"));
75 | });
76 |
77 | it("reports errors on EndWhile without While", () => {
78 | verifyCompilationErrors(`
79 | x = 1
80 | EndWhile`,
81 | // EndWhile
82 | // ^^^^^^^^
83 | // You cannot write a command of type 'EndWhile' without an earlier command of type 'While'.
84 | new Diagnostic(ErrorCode.CannotHaveCommandWithoutPreviousCommand, CompilerRange.fromValues(2, 0, 2, 8), "EndWhile", "While"));
85 | });
86 |
87 | it("reports errors on ElseIf After Else", () => {
88 | verifyCompilationErrors(`
89 | If x Then
90 | a = 0
91 | Else
92 | a = 1
93 | ElseIf y Then
94 | a = 2
95 | EndIf`,
96 | // ElseIf y Then
97 | // ^^^^^^^^^^^^^
98 | // Unexpected command of type 'ElseIf'. I was expecting a command of type 'EndIf'.
99 | new Diagnostic(ErrorCode.UnexpectedCommand_ExpectingCommand, CompilerRange.fromValues(5, 0, 5, 13), "ElseIf", "EndIf"),
100 | // ElseIf y Then
101 | // ^^^^^^^^^^^^^
102 | // You cannot write a command of type 'ElseIf' without an earlier command of type 'If'.
103 | new Diagnostic(ErrorCode.CannotHaveCommandWithoutPreviousCommand, CompilerRange.fromValues(5, 0, 5, 13), "ElseIf", "If"),
104 | // EndIf
105 | // ^^^^^
106 | // You cannot write a command of type 'EndIf' without an earlier command of type 'If'.
107 | new Diagnostic(ErrorCode.CannotHaveCommandWithoutPreviousCommand, CompilerRange.fromValues(7, 0, 7, 5), "EndIf", "If"));
108 | });
109 | });
110 |
--------------------------------------------------------------------------------
/src/compiler/utils/compiler-utils.ts:
--------------------------------------------------------------------------------
1 | import { SyntaxKind } from "../syntax/syntax-nodes";
2 | import { TokenKind } from "../syntax/tokens";
3 | import { CompilerResources } from "../../strings/compiler";
4 |
5 | export module CompilerUtils {
6 | export function formatString(template: string, args: ReadonlyArray): string {
7 | return template.replace(/{[0-9]+}/g, match => args[parseInt(match.replace(/^{/, "").replace(/}$/, ""))]);
8 | }
9 |
10 | export function stringStartsWith(value: string, prefix?: string): boolean {
11 | if (!prefix || !prefix.length) {
12 | return true;
13 | }
14 |
15 | value = value.toLowerCase();
16 | prefix = prefix.toLocaleLowerCase();
17 |
18 | if (value.length <= prefix.length) {
19 | return false;
20 | } else {
21 | return prefix === value.substr(0, prefix.length);
22 | }
23 | }
24 |
25 | export function values(parent: { [key: string]: TMember }): ReadonlyArray {
26 | return Object.keys(parent).map(key => parent[key]);
27 | }
28 |
29 | export function commandToDisplayString(kind: SyntaxKind): string {
30 | switch (kind) {
31 | case SyntaxKind.IfCommand: return tokenToDisplayString(TokenKind.IfKeyword);
32 | case SyntaxKind.ElseCommand: return tokenToDisplayString(TokenKind.ElseKeyword);
33 | case SyntaxKind.ElseIfCommand: return tokenToDisplayString(TokenKind.ElseIfKeyword);
34 | case SyntaxKind.EndIfCommand: return tokenToDisplayString(TokenKind.EndIfKeyword);
35 | case SyntaxKind.ForCommand: return tokenToDisplayString(TokenKind.ForKeyword);
36 | case SyntaxKind.EndForCommand: return tokenToDisplayString(TokenKind.EndForKeyword);
37 | case SyntaxKind.WhileCommand: return tokenToDisplayString(TokenKind.WhileKeyword);
38 | case SyntaxKind.EndWhileCommand: return tokenToDisplayString(TokenKind.EndWhileKeyword);
39 | case SyntaxKind.LabelCommand: return CompilerResources.SyntaxNodes_Label;
40 | case SyntaxKind.GoToCommand: return tokenToDisplayString(TokenKind.GoToKeyword);
41 | case SyntaxKind.SubCommand: return tokenToDisplayString(TokenKind.SubKeyword);
42 | case SyntaxKind.EndSubCommand: return tokenToDisplayString(TokenKind.EndSubKeyword);
43 | case SyntaxKind.ExpressionCommand: return CompilerResources.SyntaxNodes_Expression;
44 | default: throw new Error(`Unexpected syntax kind: ${SyntaxKind[kind]}`);
45 | }
46 | }
47 |
48 | export function tokenToDisplayString(kind: TokenKind): string {
49 | switch (kind) {
50 | case TokenKind.IfKeyword: return "If";
51 | case TokenKind.ThenKeyword: return "Then";
52 | case TokenKind.ElseKeyword: return "Else";
53 | case TokenKind.ElseIfKeyword: return "ElseIf";
54 | case TokenKind.EndIfKeyword: return "EndIf";
55 | case TokenKind.ForKeyword: return "For";
56 | case TokenKind.ToKeyword: return "To";
57 | case TokenKind.StepKeyword: return "Step";
58 | case TokenKind.EndForKeyword: return "EndFor";
59 | case TokenKind.GoToKeyword: return "GoTo";
60 | case TokenKind.WhileKeyword: return "While";
61 | case TokenKind.EndWhileKeyword: return "EndWhile";
62 | case TokenKind.SubKeyword: return "Sub";
63 | case TokenKind.EndSubKeyword: return "EndSub";
64 |
65 | case TokenKind.Dot: return ".";
66 | case TokenKind.RightParen: return ")";
67 | case TokenKind.LeftParen: return "(";
68 | case TokenKind.RightSquareBracket: return "]";
69 | case TokenKind.LeftSquareBracket: return "[";
70 | case TokenKind.Comma: return ",";
71 | case TokenKind.Equal: return "=";
72 | case TokenKind.NotEqual: return "<>";
73 | case TokenKind.Plus: return "+";
74 | case TokenKind.Minus: return "-";
75 | case TokenKind.Multiply: return "*";
76 | case TokenKind.Divide: return "/";
77 | case TokenKind.Colon: return ":";
78 | case TokenKind.LessThan: return "<";
79 | case TokenKind.GreaterThan: return ">";
80 | case TokenKind.LessThanOrEqual: return "<=";
81 | case TokenKind.GreaterThanOrEqual: return ">=";
82 | case TokenKind.Or: return "Or";
83 | case TokenKind.And: return "And";
84 |
85 | case TokenKind.Identifier: return CompilerResources.SyntaxNodes_Identifier;
86 | case TokenKind.NumberLiteral: return CompilerResources.SyntaxNodes_NumberLiteral;
87 | case TokenKind.StringLiteral: return CompilerResources.SyntaxNodes_StringLiteral;
88 | case TokenKind.Comment: return CompilerResources.SyntaxNodes_Comment;
89 |
90 | default: throw new Error(`Unrecognized token kind: ${TokenKind[kind]}`);
91 | }
92 | }
93 | }
94 |
--------------------------------------------------------------------------------
/tests/compiler/runtime/libraries/text-window.ts:
--------------------------------------------------------------------------------
1 | import "jasmine";
2 | import { verifyRuntimeResult } from "../../helpers";
3 |
4 | describe("Compiler.Runtime.Libraries.TextWindow", () => {
5 | it("no input or output", () => {
6 | verifyRuntimeResult(`
7 | If "Truee" Then
8 | TextWindow.WriteLine(5)
9 | EndIf`);
10 | });
11 |
12 | it("reads and writes a string value", () => {
13 | verifyRuntimeResult(`
14 | x = TextWindow.Read()
15 | TextWindow.WriteLine(x)
16 | TextWindow.WriteLine(x + 1)`,
17 | ["test"],
18 | ["test", "test1"]);
19 | });
20 |
21 | it("reads and writes a number value as string", () => {
22 | verifyRuntimeResult(`
23 | x = TextWindow.ReadNumber()
24 | TextWindow.WriteLine(x)
25 | TextWindow.WriteLine(x + 1)`,
26 | [5],
27 | ["5", "6"]);
28 | });
29 |
30 | it("displays the contents of an array", () => {
31 | verifyRuntimeResult(`
32 | x[0] = 1
33 | x[1] = "test"
34 | x[2][0] = 10
35 | x[2][1] = 11
36 | x["key"] = "value"
37 | TextWindow.WriteLine(x)
38 |
39 | x["2"] = -5
40 | TextWindow.WriteLine(x)
41 |
42 | TextWindow.WriteLine(x["key"])`,
43 | [],
44 | [
45 | `[0=1, 1="test", 2=[0=10, 1=11], key="value"]`,
46 | `[0=1, 1="test", 2=-5, key="value"]`,
47 | `value`
48 | ]);
49 | });
50 |
51 | it("prints non-conventional characters", () => {
52 | verifyRuntimeResult(`
53 | TextWindow.WriteLine("$")`,
54 | [],
55 | ["$"]);
56 | });
57 |
58 | it("sets foreground color correctly", () => {
59 | verifyRuntimeResult(`
60 | TextWindow.WriteLine(TextWindow.ForegroundColor)
61 | TextWindow.ForegroundColor = 7
62 | TextWindow.WriteLine(TextWindow.ForegroundColor)
63 | TextWindow.ForegroundColor = "Blue"
64 | TextWindow.WriteLine(TextWindow.ForegroundColor)
65 | TextWindow.ForegroundColor = "cyan" ' Case insensitive
66 | TextWindow.WriteLine(TextWindow.ForegroundColor)`,
67 | [],
68 | [
69 | "White",
70 | "Gray",
71 | "Blue",
72 | "Cyan"
73 | ]);
74 | });
75 |
76 | it("sets background color correctly", () => {
77 | verifyRuntimeResult(`
78 | TextWindow.WriteLine(TextWindow.BackgroundColor)
79 | TextWindow.BackgroundColor = 7
80 | TextWindow.WriteLine(TextWindow.BackgroundColor)
81 | TextWindow.BackgroundColor = "Blue"
82 | TextWindow.WriteLine(TextWindow.BackgroundColor)
83 | TextWindow.BackgroundColor = "cyan" ' Case insensitive
84 | TextWindow.WriteLine(TextWindow.BackgroundColor)`,
85 | [],
86 | [
87 | "Black",
88 | "Gray",
89 | "Blue",
90 | "Cyan"
91 | ]);
92 | });
93 |
94 | it("does not change when an invalid number is used for background color", () => {
95 | verifyRuntimeResult(`
96 | TextWindow.BackgroundColor = "Red"
97 | TextWindow.WriteLine(TextWindow.BackgroundColor)
98 | TextWindow.BackgroundColor = 9455
99 | TextWindow.WriteLine(TextWindow.BackgroundColor)
100 | `,
101 | [],
102 | [
103 | "Red",
104 | "Red"
105 | ]);
106 | });
107 |
108 | it("does not change when an invalid string is used for background color", () => {
109 | verifyRuntimeResult(`
110 | TextWindow.BackgroundColor = "Red"
111 | TextWindow.WriteLine(TextWindow.BackgroundColor)
112 | TextWindow.BackgroundColor = "invalid"
113 | TextWindow.WriteLine(TextWindow.BackgroundColor)
114 | `,
115 | [],
116 | [
117 | "Red",
118 | "Red"
119 | ]);
120 | });
121 |
122 | it("does not change when an invalid number is used for foreground color", () => {
123 | verifyRuntimeResult(`
124 | TextWindow.ForegroundColor = "Red"
125 | TextWindow.WriteLine(TextWindow.ForegroundColor)
126 | TextWindow.ForegroundColor = 9455
127 | TextWindow.WriteLine(TextWindow.ForegroundColor)
128 | `,
129 | [],
130 | [
131 | "Red",
132 | "Red"
133 | ]);
134 | });
135 |
136 | it("does not change when an invalid string is used for foreground color", () => {
137 | verifyRuntimeResult(`
138 | TextWindow.ForegroundColor = "Red"
139 | TextWindow.WriteLine(TextWindow.ForegroundColor)
140 | TextWindow.ForegroundColor = "invalid"
141 | TextWindow.WriteLine(TextWindow.ForegroundColor)
142 | `,
143 | [],
144 | [
145 | "Red",
146 | "Red"
147 | ]);
148 | });
149 |
150 | it("writes partial chunks", () => {
151 | verifyRuntimeResult(`
152 | TextWindow.Write("1")
153 | TextWindow.Write("2")
154 | TextWindow.Write("3")`,
155 | [],
156 | [
157 | "123"
158 | ]);
159 | });
160 | });
161 |
--------------------------------------------------------------------------------
/src/app/components/common/shapes/shapes-plugin.ts:
--------------------------------------------------------------------------------
1 | import * as Konva from "konva";
2 | import { BaseShape, ShapeKind } from "./base-shape";
3 | import { RectangleShape } from "./rectangle";
4 | import { EllipseShape } from "./ellipse";
5 | import { TriangleShape } from "./triangle";
6 | import { LineShape } from "./line";
7 | import { TextShape } from "./text";
8 | import { IShapesLibraryPlugin } from "../../../../compiler/runtime/libraries/shapes";
9 |
10 | export class ShapesLibraryPlugin implements IShapesLibraryPlugin {
11 | private readonly shapes: { [name: string]: BaseShape } = {};
12 |
13 | public constructor(
14 | private readonly layer: Konva.Layer,
15 | private readonly stage: Konva.Stage) {
16 | }
17 |
18 | public addRectangle(width: number, height: number): string {
19 | return this.addShape(new RectangleShape(width, height));
20 | }
21 |
22 | public addEllipse(width: number, height: number): string {
23 | return this.addShape(new EllipseShape(width, height));
24 | }
25 |
26 | public addTriangle(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): string {
27 | return this.addShape(new TriangleShape(x1, y1, x2, y2, x3, y3));
28 | }
29 |
30 | public addLine(x1: number, y1: number, x2: number, y2: number): string {
31 | return this.addShape(new LineShape(x1, y1, x2, y2));
32 | }
33 |
34 | public addImage(): string {
35 | throw new Error("TODO: Not Implemented Yet");
36 | }
37 |
38 | public addText(text: string): string {
39 | return this.addShape(new TextShape(text));
40 | }
41 |
42 | public setText(shapeName: string, text: string): void {
43 | const shape = this.shapes[shapeName];
44 | if (shape && shape.kind === ShapeKind.Text) {
45 | (shape as TextShape).setText(text);
46 | this.stage.draw();
47 | }
48 | }
49 |
50 | public remove(shapeName: string): void {
51 | const shape = this.shapes[shapeName];
52 | if (shape) {
53 | shape.remove();
54 | delete (this.shapes[shapeName]);
55 | this.stage.draw();
56 | }
57 | }
58 |
59 | public move(shapeName: string, x: number, y: number): void {
60 | const shape = this.shapes[shapeName];
61 | if (shape) {
62 | shape.move(x, y);
63 | this.stage.draw();
64 | }
65 | }
66 |
67 | public rotate(shapeName: string, angle: number): void {
68 | const shape = this.shapes[shapeName];
69 | if (shape) {
70 | shape.rotate(angle);
71 | this.stage.draw();
72 | }
73 | }
74 |
75 | public zoom(shapeName: string, scaleX: number, scaleY: number): void {
76 | const shape = this.shapes[shapeName];
77 | if (shape) {
78 | shape.zoom(scaleX, scaleY);
79 | this.stage.draw();
80 | }
81 | }
82 |
83 | public animate(shapeName: string, x: number, y: number, duration: number): void {
84 | const shape = this.shapes[shapeName];
85 | if (shape) {
86 | shape.animate(x, y, duration, this.layer);
87 | this.stage.draw();
88 | }
89 | }
90 |
91 | public getLeft(shapeName: string): number {
92 | const shape = this.shapes[shapeName];
93 | if (shape) {
94 | return shape.getLeft();
95 | }
96 |
97 | return 0;
98 | }
99 |
100 | public getTop(shapeName: string): number {
101 | const shape = this.shapes[shapeName];
102 | if (shape) {
103 | return shape.getTop();
104 | }
105 |
106 | return 0;
107 | }
108 |
109 | public getOpacity(shapeName: string): number {
110 | const shape = this.shapes[shapeName];
111 | if (shape) {
112 | return this.shapes[shapeName].getOpacity() * 100;
113 | }
114 |
115 | return 0;
116 | }
117 |
118 | public setOpacity(shapeName: string, level: number): void {
119 | const shape = this.shapes[shapeName];
120 | if (shape) {
121 | if (level < 0) {
122 | level = 0;
123 | }
124 | else if (level > 100) {
125 | level = 100;
126 | }
127 |
128 | shape.setOpacity(level / 100);
129 | this.stage.draw();
130 | }
131 | }
132 |
133 | public setVisibility(shapeName: string, isVisible: boolean): void {
134 | const shape = this.shapes[shapeName];
135 | if (shape) {
136 | if (isVisible) {
137 | shape.showShape();
138 | }
139 | else {
140 | shape.hideShape();
141 | }
142 |
143 | this.stage.draw();
144 | }
145 | }
146 |
147 | private addShape(shape: BaseShape): string {
148 | this.shapes[shape.name] = shape;
149 | this.layer.add(shape.instance);
150 | this.stage.draw();
151 |
152 | return shape.name;
153 | }
154 | }
155 |
--------------------------------------------------------------------------------
/src/compiler/runtime/libraries/text-window.ts:
--------------------------------------------------------------------------------
1 | import { LibraryTypeInstance, LibraryMethodInstance, LibraryPropertyInstance, LibraryEventInstance } from "../libraries";
2 | import { ValueKind, BaseValue } from "../values/base-value";
3 | import { StringValue } from "../values/string-value";
4 | import { NumberValue } from "../values/number-value";
5 | import { ExecutionState, ExecutionEngine } from "../../execution-engine";
6 |
7 | export enum TextWindowColor {
8 | Black = 0,
9 | DarkBlue = 1,
10 | DarkGreen = 2,
11 | DarkCyan = 3,
12 | DarkRed = 4,
13 | DarkMagenta = 5,
14 | DarkYellow = 6,
15 | Gray = 7,
16 | DarkGray = 8,
17 | Blue = 9,
18 | Green = 10,
19 | Cyan = 11,
20 | Red = 12,
21 | Magenta = 13,
22 | Yellow = 14,
23 | White = 15
24 | }
25 |
26 | export interface ITextWindowLibraryPlugin {
27 | inputIsNeeded(kind: ValueKind): void;
28 |
29 | checkInputBuffer(): BaseValue | undefined;
30 | writeText(value: string, appendNewLine: boolean): void;
31 |
32 | getForegroundColor(): TextWindowColor;
33 | setForegroundColor(color: TextWindowColor): void;
34 | getBackgroundColor(): TextWindowColor;
35 | setBackgroundColor(color: TextWindowColor): void;
36 | }
37 |
38 | export class TextWindowLibrary implements LibraryTypeInstance {
39 | private _pluginInstance: ITextWindowLibraryPlugin | undefined;
40 |
41 | public get plugin(): ITextWindowLibraryPlugin {
42 | if (!this._pluginInstance) {
43 | throw new Error("Plugin is not set.");
44 | }
45 |
46 | return this._pluginInstance;
47 | }
48 |
49 | public set plugin(plugin: ITextWindowLibraryPlugin) {
50 | this._pluginInstance = plugin;
51 | }
52 |
53 | private executeReadMethod(engine: ExecutionEngine, kind: ValueKind): void {
54 | const bufferValue = this.plugin.checkInputBuffer();
55 | if (bufferValue) {
56 | if (bufferValue.kind !== kind) {
57 | throw new Error(`Expecting input kind '${ValueKind[kind]}' but buffer has kind '${ValueKind[bufferValue.kind]}'`);
58 | }
59 |
60 | engine.pushEvaluationStack(bufferValue);
61 | engine.state = ExecutionState.Running;
62 | } else {
63 | engine.state = ExecutionState.BlockedOnInput;
64 | this.plugin.inputIsNeeded(kind);
65 | }
66 | }
67 |
68 | private executeWriteMethod(engine: ExecutionEngine, appendNewLine: boolean): void {
69 | const value = engine.popEvaluationStack().toValueString();
70 | this.plugin.writeText(value, appendNewLine);
71 | }
72 |
73 | private tryParseColorValue(value: BaseValue): TextWindowColor | undefined {
74 | switch (value.kind) {
75 | case ValueKind.Number: {
76 | const numberValue = (value as NumberValue).value;
77 | if (TextWindowColor[numberValue]) {
78 | return numberValue;
79 | }
80 | break;
81 | }
82 | case ValueKind.String: {
83 | const stringValue = (value as StringValue).value.toLowerCase();
84 | for (let color in TextWindowColor) {
85 | if (color.toLowerCase() === stringValue) {
86 | return TextWindowColor[color];
87 | }
88 | }
89 | break;
90 | }
91 | }
92 |
93 | return undefined;
94 | }
95 |
96 | private setForegroundColor(value: BaseValue): void {
97 | const color = this.tryParseColorValue(value);
98 | if (color) {
99 | this.plugin.setForegroundColor(color);
100 | }
101 | }
102 |
103 | private setBackgroundColor(value: BaseValue): void {
104 | const color = this.tryParseColorValue(value);
105 | if (color) {
106 | this.plugin.setBackgroundColor(color);
107 | }
108 | }
109 |
110 | private getForegroundColor(): BaseValue {
111 | return new StringValue(TextWindowColor[this.plugin.getForegroundColor()]);
112 | }
113 |
114 | private getBackgroundColor(): BaseValue {
115 | return new StringValue(TextWindowColor[this.plugin.getBackgroundColor()]);
116 | }
117 |
118 | public readonly methods: { readonly [name: string]: LibraryMethodInstance } = {
119 | Read: { execute: engine => this.executeReadMethod(engine, ValueKind.String) },
120 | ReadNumber: { execute: engine => this.executeReadMethod(engine, ValueKind.Number) },
121 | Write: { execute: engine => this.executeWriteMethod(engine, false) },
122 | WriteLine: { execute: engine => this.executeWriteMethod(engine, true) }
123 | };
124 |
125 | public readonly properties: { readonly [name: string]: LibraryPropertyInstance } = {
126 | ForegroundColor: { getter: this.getForegroundColor.bind(this), setter: this.setForegroundColor.bind(this) },
127 | BackgroundColor: { getter: this.getBackgroundColor.bind(this), setter: this.setBackgroundColor.bind(this) }
128 | };
129 |
130 | public readonly events: { readonly [name: string]: LibraryEventInstance } = {};
131 | }
132 |
--------------------------------------------------------------------------------
/src/compiler/runtime/values/string-value.ts:
--------------------------------------------------------------------------------
1 | import { NumberValue } from "./number-value";
2 | import { ExecutionEngine } from "../../execution-engine";
3 | import { AddInstruction, DivideInstruction, MultiplyInstruction, SubtractInstruction } from "../../emitting/instructions";
4 | import { BaseValue, ValueKind, Constants } from "./base-value";
5 | import { TokenKind } from "../../syntax/tokens";
6 | import { ErrorCode, Diagnostic } from "../../utils/diagnostics";
7 | import { CompilerUtils } from "../../utils/compiler-utils";
8 |
9 | export class StringValue extends BaseValue {
10 | public constructor(public readonly value: string) {
11 | super();
12 | }
13 |
14 | public toBoolean(): boolean {
15 | return this.value.toLowerCase() === Constants.True.toLowerCase();
16 | }
17 |
18 | public toDebuggerString(): string {
19 | return `"${this.value.toString()}"`;
20 | }
21 |
22 | public toValueString(): string {
23 | return this.value;
24 | }
25 |
26 | public get kind(): ValueKind {
27 | return ValueKind.String;
28 | }
29 |
30 | public tryConvertToNumber(): BaseValue {
31 | const number = parseFloat(this.value.trim());
32 | if (isNaN(number)) {
33 | return this;
34 | } else {
35 | return new NumberValue(number);
36 | }
37 | }
38 |
39 | public isEqualTo(other: BaseValue): boolean {
40 | switch (other.kind) {
41 | case ValueKind.String:
42 | return this.value === (other as StringValue).value;
43 | case ValueKind.Number:
44 | return this.value.trim() === (other as NumberValue).value.toString();
45 | case ValueKind.Array:
46 | return false;
47 | default:
48 | throw new Error(`Unexpected value kind ${ValueKind[other.kind]}`);
49 | }
50 | }
51 |
52 | public isLessThan(other: BaseValue): boolean {
53 | const thisConverted = this.tryConvertToNumber();
54 | if (thisConverted.tryConvertToNumber().kind === ValueKind.String) {
55 | return false;
56 | } else {
57 | return thisConverted.isLessThan(other);
58 | }
59 | }
60 |
61 | public isGreaterThan(other: BaseValue): boolean {
62 | const thisConverted = this.tryConvertToNumber();
63 | if (thisConverted.tryConvertToNumber().kind === ValueKind.String) {
64 | return false;
65 | } else {
66 | return thisConverted.isGreaterThan(other);
67 | }
68 | }
69 |
70 | public add(other: BaseValue, engine: ExecutionEngine, instruction: AddInstruction): BaseValue {
71 | const thisConverted = this.tryConvertToNumber();
72 | if (thisConverted.tryConvertToNumber().kind !== ValueKind.String) {
73 | return thisConverted.add(other, engine, instruction);
74 | }
75 |
76 | other = other.tryConvertToNumber();
77 | switch (other.kind) {
78 | case ValueKind.String:
79 | return new StringValue(this.value + (other as StringValue).value);
80 | case ValueKind.Number:
81 | return new StringValue(this.value + (other as NumberValue).value.toString());
82 | case ValueKind.Array:
83 | engine.terminate(new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, instruction.sourceRange, CompilerUtils.tokenToDisplayString(TokenKind.Plus)));
84 | return this;
85 | default:
86 | throw new Error(`Unexpected value kind ${ValueKind[other.kind]}`);
87 | }
88 | }
89 |
90 | public subtract(other: BaseValue, engine: ExecutionEngine, instruction: SubtractInstruction): BaseValue {
91 | const thisConverted = this.tryConvertToNumber();
92 | if (thisConverted.tryConvertToNumber().kind === ValueKind.String) {
93 | engine.terminate(new Diagnostic(ErrorCode.CannotUseOperatorWithAString, instruction.sourceRange, CompilerUtils.tokenToDisplayString(TokenKind.Minus)));
94 | return this;
95 | } else {
96 | return thisConverted.subtract(other, engine, instruction);
97 | }
98 | }
99 |
100 | public multiply(other: BaseValue, engine: ExecutionEngine, instruction: MultiplyInstruction): BaseValue {
101 | const thisConverted = this.tryConvertToNumber();
102 | if (thisConverted.tryConvertToNumber().kind === ValueKind.String) {
103 | engine.terminate(new Diagnostic(ErrorCode.CannotUseOperatorWithAString, instruction.sourceRange, CompilerUtils.tokenToDisplayString(TokenKind.Multiply)));
104 | return this;
105 | } else {
106 | return thisConverted.multiply(other, engine, instruction);
107 | }
108 | }
109 |
110 | public divide(other: BaseValue, engine: ExecutionEngine, instruction: DivideInstruction): BaseValue {
111 | const thisConverted = this.tryConvertToNumber();
112 | if (thisConverted.tryConvertToNumber().kind === ValueKind.String) {
113 | engine.terminate(new Diagnostic(ErrorCode.CannotUseOperatorWithAString, instruction.sourceRange, CompilerUtils.tokenToDisplayString(TokenKind.Divide)));
114 | return this;
115 | } else {
116 | return thisConverted.divide(other, engine, instruction);
117 | }
118 | }
119 | }
120 |
--------------------------------------------------------------------------------
/tests/compiler/runtime/libraries-metadata.ts:
--------------------------------------------------------------------------------
1 | import "jasmine";
2 | import { CompilerUtils } from "../../../src/compiler/utils/compiler-utils";
3 | import { RuntimeLibraries } from "../../../src/compiler/runtime/libraries";
4 | import { verifyCompilationErrors } from "../helpers";
5 |
6 | describe("Compiler.Runtime.LibrariesMetadata", () => {
7 | it("all libraries have correct metadata", () => {
8 | const implementations = new RuntimeLibraries();
9 |
10 | CompilerUtils.values(RuntimeLibraries.Metadata).forEach(library => {
11 | const libraryImplementation = implementations[library.typeName];
12 | expect(libraryImplementation).toBeDefined();
13 |
14 | expect(library.typeName.length).toBeGreaterThan(0);
15 | expect(library.description.length).toBeGreaterThan(0);
16 |
17 | CompilerUtils.values(library.methods).forEach(method => {
18 | expect(method.typeName.length).toBeGreaterThan(0);
19 | expect(method.methodName.length).toBeGreaterThan(0);
20 | expect(method.description.length).toBeGreaterThan(0);
21 | expect(method.returnsValue).toBeDefined();
22 |
23 | method.parameters.forEach(parameter => {
24 | expect(parameter.length).toBeGreaterThan(0);
25 | expect(method.parameterDescription(parameter).length).toBeGreaterThan(0);
26 | });
27 |
28 | expect(libraryImplementation.methods[method.methodName]).toBeDefined();
29 | delete (libraryImplementation.methods)[method.methodName];
30 | });
31 |
32 | expect(Object.keys(libraryImplementation.methods).length).toBe(0);
33 |
34 | CompilerUtils.values(library.properties).forEach(property => {
35 | expect(property.typeName.length).toBeGreaterThan(0);
36 | expect(property.propertyName.length).toBeGreaterThan(0);
37 | expect(property.description.length).toBeGreaterThan(0);
38 |
39 | const propertyImplementation = libraryImplementation.properties[property.propertyName];
40 | expect(property.hasGetter).toBe(!!propertyImplementation.getter);
41 | expect(property.hasSetter).toBe(!!propertyImplementation.setter);
42 |
43 | delete (libraryImplementation.properties)[property.propertyName];
44 | });
45 |
46 | expect(Object.keys(libraryImplementation.properties).length).toBe(0);
47 |
48 | CompilerUtils.values(library.events).forEach(event => {
49 | expect(event.typeName.length).toBeGreaterThan(0);
50 | expect(event.eventName.length).toBeGreaterThan(0);
51 | expect(event.description.length).toBeGreaterThan(0);
52 |
53 | const eventImplementation = libraryImplementation.events[event.eventName];
54 | expect(eventImplementation.setSubModule).toBeDefined();
55 | expect(eventImplementation.raise).toBeDefined();
56 |
57 | delete (libraryImplementation.events)[event.eventName];
58 | });
59 |
60 | expect(Object.keys(libraryImplementation.events).length).toBe(0);
61 |
62 | delete (implementations)[library.typeName];
63 | });
64 |
65 | expect(Object.keys(implementations).length).toBe(0);
66 | });
67 |
68 | it("has no kind if there were no library calls in code", () => {
69 | const compilation = verifyCompilationErrors(`
70 | x = 0`);
71 |
72 | expect(compilation.kind.writesToTextWindow()).toBe(false);
73 | expect(compilation.kind.drawsShapes()).toBe(false);
74 | });
75 |
76 | it("has writesToText kind if there were calls to TextWindow", () => {
77 | const compilation = verifyCompilationErrors(`
78 | x = 0
79 | TextWindow.WriteLine(x)`);
80 |
81 | expect(compilation.kind.writesToTextWindow()).toBe(true);
82 | expect(compilation.kind.drawsShapes()).toBe(false);
83 | });
84 |
85 | /* TODO: reenable
86 | it("has drawsShapes kind if there were calls to Turtle", () => {
87 | const compilation = verifyCompilationErrors(`
88 | Turtle.TurnLeft()`);
89 |
90 | expect(compilation.kind.writesToTextWindow()).toBe(false);
91 | expect(compilation.kind.drawsShapes()).toBe(true);
92 | });
93 |
94 | it("has drawsShapes kind if there were calls to Controls", () => {
95 | const compilation = verifyCompilationErrors(`
96 | Controls.AddButton("value", 0, 0)`);
97 |
98 | expect(compilation.kind.writesToTextWindow()).toBe(false);
99 | expect(compilation.kind.drawsShapes()).toBe(true);
100 | });
101 | */
102 |
103 | it("has drawsShapes kind if there were calls to Shapes", () => {
104 | const compilation = verifyCompilationErrors(`
105 | Shapes.AddRectangle( 0, 0)`);
106 |
107 | expect(compilation.kind.writesToTextWindow()).toBe(false);
108 | expect(compilation.kind.drawsShapes()).toBe(true);
109 | });
110 |
111 | it("has both kinds if there were calls to Shapes and TextWindow", () => {
112 | const compilation = verifyCompilationErrors(`
113 | shape = Shapes.AddRectangle( 0, 0)
114 | TextWindow.WriteLine(shape)`);
115 |
116 | expect(compilation.kind.writesToTextWindow()).toBe(true);
117 | expect(compilation.kind.drawsShapes()).toBe(true);
118 | });
119 | });
120 |
--------------------------------------------------------------------------------
/tests/compiler/runtime/expressions/addition.ts:
--------------------------------------------------------------------------------
1 | import "jasmine";
2 | import { verifyRuntimeResult, verifyRuntimeError } from "../../helpers";
3 | import { Diagnostic, ErrorCode } from "../../../../src/compiler/utils/diagnostics";
4 | import { CompilerRange } from "../../../../src/compiler/syntax/ranges";
5 |
6 | describe("Compiler.Runtime.Expressions.Addition", () => {
7 | it("computes addition - number plus number", () => {
8 | verifyRuntimeResult(`
9 | TextWindow.WriteLine(1 + 4)`,
10 | [],
11 | ["5"]);
12 | });
13 |
14 | it("computes addition - number plus numeric string", () => {
15 | verifyRuntimeResult(`
16 | TextWindow.WriteLine(1 + "7")`,
17 | [],
18 | ["8"]);
19 | });
20 |
21 | it("computes addition - number plus non-numeric string", () => {
22 | verifyRuntimeResult(`
23 | TextWindow.WriteLine(1 + "t")`,
24 | [],
25 | ["1t"]);
26 | });
27 |
28 | it("computes addition - number plus array - error", () => {
29 | verifyRuntimeError(`
30 | x[0] = 1
31 | TextWindow.WriteLine(1 + x)`,
32 | // TextWindow.WriteLine(1 + x)
33 | // ^^^^^
34 | // You cannot use the operator '+' with an array value
35 | new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, CompilerRange.fromValues(2, 21, 2, 26), "+"));
36 | });
37 |
38 | it("computes addition - numeric string plus number", () => {
39 | verifyRuntimeResult(`
40 | TextWindow.WriteLine("1" + 4)`,
41 | [],
42 | ["5"]);
43 | });
44 |
45 | it("computes addition - numeric string plus numeric string", () => {
46 | verifyRuntimeResult(`
47 | TextWindow.WriteLine("1" + "7")`,
48 | [],
49 | ["8"]);
50 | });
51 |
52 | it("computes addition - numeric string plus non-numeric string", () => {
53 | verifyRuntimeResult(`
54 | TextWindow.WriteLine("1" + "t")`,
55 | [],
56 | ["1t"]);
57 | });
58 |
59 | it("computes addition - numeric string plus array - error", () => {
60 | verifyRuntimeError(`
61 | x[0] = 1
62 | TextWindow.WriteLine("1" + x)`,
63 | // TextWindow.WriteLine("1" + x)
64 | // ^^^^^^^
65 | // You cannot use the operator '+' with an array value
66 | new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, CompilerRange.fromValues(2, 21, 2, 28), "+"));
67 | });
68 |
69 | it("computes addition - non-numeric string plus number", () => {
70 | verifyRuntimeResult(`
71 | TextWindow.WriteLine("r" + 5)`,
72 | [],
73 | ["r5"]);
74 | });
75 |
76 | it("computes addition - non-numeric string plus numeric string", () => {
77 | verifyRuntimeResult(`
78 | TextWindow.WriteLine("r" + "4")`,
79 | [],
80 | ["r4"]);
81 | });
82 |
83 | it("computes addition - non-numeric string plus non-numeric string", () => {
84 | verifyRuntimeResult(`
85 | TextWindow.WriteLine("r" + "t")`,
86 | [],
87 | ["rt"]);
88 | });
89 |
90 | it("computes addition - non-numeric string plus array - error", () => {
91 | verifyRuntimeError(`
92 | x[0] = 1
93 | TextWindow.WriteLine("r" + x)`,
94 | // TextWindow.WriteLine("r" + x)
95 | // ^^^^^^^
96 | // You cannot use the operator '+' with an array value
97 | new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, CompilerRange.fromValues(2, 21, 2, 28), "+"));
98 | });
99 |
100 | it("computes addition - array plus number", () => {
101 | verifyRuntimeError(`
102 | x[0] = 1
103 | TextWindow.WriteLine(x + 5)`,
104 | // TextWindow.WriteLine(x + 5)
105 | // ^^^^^
106 | // You cannot use the operator '+' with an array value
107 | new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, CompilerRange.fromValues(2, 21, 2, 26), "+"));
108 | });
109 |
110 | it("computes addition - array plus numeric string", () => {
111 | verifyRuntimeError(`
112 | x[0] = 1
113 | TextWindow.WriteLine(x + "4")`,
114 | // TextWindow.WriteLine(x + "4")
115 | // ^^^^^^^
116 | // You cannot use the operator '+' with an array value
117 | new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, CompilerRange.fromValues(2, 21, 2, 28), "+"));
118 | });
119 |
120 | it("computes addition - array plus non-numeric string", () => {
121 | verifyRuntimeError(`
122 | x[0] = 1
123 | TextWindow.WriteLine(x + "t")`,
124 | // TextWindow.WriteLine(x + "t")
125 | // ^^^^^^^
126 | // You cannot use the operator '+' with an array value
127 | new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, CompilerRange.fromValues(2, 21, 2, 28), "+"));
128 | });
129 |
130 | it("computes addition - array plus array - error", () => {
131 | verifyRuntimeError(`
132 | x[0] = 1
133 | y[0] = 1
134 | TextWindow.WriteLine(x + y)`,
135 | // TextWindow.WriteLine(x + y)
136 | // ^^^^^
137 | // You cannot use the operator '+' with an array value
138 | new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, CompilerRange.fromValues(3, 21, 3, 26), "+"));
139 | });
140 | });
141 |
--------------------------------------------------------------------------------
/src/compiler/execution-engine.ts:
--------------------------------------------------------------------------------
1 | import { BaseValue } from "./runtime/values/base-value";
2 | import { Compilation } from "./compilation";
3 | import { BaseInstruction } from "./emitting/instructions";
4 | import { RuntimeLibraries } from "./runtime/libraries";
5 | import { Diagnostic } from "./utils/diagnostics";
6 | import { ArrayValue } from "./runtime/values/array-value";
7 | import { PubSubPayloadChannel } from "./utils/notifications";
8 | import { ModulesBinder } from "./binding/modules-binder";
9 |
10 | export interface StackFrame {
11 | moduleName: string;
12 | instructionIndex: number;
13 | }
14 |
15 | export enum ExecutionMode {
16 | RunToEnd,
17 | Debug,
18 | NextStatement
19 | }
20 |
21 | export enum ExecutionState {
22 | Running,
23 | Paused,
24 | BlockedOnInput,
25 | Terminated
26 | }
27 |
28 | export class ExecutionEngine {
29 | private _libraries: RuntimeLibraries = new RuntimeLibraries();
30 | private _executionStack: StackFrame[] = [];
31 | private _evaluationStack: BaseValue[] = [];
32 | private _memory: ArrayValue = new ArrayValue();
33 | private _modules: { readonly [name: string]: ReadonlyArray };
34 |
35 | private _exception?: Diagnostic;
36 | private _currentLine: number = 0;
37 | private _state: ExecutionState = ExecutionState.Running;
38 |
39 | public readonly programTerminated: PubSubPayloadChannel = new PubSubPayloadChannel("programTerminated");
40 |
41 | public get libraries(): RuntimeLibraries {
42 | return this._libraries;
43 | }
44 |
45 | public get executionStack(): ReadonlyArray {
46 | return this._executionStack;
47 | }
48 |
49 | public get evaluationStack(): ReadonlyArray {
50 | return this._evaluationStack;
51 | }
52 |
53 | public get memory(): ArrayValue {
54 | return this._memory;
55 | }
56 |
57 | public get modules(): { readonly [name: string]: ReadonlyArray } {
58 | return this._modules;
59 | }
60 |
61 | public get exception(): Diagnostic | undefined {
62 | return this._exception;
63 | }
64 |
65 | public get state(): ExecutionState {
66 | return this._state;
67 | }
68 |
69 | public set state(newState: ExecutionState) {
70 | this._state = newState;
71 | }
72 |
73 | public constructor(compilation: Compilation) {
74 | if (compilation.diagnostics.length) {
75 | throw new Error(`Cannot execute a compilation with errors`);
76 | }
77 |
78 | this._modules = compilation.emit();
79 |
80 | this._executionStack.push({
81 | moduleName: ModulesBinder.MainModuleName,
82 | instructionIndex: 0
83 | });
84 | }
85 |
86 | public execute(mode: ExecutionMode): void {
87 | if (this._state === ExecutionState.Paused) {
88 | this._state = ExecutionState.Running;
89 | }
90 |
91 | while (true) {
92 | if (this._state === ExecutionState.Terminated) {
93 | return;
94 | }
95 |
96 | if (this._executionStack.length === 0) {
97 | this.terminate();
98 | return;
99 | }
100 |
101 | const frame = this._executionStack[this._executionStack.length - 1];
102 | if (frame.instructionIndex === this._modules[frame.moduleName].length) {
103 | this._executionStack.pop();
104 | continue;
105 | }
106 |
107 | const instruction = this._modules[frame.moduleName][frame.instructionIndex];
108 | if (instruction.sourceRange.start.line !== this._currentLine && mode === ExecutionMode.NextStatement) {
109 | this._currentLine = instruction.sourceRange.start.line;
110 | this._state = ExecutionState.Paused;
111 | return;
112 | }
113 |
114 | instruction.execute(this, mode, frame);
115 |
116 | switch (this.state) {
117 | case ExecutionState.Running:
118 | break;
119 | case ExecutionState.Paused:
120 | case ExecutionState.Terminated:
121 | case ExecutionState.BlockedOnInput:
122 | return;
123 | default:
124 | throw new Error(`Unexpected execution state: '${ExecutionState[this.state]}'`);
125 | }
126 | }
127 | }
128 |
129 | public terminate(exception?: Diagnostic): void {
130 | this._state = ExecutionState.Terminated;
131 | this._exception = exception;
132 | this.programTerminated.publish(exception);
133 | }
134 |
135 | public popEvaluationStack(): BaseValue {
136 | const value = this._evaluationStack.pop();
137 | if (value) {
138 | return value;
139 | }
140 |
141 | throw new Error("Evaluation stack empty");
142 | }
143 |
144 | public pushEvaluationStack(value: BaseValue): void {
145 | this._evaluationStack.push(value);
146 | }
147 |
148 | public pushSubModule(name: string): void {
149 | if (this._modules[name]) {
150 | this._executionStack.push({
151 | moduleName: name,
152 | instructionIndex: 0
153 | });
154 | } else {
155 | throw new Error(`SubModule ${name} not found`);
156 | }
157 | }
158 | }
159 |
--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
1 | # Code of Conduct
2 |
3 | ## 1. Purpose
4 |
5 | A primary goal of SmallBasic Online is to be inclusive to the largest number of contributors, with the most varied and diverse backgrounds possible. As such, we are committed to providing a friendly, safe and welcoming environment for all, regardless of gender, sexual orientation, ability, ethnicity, socioeconomic status, and religion (or lack thereof).
6 |
7 | This code of conduct outlines our expectations for all those who participate in our community, as well as the consequences for unacceptable behavior.
8 |
9 | We invite all those who participate in SmallBasic Online to help us create safe and positive experiences for everyone.
10 |
11 | ## 2. Open Source Citizenship
12 |
13 | A supplemental goal of this Code of Conduct is to increase open source citizenship by encouraging participants to recognize and strengthen the relationships between our actions and their effects on our community.
14 |
15 | Communities mirror the societies in which they exist and positive action is essential to counteract the many forms of inequality and abuses of power that exist in society.
16 |
17 | If you see someone who is making an extra effort to ensure our community is welcoming, friendly, and encourages all participants to contribute to the fullest extent, we want to know.
18 |
19 | ## 3. Expected Behavior
20 |
21 | The following behaviors are expected and requested of all community members:
22 |
23 | * Participate in an authentic and active way. In doing so, you contribute to the health and longevity of this community.
24 | * Exercise consideration and respect in your speech and actions.
25 | * Attempt collaboration before conflict.
26 | * Refrain from demeaning, discriminatory, or harassing behavior and speech.
27 | * Be mindful of your surroundings and of your fellow participants. Alert community leaders if you notice a dangerous situation, someone in distress, or violations of this Code of Conduct, even if they seem inconsequential.
28 | * Remember that community event venues may be shared with members of the public; please be respectful to all patrons of these locations.
29 |
30 | ## 4. Unacceptable Behavior
31 |
32 | The following behaviors are considered harassment and are unacceptable within our community:
33 |
34 | * Violence, threats of violence or violent language directed against another person.
35 | * Sexist, racist, homophobic, transphobic, ableist or otherwise discriminatory jokes and language.
36 | * Posting or displaying sexually explicit or violent material.
37 | * Posting or threatening to post other people’s personally identifying information ("doxing").
38 | * Personal insults, particularly those related to gender, sexual orientation, race, religion, or disability.
39 | * Inappropriate photography or recording.
40 | * Inappropriate physical contact. You should have someone’s consent before touching them.
41 | * Unwelcome sexual attention. This includes, sexualized comments or jokes; inappropriate touching, groping, and unwelcomed sexual advances.
42 | * Deliberate intimidation, stalking or following (online or in person).
43 | * Advocating for, or encouraging, any of the above behavior.
44 | * Sustained disruption of community events, including talks and presentations.
45 |
46 | ## 5. Consequences of Unacceptable Behavior
47 |
48 | Unacceptable behavior from any community member, including sponsors and those with decision-making authority, will not be tolerated.
49 |
50 | Anyone asked to stop unacceptable behavior is expected to comply immediately.
51 |
52 | If a community member engages in unacceptable behavior, the community organizers may take any action they deem appropriate, up to and including a temporary ban or permanent expulsion from the community without warning (and without refund in the case of a paid event).
53 |
54 | ## 6. Reporting Guidelines
55 |
56 | If you are subject to or witness unacceptable behavior, or have any other concerns, please notify a community organizer as soon as possible. .
57 |
58 |
59 |
60 | Additionally, community organizers are available to help community members engage with local law enforcement or to otherwise help those experiencing unacceptable behavior feel safe. In the context of in-person events, organizers will also provide escorts as desired by the person experiencing distress.
61 |
62 | ## 7. Addressing Grievances
63 |
64 | If you feel you have been falsely or unfairly accused of violating this Code of Conduct, you should notify the SmallBasic council with a concise description of your grievance. Your grievance will be handled in accordance with our existing governing policies.
65 |
66 |
67 |
68 | ## 8. Scope
69 |
70 | We expect all community participants (contributors, paid or otherwise; sponsors; and other guests) to abide by this Code of Conduct in all community venues–online and in-person–as well as in all one-on-one communications pertaining to community business.
71 |
72 | This code of conduct and its related procedures also applies to unacceptable behavior occurring outside the scope of community activities when such behavior has the potential to adversely affect the safety and well-being of community members.
73 |
74 | ## 9. Contact info
75 |
76 |
77 |
78 | ## 10. License and attribution
79 |
80 | This Code of Conduct is distributed under a [Creative Commons Attribution-ShareAlike license](http://creativecommons.org/licenses/by-sa/3.0/).
81 |
82 | Portions of text derived from the [Django Code of Conduct](https://www.djangoproject.com/conduct/) and the [Geek Feminism Anti-Harassment Policy](http://geekfeminism.wikia.com/wiki/Conference_anti-harassment/Policy).
83 |
84 | Retrieved on November 22, 2016 from [http://citizencodeofconduct.org/](http://citizencodeofconduct.org/)
85 |
--------------------------------------------------------------------------------
/src/app/components/editor/documentation/index.tsx:
--------------------------------------------------------------------------------
1 | import { RuntimeLibraries } from "../../../../compiler/runtime/libraries";
2 | import * as React from "react";
3 | import { EditorResources } from "../../../../strings/editor";
4 |
5 | import "./style.css";
6 | import { CompilerUtils } from "../../../../compiler/utils/compiler-utils";
7 |
8 | const DocumentationIcon = require("./header.png");
9 |
10 | interface DocumentationProps {
11 | }
12 |
13 | interface DocumentationState {
14 | library?: string;
15 | member?: string;
16 | }
17 |
18 | export class DocumentationComponent extends React.Component {
19 |
20 | public constructor(props: DocumentationProps) {
21 | super(props);
22 | this.state = {
23 | library: undefined,
24 | member: undefined
25 | };
26 | }
27 |
28 | private libraryClicked(name: string): void {
29 | if (this.state.library === name) {
30 | this.setState({
31 | library: undefined,
32 | member: undefined
33 | });
34 | } else {
35 | this.setState({
36 | library: name,
37 | member: undefined
38 | });
39 | }
40 | }
41 |
42 | private memberClicked(name: string): void {
43 | if (this.state.member === name) {
44 | this.setState({
45 | library: this.state.library,
46 | member: undefined
47 | });
48 | } else {
49 | this.setState({
50 | library: this.state.library,
51 | member: name
52 | });
53 | }
54 | }
55 |
56 | public render(): JSX.Element {
57 | return (
58 |
78 |
85 | :
86 |
79 |
81 |
82 |
84 |
87 |
89 | }
90 | />
91 | );
92 | }
93 | }
94 |
95 | function mapStateToProps(state: AppState): PropsFromState {
96 | return {
97 | compilation: state.compilation,
98 | appInsights: state.appInsights
99 | };
100 | }
101 |
102 | function mapDispatchToProps(_: Dispatch
59 |
60 |
107 | );
108 | }
109 | }
110 |
--------------------------------------------------------------------------------
/tests/compiler/runtime/expressions/subtraction.ts:
--------------------------------------------------------------------------------
1 | import "jasmine";
2 | import { verifyRuntimeResult, verifyRuntimeError } from "../../helpers";
3 | import { Diagnostic, ErrorCode } from "../../../../src/compiler/utils/diagnostics";
4 | import { CompilerRange } from "../../../../src/compiler/syntax/ranges";
5 |
6 | describe("Compiler.Runtime.Expressions.Subtraction", () => {
7 | it("computes subtraction - number minus number", () => {
8 | verifyRuntimeResult(`
9 | TextWindow.WriteLine(7 - 4)`,
10 | [],
11 | ["3"]);
12 | });
13 |
14 | it("computes subtraction - number minus numeric string", () => {
15 | verifyRuntimeResult(`
16 | TextWindow.WriteLine(7 - "2")`,
17 | [],
18 | ["5"]);
19 | });
20 |
21 | it("computes subtraction - number minus non-numeric string", () => {
22 | verifyRuntimeError(`
23 | TextWindow.WriteLine(1 - "t")`,
24 | // TextWindow.WriteLine(1 - "t")
25 | // ^^^^^^^
26 | // You cannot use the operator '-' with a string value
27 | new Diagnostic(ErrorCode.CannotUseOperatorWithAString, CompilerRange.fromValues(1, 21, 1, 28), "-"));
28 | });
29 |
30 | it("computes subtraction - number minus array - error", () => {
31 | verifyRuntimeError(`
32 | x[0] = 1
33 | TextWindow.WriteLine(1 - x)`,
34 | // TextWindow.WriteLine(1 - x)
35 | // ^^^^^
36 | // You cannot use the operator '-' with an array value
37 | new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, CompilerRange.fromValues(2, 21, 2, 26), "-"));
38 | });
39 |
40 | it("computes subtraction - numeric string minus number", () => {
41 | verifyRuntimeResult(`
42 | TextWindow.WriteLine("6" - 4)`,
43 | [],
44 | ["2"]);
45 | });
46 |
47 | it("computes subtraction - numeric string minus numeric string", () => {
48 | verifyRuntimeResult(`
49 | TextWindow.WriteLine("1" - "7")`,
50 | [],
51 | ["-6"]);
52 | });
53 |
54 | it("computes subtraction - numeric string minus non-numeric string", () => {
55 | verifyRuntimeError(`
56 | TextWindow.WriteLine("1" - "t")`,
57 | // TextWindow.WriteLine("1" - "t")
58 | // ^^^^^^^^^
59 | // You cannot use the operator '-' with a string value
60 | new Diagnostic(ErrorCode.CannotUseOperatorWithAString, CompilerRange.fromValues(1, 21, 1, 30), "-"));
61 | });
62 |
63 | it("computes subtraction - numeric string minus array - error", () => {
64 | verifyRuntimeError(`
65 | x[0] = 1
66 | TextWindow.WriteLine("1" - x)`,
67 | // TextWindow.WriteLine("1" - x)
68 | // ^^^^^^^
69 | // You cannot use the operator '-' with an array value
70 | new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, CompilerRange.fromValues(2, 21, 2, 28), "-"));
71 | });
72 |
73 | it("computes subtraction - non-numeric string minus number", () => {
74 | verifyRuntimeError(`
75 | TextWindow.WriteLine("r" - 5)`,
76 | // TextWindow.WriteLine("r" - 5)
77 | // ^^^^^^^
78 | // You cannot use the operator '-' with a string value
79 | new Diagnostic(ErrorCode.CannotUseOperatorWithAString, CompilerRange.fromValues(1, 21, 1, 28), "-"));
80 | });
81 |
82 | it("computes subtraction - non-numeric string minus numeric string", () => {
83 | verifyRuntimeError(`
84 | TextWindow.WriteLine("r" - "4")`,
85 | // TextWindow.WriteLine("r" - "4")
86 | // ^^^^^^^^^
87 | // You cannot use the operator '-' with a string value
88 | new Diagnostic(ErrorCode.CannotUseOperatorWithAString, CompilerRange.fromValues(1, 21, 1, 30), "-"));
89 | });
90 |
91 | it("computes subtraction - non-numeric string minus non-numeric string", () => {
92 | verifyRuntimeError(`
93 | TextWindow.WriteLine("r" - "t")`,
94 | // TextWindow.WriteLine("r" - "t")
95 | // ^^^^^^^^^
96 | // You cannot use the operator '-' with a string value
97 | new Diagnostic(ErrorCode.CannotUseOperatorWithAString, CompilerRange.fromValues(1, 21, 1, 30), "-"));
98 | });
99 |
100 | it("computes subtraction - non-numeric string minus array - error", () => {
101 | verifyRuntimeError(`
102 | x[0] = 1
103 | TextWindow.WriteLine("r" - x)`,
104 | // TextWindow.WriteLine("r" - x)
105 | // ^^^^^^^
106 | // You cannot use the operator '-' with a string value
107 | new Diagnostic(ErrorCode.CannotUseOperatorWithAString, CompilerRange.fromValues(2, 21, 2, 28), "-"));
108 | });
109 |
110 | it("computes subtraction - array minus number", () => {
111 | verifyRuntimeError(`
112 | x[0] = 1
113 | TextWindow.WriteLine(x - 5)`,
114 | // TextWindow.WriteLine(x - 5)
115 | // ^^^^^
116 | // You cannot use the operator '-' with an array value
117 | new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, CompilerRange.fromValues(2, 21, 2, 26), "-"));
118 | });
119 |
120 | it("computes subtraction - array minus numeric string", () => {
121 | verifyRuntimeError(`
122 | x[0] = 1
123 | TextWindow.WriteLine(x - "4")`,
124 | // TextWindow.WriteLine(x - "4")
125 | // ^^^^^^^
126 | // You cannot use the operator '-' with an array value
127 | new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, CompilerRange.fromValues(2, 21, 2, 28), "-"));
128 | });
129 |
130 | it("computes subtraction - array minus non-numeric string", () => {
131 | verifyRuntimeError(`
132 | x[0] = 1
133 | TextWindow.WriteLine(x - "t")`,
134 | // TextWindow.WriteLine(x - "t")
135 | // ^^^^^^^
136 | // You cannot use the operator '-' with an array value
137 | new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, CompilerRange.fromValues(2, 21, 2, 28), "-"));
138 | });
139 |
140 | it("computes subtraction - array minus array - error", () => {
141 | verifyRuntimeError(`
142 | x[0] = 1
143 | y[0] = 1
144 | TextWindow.WriteLine(x - y)`,
145 | // TextWindow.WriteLine(x - y)
146 | // ^^^^^
147 | // You cannot use the operator '-' with an array value
148 | new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, CompilerRange.fromValues(3, 21, 3, 26), "-"));
149 | });
150 | });
151 |
--------------------------------------------------------------------------------
/src/compiler/runtime/values/number-value.ts:
--------------------------------------------------------------------------------
1 | import { ExecutionEngine } from "../../execution-engine";
2 | import { StringValue } from "./string-value";
3 | import { AddInstruction, DivideInstruction, MultiplyInstruction, SubtractInstruction } from "../../emitting/instructions";
4 | import { Diagnostic, ErrorCode } from "../../utils/diagnostics";
5 | import { BaseValue, ValueKind } from "./base-value";
6 | import { TokenKind } from "../../syntax/tokens";
7 | import { CompilerUtils } from "../../utils/compiler-utils";
8 |
9 | export class NumberValue extends BaseValue {
10 | public constructor(public readonly value: number) {
11 | super();
12 | }
13 |
14 | public toBoolean(): boolean {
15 | return false;
16 | }
17 |
18 | public toDebuggerString(): string {
19 | return this.value.toString();
20 | }
21 |
22 | public toValueString(): string {
23 | return this.toDebuggerString();
24 | }
25 |
26 | public get kind(): ValueKind {
27 | return ValueKind.Number;
28 | }
29 |
30 | public tryConvertToNumber(): BaseValue {
31 | return this;
32 | }
33 |
34 | public isEqualTo(other: BaseValue): boolean {
35 | other = other.tryConvertToNumber();
36 |
37 | switch (other.kind) {
38 | case ValueKind.String:
39 | return this.value.toString() === (other as StringValue).value;
40 | case ValueKind.Number:
41 | return this.value === (other as NumberValue).value;
42 | case ValueKind.Array:
43 | return false;
44 | default:
45 | throw new Error(`Unexpected value kind ${ValueKind[other.kind]}`);
46 | }
47 | }
48 |
49 | public isLessThan(other: BaseValue): boolean {
50 | other = other.tryConvertToNumber();
51 |
52 | switch (other.kind) {
53 | case ValueKind.String:
54 | case ValueKind.Array:
55 | return false;
56 | case ValueKind.Number:
57 | return this.value < (other as NumberValue).value;
58 | default:
59 | throw new Error(`Unexpected value kind ${ValueKind[other.kind]}`);
60 | }
61 | }
62 |
63 | public isGreaterThan(other: BaseValue): boolean {
64 | other = other.tryConvertToNumber();
65 |
66 | switch (other.kind) {
67 | case ValueKind.String:
68 | case ValueKind.Array:
69 | return false;
70 | case ValueKind.Number:
71 | return this.value > (other as NumberValue).value;
72 | default:
73 | throw new Error(`Unexpected value kind ${ValueKind[other.kind]}`);
74 | }
75 | }
76 |
77 | public add(other: BaseValue, engine: ExecutionEngine, instruction: AddInstruction): BaseValue {
78 | other = other.tryConvertToNumber();
79 |
80 | switch (other.kind) {
81 | case ValueKind.String:
82 | return new StringValue(this.value.toString() + (other as StringValue).value);
83 | case ValueKind.Number:
84 | return new NumberValue(this.value + (other as NumberValue).value);
85 | case ValueKind.Array:
86 | engine.terminate(new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, instruction.sourceRange, CompilerUtils.tokenToDisplayString(TokenKind.Plus)));
87 | return this;
88 | default:
89 | throw new Error(`Unexpected value kind ${ValueKind[other.kind]}`);
90 | }
91 | }
92 |
93 | public subtract(other: BaseValue, engine: ExecutionEngine, instruction: SubtractInstruction): BaseValue {
94 | other = other.tryConvertToNumber();
95 |
96 | switch (other.kind) {
97 | case ValueKind.String:
98 | engine.terminate(new Diagnostic(ErrorCode.CannotUseOperatorWithAString, instruction.sourceRange, CompilerUtils.tokenToDisplayString(TokenKind.Minus)));
99 | return this;
100 | case ValueKind.Number:
101 | return new NumberValue(this.value - (other as NumberValue).value);
102 | case ValueKind.Array:
103 | engine.terminate(new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, instruction.sourceRange, CompilerUtils.tokenToDisplayString(TokenKind.Minus)));
104 | return this;
105 | default:
106 | throw new Error(`Unexpected value kind ${ValueKind[other.kind]}`);
107 | }
108 | }
109 |
110 | public multiply(other: BaseValue, engine: ExecutionEngine, instruction: MultiplyInstruction): BaseValue {
111 | other = other.tryConvertToNumber();
112 |
113 | switch (other.kind) {
114 | case ValueKind.String:
115 | engine.terminate(new Diagnostic(ErrorCode.CannotUseOperatorWithAString, instruction.sourceRange, CompilerUtils.tokenToDisplayString(TokenKind.Multiply)));
116 | return this;
117 | case ValueKind.Number:
118 | return new NumberValue(this.value * (other as NumberValue).value);
119 | case ValueKind.Array:
120 | engine.terminate(new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, instruction.sourceRange, CompilerUtils.tokenToDisplayString(TokenKind.Multiply)));
121 | return this;
122 | default:
123 | throw new Error(`Unexpected value kind ${ValueKind[other.kind]}`);
124 | }
125 | }
126 |
127 | public divide(other: BaseValue, engine: ExecutionEngine, instruction: DivideInstruction): BaseValue {
128 | other = other.tryConvertToNumber();
129 |
130 | switch (other.kind) {
131 | case ValueKind.String:
132 | engine.terminate(new Diagnostic(ErrorCode.CannotUseOperatorWithAString, instruction.sourceRange, CompilerUtils.tokenToDisplayString(TokenKind.Divide)));
133 | return this;
134 | case ValueKind.Number:
135 | const otherValue = (other as NumberValue).value;
136 | if (otherValue === 0) {
137 | engine.terminate(new Diagnostic(ErrorCode.CannotDivideByZero, instruction.sourceRange));
138 | return this;
139 | } else {
140 | return new NumberValue(this.value / otherValue);
141 | }
142 | case ValueKind.Array:
143 | engine.terminate(new Diagnostic(ErrorCode.CannotUseOperatorWithAnArray, instruction.sourceRange, CompilerUtils.tokenToDisplayString(TokenKind.Divide)));
144 | return this;
145 | default:
146 | throw new Error(`Unexpected value kind ${ValueKind[other.kind]}`);
147 | }
148 | }
149 | }
150 |
--------------------------------------------------------------------------------
{EditorResources.Documentation_Header}
61 | -
62 | {CompilerUtils.values(RuntimeLibraries.Metadata).map(library => {
63 | return (
64 |
-
65 |
this.libraryClicked(library.typeName)).bind(this)}>{library.typeName}
66 |67 |102 |{library.description}
68 |-
69 | {CompilerUtils.values(library.properties).map(property => {
70 | return (
71 |
-
72 |
this.memberClicked(property.propertyName)).bind(this)}> 73 | {library.typeName}.{property.propertyName} 74 |
75 |76 |78 |{property.description}
77 |
79 | );
80 | })}
81 | {CompilerUtils.values(library.methods).map(method => {
82 | return (
83 | -
84 |
this.memberClicked(method.methodName)).bind(this)}> 85 | {method.typeName}.{method.methodName}({method.parameters.join(", ")}) 86 |
87 |88 |97 |{method.description}
89 |-
90 | {method.parameters.map(parameter =>
91 |
-
92 |
{parameter}: {method.parameterDescription(parameter)}
93 |
94 | )}
95 |
98 | );
99 | })}
100 | -
92 |
103 | );
104 | })}
105 | -
72 |