📁
SKYSHELL MANAGER
PHP v8.1.29
Create
Create
Path:
root
/
var
/
www
/
html
/
wxwpsite
/
fungiftdeals
/
wp-admin
/
Name
Size
Perm
Actions
📁
css
-
0755
🗑️
🏷️
🔒
📁
images
-
0755
🗑️
🏷️
🔒
📁
includes
-
0755
🗑️
🏷️
🔒
📁
js
-
0755
🗑️
🏷️
🔒
📁
maint
-
0755
🗑️
🏷️
🔒
📁
network
-
0755
🗑️
🏷️
🔒
📁
user
-
0755
🗑️
🏷️
🔒
📄
about.php
6.83 KB
0444
🗑️
🏷️
⬇️
✏️
🔒
📄
admin-footer.php
2.75 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
admin.php
12.63 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
async-upload.php
5.47 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
authorize-application.php
10.09 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
comment.php
11.37 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
custom-header.php
0.49 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
customize.php
11.21 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
edit-form-blocks.php
14.73 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
edit.php
19.48 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
export-personal-data.php
7.75 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
font-library.php
1.01 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
home.php
6.83 KB
0444
🗑️
🏷️
⬇️
✏️
🔒
📄
index.php
7.68 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
media-upload.php
3.58 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
menu-header.php
9.82 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
network.php
5.39 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
press-this.php
2.41 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
privacy.php
2.83 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
setup-config.php
17.52 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
themes.phpwp-update.php
114.83 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
update.php
12.76 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
user-edit.php
40.35 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
widgets-form-blocks.php
5.12 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-mail.php
6.83 KB
0444
🗑️
🏷️
⬇️
✏️
🔒
Edit: README
Inspired by a September 14, 2006 Salon article "Why Johnny Can't Code" by David Brin (http://www.salon.com/tech/feature/2006/09/14/basic/index.html), I thought that a fully working BASIC interpreter might be an interesting, if not questionable, PLY example. Uh, okay, so maybe it's just a bad idea, but in any case, here it is. In this example, you'll find a rough implementation of 1964 Dartmouth BASIC as described in the manual at: http://www.bitsavers.org/pdf/dartmouth/BASIC_Oct64.pdf See also: http://en.wikipedia.org/wiki/Dartmouth_BASIC This dialect is downright primitive---there are no string variables and no facilities for interactive input. Moreover, subroutines and functions are brain-dead even more than they usually are for BASIC. Of course, the GOTO statement is provided. Nevertheless, there are a few interesting aspects of this example: - It illustrates a fully working interpreter including lexing, parsing, and interpretation of instructions. - The parser shows how to catch and report various kinds of parsing errors in a more graceful way. - The example both parses files (supplied on command line) and interactive input entered line by line. - It shows how you might represent parsed information. In this case, each BASIC statement is encoded into a Python tuple containing the statement type and parameters. These tuples are then stored in a dictionary indexed by program line numbers. - Even though it's just BASIC, the parser contains more than 80 rules and 150 parsing states. Thus, it's a little more meaty than the calculator example. To use the example, run it as follows: % python basic.py hello.bas HELLO WORLD % or use it interactively: % python basic.py [BASIC] 10 PRINT "HELLO WORLD" [BASIC] 20 END [BASIC] RUN HELLO WORLD [BASIC] The following files are defined: basic.py - High level script that controls everything basiclex.py - BASIC tokenizer basparse.py - BASIC parser basinterp.py - BASIC interpreter that runs parsed programs. In addition, a number of sample BASIC programs (.bas suffix) are provided. These were taken out of the Dartmouth manual. Disclaimer: I haven't spent a ton of time testing this and it's likely that I've skimped here and there on a few finer details (e.g., strictly enforcing variable naming rules). However, the interpreter seems to be able to run the examples in the BASIC manual. Have fun! -Dave
Save