Skip to content

Commit a1a10b1

Browse files
author
Wangdahai
committed
cse-machine-version independent from js-slang
1 parent 9a3eceb commit a1a10b1

File tree

417 files changed

+86336
-5047
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

417 files changed

+86336
-5047
lines changed

‎.gitignore‎

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -80,7 +80,7 @@ typings/
8080

8181
# Nuxt.js build / generate output
8282
.nuxt
83-
dist
83+
# dist
8484

8585
# Gatsby files
8686
.cache/
@@ -107,4 +107,7 @@ dist
107107
.idea
108108

109109
# TypeScript build files
110-
build/
110+
build/
111+
112+
113+
.DS_Store

‎README.md‎

Lines changed: 1 addition & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -2,13 +2,7 @@
22

33
## What is py-slang?
44

5-
`py-slang` is a language frontend for the
6-
[js-slang](https://github.com/source-academy/js-slang) repository. It parses
7-
a restricted subset of Python (enough to complete SICP), and outputs an
8-
`estree`-compatible AST. [The grammar](./src/Grammar.gram) is a reduced
9-
version of [Python 3.7's](https://docs.python.org/3.7/reference/grammar.html).
10-
This project does not aim to be a full Python to JS transpiler, but aims
11-
to transpile just a small enough subset of Python.
5+
`py-slang` is a Python implementation developed specifically for the Source Academy online learning environment. Unlike previous versions where Python was treated as a subset within [js-slang](https://github.com/source-academy/js-slang), py-slang now stands as an independent language implementation. It features its own parser, csemachine, and runtime, designed to process a tailored subset of Python for educational purposes.
126

137
## Usage
148
For local testing:

‎dist/ast-types.d.ts‎

Lines changed: 234 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,234 @@
1+
import { Token } from "./tokenizer";
2+
import { PyComplexNumber } from "./types";
3+
export declare namespace ExprNS {
4+
interface Visitor<T> {
5+
visitBigIntLiteralExpr(expr: BigIntLiteral): T;
6+
visitBinaryExpr(expr: Binary): T;
7+
visitCompareExpr(expr: Compare): T;
8+
visitBoolOpExpr(expr: BoolOp): T;
9+
visitGroupingExpr(expr: Grouping): T;
10+
visitLiteralExpr(expr: Literal): T;
11+
visitUnaryExpr(expr: Unary): T;
12+
visitTernaryExpr(expr: Ternary): T;
13+
visitLambdaExpr(expr: Lambda): T;
14+
visitMultiLambdaExpr(expr: MultiLambda): T;
15+
visitVariableExpr(expr: Variable): T;
16+
visitCallExpr(expr: Call): T;
17+
visitComplexExpr(expr: Complex): T;
18+
visitNoneExpr(expr: None): T;
19+
}
20+
abstract class Expr {
21+
startToken: Token;
22+
endToken: Token;
23+
protected constructor(startToken: Token, endToken: Token);
24+
abstract accept(visitor: Visitor<any>): any;
25+
}
26+
class None extends Expr {
27+
constructor(startToken: Token, endToken: Token, value?: string);
28+
accept(visitor: Visitor<any>): any;
29+
}
30+
class BigIntLiteral extends Expr {
31+
value: string;
32+
constructor(startToken: Token, endToken: Token, value: string);
33+
accept(visitor: Visitor<any>): any;
34+
}
35+
class Complex extends Expr {
36+
value: PyComplexNumber;
37+
constructor(startToken: Token, endToken: Token, value: string);
38+
accept<T>(visitor: Visitor<T>): T;
39+
}
40+
class Binary extends Expr {
41+
left: Expr;
42+
operator: Token;
43+
right: Expr;
44+
constructor(startToken: Token, endToken: Token, left: Expr, operator: Token, right: Expr);
45+
accept(visitor: Visitor<any>): any;
46+
}
47+
class Compare extends Expr {
48+
left: Expr;
49+
operator: Token;
50+
right: Expr;
51+
constructor(startToken: Token, endToken: Token, left: Expr, operator: Token, right: Expr);
52+
accept(visitor: Visitor<any>): any;
53+
}
54+
class BoolOp extends Expr {
55+
left: Expr;
56+
operator: Token;
57+
right: Expr;
58+
constructor(startToken: Token, endToken: Token, left: Expr, operator: Token, right: Expr);
59+
accept(visitor: Visitor<any>): any;
60+
}
61+
class Grouping extends Expr {
62+
expression: Expr;
63+
constructor(startToken: Token, endToken: Token, expression: Expr);
64+
accept(visitor: Visitor<any>): any;
65+
}
66+
class Literal extends Expr {
67+
value: true | false | number | string;
68+
constructor(startToken: Token, endToken: Token, value: true | false | number | string);
69+
accept(visitor: Visitor<any>): any;
70+
}
71+
class Unary extends Expr {
72+
operator: Token;
73+
right: Expr;
74+
constructor(startToken: Token, endToken: Token, operator: Token, right: Expr);
75+
accept(visitor: Visitor<any>): any;
76+
}
77+
class Ternary extends Expr {
78+
predicate: Expr;
79+
consequent: Expr;
80+
alternative: Expr;
81+
constructor(startToken: Token, endToken: Token, predicate: Expr, consequent: Expr, alternative: Expr);
82+
accept(visitor: Visitor<any>): any;
83+
}
84+
class Lambda extends Expr {
85+
parameters: Token[];
86+
body: Expr;
87+
constructor(startToken: Token, endToken: Token, parameters: Token[], body: Expr);
88+
accept(visitor: Visitor<any>): any;
89+
}
90+
class MultiLambda extends Expr {
91+
parameters: Token[];
92+
body: StmtNS.Stmt[];
93+
varDecls: Token[];
94+
constructor(startToken: Token, endToken: Token, parameters: Token[], body: StmtNS.Stmt[], varDecls: Token[]);
95+
accept(visitor: Visitor<any>): any;
96+
}
97+
class Variable extends Expr {
98+
name: Token;
99+
constructor(startToken: Token, endToken: Token, name: Token);
100+
accept(visitor: Visitor<any>): any;
101+
}
102+
class Call extends Expr {
103+
callee: Expr;
104+
args: Expr[];
105+
constructor(startToken: Token, endToken: Token, callee: Expr, args: Expr[]);
106+
accept(visitor: Visitor<any>): any;
107+
}
108+
}
109+
export declare namespace StmtNS {
110+
interface Visitor<T> {
111+
visitIndentCreation(stmt: Indent): T;
112+
visitDedentCreation(stmt: Dedent): T;
113+
visitPassStmt(stmt: Pass): T;
114+
visitAssignStmt(stmt: Assign): T;
115+
visitAnnAssignStmt(stmt: AnnAssign): T;
116+
visitBreakStmt(stmt: Break): T;
117+
visitContinueStmt(stmt: Continue): T;
118+
visitReturnStmt(stmt: Return): T;
119+
visitFromImportStmt(stmt: FromImport): T;
120+
visitGlobalStmt(stmt: Global): T;
121+
visitNonLocalStmt(stmt: NonLocal): T;
122+
visitAssertStmt(stmt: Assert): T;
123+
visitIfStmt(stmt: If): T;
124+
visitWhileStmt(stmt: While): T;
125+
visitForStmt(stmt: For): T;
126+
visitFunctionDefStmt(stmt: FunctionDef): T;
127+
visitSimpleExprStmt(stmt: SimpleExpr): T;
128+
visitFileInputStmt(stmt: FileInput): T;
129+
}
130+
abstract class Stmt {
131+
startToken: Token;
132+
endToken: Token;
133+
protected constructor(startToken: Token, endToken: Token);
134+
abstract accept(visitor: Visitor<any>): any;
135+
}
136+
class Indent extends Stmt {
137+
constructor(startToken: Token, endToken: Token);
138+
accept(visitor: Visitor<any>): any;
139+
}
140+
class Dedent extends Stmt {
141+
constructor(startToken: Token, endToken: Token);
142+
accept(visitor: Visitor<any>): any;
143+
}
144+
class Pass extends Stmt {
145+
constructor(startToken: Token, endToken: Token);
146+
accept(visitor: Visitor<any>): any;
147+
}
148+
class Assign extends Stmt {
149+
name: Token;
150+
value: ExprNS.Expr;
151+
constructor(startToken: Token, endToken: Token, name: Token, value: ExprNS.Expr);
152+
accept(visitor: Visitor<any>): any;
153+
}
154+
class AnnAssign extends Stmt {
155+
name: Token;
156+
value: ExprNS.Expr;
157+
ann: ExprNS.Expr;
158+
constructor(startToken: Token, endToken: Token, name: Token, value: ExprNS.Expr, ann: ExprNS.Expr);
159+
accept(visitor: Visitor<any>): any;
160+
}
161+
class Break extends Stmt {
162+
constructor(startToken: Token, endToken: Token);
163+
accept(visitor: Visitor<any>): any;
164+
}
165+
class Continue extends Stmt {
166+
constructor(startToken: Token, endToken: Token);
167+
accept(visitor: Visitor<any>): any;
168+
}
169+
class Return extends Stmt {
170+
value: ExprNS.Expr | null;
171+
constructor(startToken: Token, endToken: Token, value: ExprNS.Expr | null);
172+
accept(visitor: Visitor<any>): any;
173+
}
174+
class FromImport extends Stmt {
175+
module: Token;
176+
names: Token[];
177+
constructor(startToken: Token, endToken: Token, module: Token, names: Token[]);
178+
accept(visitor: Visitor<any>): any;
179+
}
180+
class Global extends Stmt {
181+
name: Token;
182+
constructor(startToken: Token, endToken: Token, name: Token);
183+
accept(visitor: Visitor<any>): any;
184+
}
185+
class NonLocal extends Stmt {
186+
name: Token;
187+
constructor(startToken: Token, endToken: Token, name: Token);
188+
accept(visitor: Visitor<any>): any;
189+
}
190+
class Assert extends Stmt {
191+
value: ExprNS.Expr;
192+
constructor(startToken: Token, endToken: Token, value: ExprNS.Expr);
193+
accept(visitor: Visitor<any>): any;
194+
}
195+
class If extends Stmt {
196+
condition: ExprNS.Expr;
197+
body: Stmt[];
198+
elseBlock: Stmt[] | null;
199+
constructor(startToken: Token, endToken: Token, condition: ExprNS.Expr, body: Stmt[], elseBlock: Stmt[] | null);
200+
accept(visitor: Visitor<any>): any;
201+
}
202+
class While extends Stmt {
203+
condition: ExprNS.Expr;
204+
body: Stmt[];
205+
constructor(startToken: Token, endToken: Token, condition: ExprNS.Expr, body: Stmt[]);
206+
accept(visitor: Visitor<any>): any;
207+
}
208+
class For extends Stmt {
209+
target: Token;
210+
iter: ExprNS.Expr;
211+
body: Stmt[];
212+
constructor(startToken: Token, endToken: Token, target: Token, iter: ExprNS.Expr, body: Stmt[]);
213+
accept(visitor: Visitor<any>): any;
214+
}
215+
class FunctionDef extends Stmt {
216+
name: Token;
217+
parameters: Token[];
218+
body: Stmt[];
219+
varDecls: Token[];
220+
constructor(startToken: Token, endToken: Token, name: Token, parameters: Token[], body: Stmt[], varDecls: Token[]);
221+
accept(visitor: Visitor<any>): any;
222+
}
223+
class SimpleExpr extends Stmt {
224+
expression: ExprNS.Expr;
225+
constructor(startToken: Token, endToken: Token, expression: ExprNS.Expr);
226+
accept(visitor: Visitor<any>): any;
227+
}
228+
class FileInput extends Stmt {
229+
statements: Stmt[];
230+
varDecls: Token[];
231+
constructor(startToken: Token, endToken: Token, statements: Stmt[], varDecls: Token[]);
232+
accept(visitor: Visitor<any>): any;
233+
}
234+
}

‎dist/common/Constant.d.ts‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,4 @@
1+
export declare const enum Constant {
2+
PROTOCOL_VERSION = 0,
3+
PROTOCOL_MIN_VERSION = 0
4+
}

‎dist/common/ds/MessageQueue.d.ts‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
export declare class MessageQueue<T> {
2+
private readonly __inputQueue;
3+
private readonly __promiseQueue;
4+
push(item: T): void;
5+
pop(): Promise<T>;
6+
tryPop(): T | undefined;
7+
constructor();
8+
}

‎dist/common/ds/Queue.d.ts‎

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
/**
2+
* A stack-based queue implementation.
3+
* `push` and `pop` run in amortized constant time.
4+
*/
5+
export declare class Queue<T> {
6+
/** The output stack. */
7+
private __s1;
8+
/** The input stack. */
9+
private __s2;
10+
/**
11+
* Adds an item to the queue.
12+
* @param item The item to be added to the queue.
13+
*/
14+
push(item: T): void;
15+
/**
16+
* Removes an item from the queue.
17+
* @returns The item removed from the queue.
18+
* @throws If the queue is empty.
19+
*/
20+
pop(): T;
21+
/**
22+
* The length of the queue.
23+
*/
24+
get length(): number;
25+
/**
26+
* Makes a copy of the queue.
27+
* @returns A copy of the queue.
28+
*/
29+
clone(): Queue<T>;
30+
}

‎dist/common/ds/index.d.ts‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,2 @@
1+
export { MessageQueue } from "./MessageQueue";
2+
export { Queue } from "./Queue";

‎dist/common/errors/ConductorError.d.ts‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,9 @@
1+
import { ErrorType } from "./ErrorType";
2+
/**
3+
* Generic Conductor Error.
4+
*/
5+
export declare class ConductorError extends Error {
6+
name: string;
7+
readonly errorType: ErrorType | string;
8+
constructor(message: string);
9+
}

‎dist/common/errors/ConductorInternalError.d.ts‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
import { ConductorError } from "./ConductorError";
2+
import { ErrorType } from "./ErrorType";
3+
/**
4+
* Conductor internal error, probably caused by developer oversight.
5+
*/
6+
export declare class ConductorInternalError extends ConductorError {
7+
name: string;
8+
readonly errorType: ErrorType | string;
9+
constructor(message: string);
10+
}

‎dist/common/errors/ErrorType.d.ts‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
export declare const enum ErrorType {
2+
UNKNOWN = "__unknown",
3+
INTERNAL = "__internal",
4+
EVALUATOR = "__evaluator",
5+
EVALUATOR_SYNTAX = "__evaluator_syntax",
6+
EVALUATOR_TYPE = "__evaluator_type",
7+
EVALUATOR_RUNTIME = "__evaluator_runtime"
8+
}

0 commit comments

Comments
 (0)