Kill everything
This commit is contained in:
Paul Tagliamonte
parent
bfef42cc66
commit
f5836da2a5
11
AUTHORS
11
AUTHORS
|
|
@ -1,11 +0,0 @@
|
|||
Code contributors:
|
||||
|
||||
- Paul R. Tagliamonte <tag@pault.ag>
|
||||
- Gergely Nagy <algernon@madhouse-project.org>
|
||||
|
||||
I'd also like to thank the following people:
|
||||
|
||||
- Kragen Sitaker:
|
||||
Major thanks goes to Kragen on helping me work through some of the
|
||||
initial namespacing crap with the first (really functional) attempt
|
||||
at solving the problem.
|
||||
19
COPYRIGHT
19
COPYRIGHT
|
|
@ -1,19 +0,0 @@
|
|||
Copyright (c) 2010-2012 Paul Tagliamonte <tag@pault.ag>
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a
|
||||
copy of this software and associated documentation files (the "Software"),
|
||||
to deal in the Software without restriction, including without limitation
|
||||
the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
and/or sell copies of the Software, and to permit persons to whom the
|
||||
Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
DEALINGS IN THE SOFTWARE.
|
||||
4
REFACTOR
4
REFACTOR
|
|
@ -1,4 +0,0 @@
|
|||
|
||||
overhaul state stuff, machine stuff, revise to be smart
|
||||
|
||||
generate ast in a better way; use "prims" & macros to compile hy
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
#!/bin/sh
|
||||
"""":
|
||||
exec /usr/bin/env bpython -i $0 $@
|
||||
"""
|
||||
|
||||
import hy.lang.importer
|
||||
import sys
|
||||
|
||||
print "Hython is now importable!"
|
||||
28
bin/hython
28
bin/hython
|
|
@ -1,28 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
from hy.lang.importer import _hy_import_file
|
||||
|
||||
from code import InteractiveConsole
|
||||
import traceback
|
||||
import sys
|
||||
|
||||
try:
|
||||
import readline
|
||||
except ImportError:
|
||||
pass
|
||||
|
||||
if len(sys.argv) > 1:
|
||||
sys.argv = sys.argv[1:]
|
||||
mod = _hy_import_file(sys.argv[0], '__main__')
|
||||
sys.exit(0)
|
||||
|
||||
|
||||
InteractiveConsole().interact(banner="""
|
||||
"Really, if the lower orders don’t set us a good example, what on
|
||||
earth is the use of them?"
|
||||
|
||||
-- Oscar Wilde (The Importance of Being Earnest)
|
||||
|
||||
|
||||
The hython bits have been loaded -- magically, .hy
|
||||
files are importable!""")
|
||||
|
|
@ -1 +0,0 @@
|
|||
static/css
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
LESSC = lessc
|
||||
LESSCFLAGS = -x
|
||||
DEPLOYMENT = dev
|
||||
|
||||
all: clean build
|
||||
|
||||
STATIC=./static
|
||||
|
||||
clean:
|
||||
rm -rf $(STATIC)/css
|
||||
|
||||
build:
|
||||
mkdir $(STATIC)/css
|
||||
$(LESSC) $(LESSCFLAGS) less/debuild.me.less > $(STATIC)/css/debuild.css
|
||||
27
demo/app.py
27
demo/app.py
|
|
@ -1,27 +0,0 @@
|
|||
from hy.compiler.ast27 import forge_ast
|
||||
from hy.lex.tokenize import tokenize
|
||||
import codegen
|
||||
|
||||
from flask import Flask, render_template, request
|
||||
app = Flask(__name__)
|
||||
|
||||
|
||||
@app.route('/')
|
||||
def index():
|
||||
return render_template('index.html')
|
||||
|
||||
|
||||
@app.route('/translate', methods=['POST'])
|
||||
def translate():
|
||||
lines = request.form['code']
|
||||
|
||||
try:
|
||||
code = tokenize(lines)
|
||||
ast = forge_ast("stdin", code)
|
||||
return codegen.to_source(ast)
|
||||
except Exception as e:
|
||||
return str(e)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
app.run(debug=True)
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
#!/bin/bash
|
||||
|
||||
last=""
|
||||
while [ true ]; do
|
||||
now=$(find ./less -type f -printf "%T@ %Tx %TX %p\n" | sort -n -r | head -1)
|
||||
if [ "$last" != "$now" ]; then
|
||||
make >/dev/null
|
||||
echo "Updated."
|
||||
fi
|
||||
last=$now
|
||||
sleep 1
|
||||
done
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
@background-color: #DCDCDC;
|
||||
@color: #333333;
|
||||
|
||||
@link-color: #191921;
|
||||
|
||||
@nav-background-color: #333333;
|
||||
@nav-color: #EEEEEE;
|
||||
@nav-border: #FFFFFF;
|
||||
@nav-height: 50px;
|
||||
|
||||
@shadow-color: #333333;
|
||||
|
||||
@nav-from: #CACACA;
|
||||
@nav-to: #F5F5F5;
|
||||
|
||||
@table-zebra: #FFFFFF;
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
@import "config.less";
|
||||
|
||||
@import "macros.less";
|
||||
@import "font.less";
|
||||
|
||||
@import "layout.less";
|
||||
|
|
@ -1,32 +0,0 @@
|
|||
@font-face {
|
||||
font-family: 'Damion';
|
||||
font-style: normal;
|
||||
font-weight: 400;
|
||||
src: local('Damion'), url(../fonts/Damion.woff) format('woff');
|
||||
}
|
||||
|
||||
@font-face {
|
||||
font-family: 'Cantarel';
|
||||
font-style: normal;
|
||||
font-weight: 400;
|
||||
src: url(../fonts/cantarell.otf);
|
||||
}
|
||||
|
||||
@font-face {
|
||||
font-family: 'Quicksand';
|
||||
font-style: normal;
|
||||
font-weight: 400;
|
||||
src: local('Quicksand'), url(../fonts/Quicksand.woff) format('woff');
|
||||
}
|
||||
|
||||
.damion {
|
||||
font-family: 'Damion', cursive;
|
||||
}
|
||||
|
||||
.quicksand {
|
||||
font-family: 'Quicksand', sans-serif;
|
||||
}
|
||||
|
||||
.cantarell {
|
||||
font-family: 'Cantarel', sans-serif;
|
||||
}
|
||||
|
|
@ -1,146 +0,0 @@
|
|||
.noshim {
|
||||
padding: 0px;
|
||||
margin: 0px;
|
||||
}
|
||||
|
||||
html, body {
|
||||
background-color: @background-color;
|
||||
background-image: url(../imgs/texture.png);
|
||||
height: 100%;
|
||||
.noshim;
|
||||
.cantarell;
|
||||
}
|
||||
|
||||
pre {
|
||||
border-radius: 5px;
|
||||
background-color: #FFFFFF;
|
||||
padding: 10px;
|
||||
border: 1px solid darken(@background-color, 1%);
|
||||
}
|
||||
|
||||
.spacer {
|
||||
min-height: 30px;
|
||||
}
|
||||
|
||||
a {
|
||||
color: @link-color;
|
||||
}
|
||||
|
||||
ul {
|
||||
.noshim;
|
||||
list-style-type: none;
|
||||
}
|
||||
|
||||
table {
|
||||
width: 100%;
|
||||
.noshim;
|
||||
border-spacing: 0px;
|
||||
border-collapse: collapse;
|
||||
border: 1px solid darken(@background-color, 1%);
|
||||
tr {
|
||||
.noshim;
|
||||
td {
|
||||
.noshim;
|
||||
padding: 5px;
|
||||
}
|
||||
border-bottom: 1px solid darken(@background-color, 1%);
|
||||
}
|
||||
margin-top: 10px;
|
||||
margin-bottom: 10px;
|
||||
}
|
||||
|
||||
table.zebra {
|
||||
tr:nth-child(2n) {
|
||||
background-color: @table-zebra;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
.content {
|
||||
background-color: #F8F8F8;
|
||||
min-height: 70%;
|
||||
border-bottom: 1px solid #888888;
|
||||
padding-top: 30px;
|
||||
}
|
||||
|
||||
.container {
|
||||
margin-left: auto;
|
||||
margin-right: auto;
|
||||
width: 700px;
|
||||
}
|
||||
|
||||
.main-container {
|
||||
.container;
|
||||
padding-bottom: 50px;
|
||||
}
|
||||
|
||||
.shim {
|
||||
padding: 5px;
|
||||
}
|
||||
|
||||
.header {
|
||||
.color {
|
||||
width: 12.5%;
|
||||
height: 10px;
|
||||
float: left;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
.shadow {
|
||||
box-shadow: 5px 5px rgba(15,15,15,0.05);
|
||||
}
|
||||
|
||||
|
||||
.popover {
|
||||
position: fixed;
|
||||
height: 100%;
|
||||
width: 100%;
|
||||
.focus {
|
||||
.shadow;
|
||||
border: 1px solid #CCCCCC;
|
||||
background-color: #FFFFFF;
|
||||
border-radius: 5px;
|
||||
width: 90%;
|
||||
height: 85%;
|
||||
margin-left: auto;
|
||||
margin-right: auto;
|
||||
margin-top: 5%;
|
||||
}
|
||||
}
|
||||
|
||||
#repl-input {
|
||||
border-right: 1px solid #DDDDDD;
|
||||
}
|
||||
|
||||
.repl {
|
||||
height: 100%;
|
||||
padding: 3px;
|
||||
.repl-left {
|
||||
float: left;
|
||||
}
|
||||
.repl-right {
|
||||
float: right;
|
||||
}
|
||||
.repl-pane {
|
||||
padding: 0px;
|
||||
margin: 0px;
|
||||
border: 0px solid #000000;
|
||||
resize: none;
|
||||
width: 48%;
|
||||
height: 99%;
|
||||
}
|
||||
}
|
||||
|
||||
.logo {
|
||||
width: 100%;
|
||||
text-align: center;
|
||||
}
|
||||
|
||||
small {
|
||||
font-size: 0.5em;
|
||||
}
|
||||
|
||||
.clear {
|
||||
clear: both;
|
||||
}
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
.box-shadow(@style) {
|
||||
box-shadow: @style @shadow-color;
|
||||
-webkit-box-shadow: @style @shadow-color;
|
||||
-moz-box-shadow: @style @shadow-color;
|
||||
}
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
Before Width: | Height: | Size: 2.4 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 170 B |
File diff suppressed because one or more lines are too long
|
|
@ -1 +0,0 @@
|
|||
jquery-1.8.3.min.js
|
||||
|
|
@ -1,64 +0,0 @@
|
|||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<title>{% block title %}{% endblock %} | hy</title>
|
||||
<link rel = "stylesheet" href = "{{ url_for('static', filename='css/debuild.css') }}" ></link>
|
||||
<script src = '{{ url_for('static', filename='jquery.min.js') }}' ></script>
|
||||
<script type="text/javascript">
|
||||
function reload() {
|
||||
var input = $("#repl-input").val();
|
||||
console.log("Input: " + input);
|
||||
$('#repl-output').load(
|
||||
'/translate',
|
||||
{"code": input}
|
||||
);
|
||||
}
|
||||
|
||||
$(document).ready(function() {
|
||||
var count = 0;
|
||||
$("#repl-input").keyup(function(e) {
|
||||
var curcount;
|
||||
count = count + 1;
|
||||
curcount = count;
|
||||
|
||||
window.setTimeout(
|
||||
function() {
|
||||
if ( curcount == count ) {
|
||||
reload();
|
||||
} else {
|
||||
/* Pass. User is still typing */
|
||||
}
|
||||
},
|
||||
500
|
||||
);
|
||||
});
|
||||
reload();
|
||||
});
|
||||
</script>
|
||||
</head>
|
||||
<body>
|
||||
<div id = 'popshim' >
|
||||
<div class = 'popover' >
|
||||
<div class = 'focus' >
|
||||
<div class = 'repl' >
|
||||
<textarea id = 'repl-input' class = 'repl-pane repl-left' >
|
||||
(defn square [x]
|
||||
(* x x))
|
||||
|
||||
(print (square 4))
|
||||
</textarea>
|
||||
<pre
|
||||
id = 'repl-output'
|
||||
class = 'repl-pane repl-right'
|
||||
></pre>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<div class = 'logo' >
|
||||
<img src = '{{ url_for('static', filename='imgs/logo.png') }}' alt = 'hython' />
|
||||
</div>
|
||||
{% block content %}
|
||||
{% endblock %}
|
||||
</body>
|
||||
</html>
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
{% extends "base.html" %}
|
||||
|
||||
{% block title %}Welcome!{% endblock %}
|
||||
|
||||
{% block content %}
|
||||
{% endblock %}
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
; Copyright (c) Paul R. Tagliamonte <tag@pault.ag>, 2013 under the terms of
|
||||
; hy.
|
||||
|
||||
(import-from flask
|
||||
Flask render-template)
|
||||
|
||||
|
||||
(def app (Flask "__main__"))
|
||||
|
||||
|
||||
(decorate-with (.route app "/")
|
||||
(defn index []
|
||||
(render-template "index.html")))
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
import hy.lang.importer # NOQA
|
||||
from app import app
|
||||
|
||||
if __name__ == '__main__':
|
||||
app.run(debug=True)
|
||||
|
|
@ -1 +0,0 @@
|
|||
<h1>It works!</h1>
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
; vim: tabstop=2 expandtab shiftwidth=2 softtabstop=2 filetype=lisp
|
||||
; Copyright (c) Paul Tagliamonte, in sofar as any of this is at all
|
||||
; copyrightable.
|
||||
|
||||
(import "sunlight")
|
||||
|
||||
|
||||
(for [x (kwapply (sunlight.openstates.legislators) {"state" "ma"})]
|
||||
(print (index x "first_name")))
|
||||
|
|
@ -1,35 +0,0 @@
|
|||
(import sys) ; for arguments
|
||||
(import-from sh apt-cache) ; for apt-cache
|
||||
|
||||
|
||||
(def package "fluxbox")
|
||||
(if (> (len sys.argv) 1)
|
||||
(def package (index sys.argv 1)))
|
||||
|
||||
|
||||
(defn parse-rfc-822 [inpu]
|
||||
(do (def keys {})
|
||||
(def key None)
|
||||
(def val None)
|
||||
(for [x (.splitlines inpu)]
|
||||
(if (!= x "")
|
||||
(if (!= (index x 0) " ")
|
||||
(do (def kv (.split x ":" 1))
|
||||
(def key (.strip (index kv 0)))
|
||||
(set-index keys key (.strip (index kv 1))))
|
||||
(do
|
||||
(if (== x " .")
|
||||
(def x ""))
|
||||
(set-index keys key (+ (index keys key) "\n" (.strip x)))))))
|
||||
(dict keys)))
|
||||
|
||||
|
||||
(defn get-info [package]
|
||||
(parse-rfc-822 (.show apt-cache package)))
|
||||
|
||||
|
||||
(def data (get-info package))
|
||||
|
||||
(print "The maintainer for" package "is" (index data "Maintainer"))
|
||||
(print "")
|
||||
(print package "is a(n)" (index data "Description-en"))
|
||||
47
grammar.md
47
grammar.md
|
|
@ -1,47 +0,0 @@
|
|||
## Lexical syntax ##
|
||||
|
||||
OPEN-PAREN := '('
|
||||
|
||||
CLOSE-PAREN := ')'
|
||||
|
||||
OPEN-SQUARE := '['
|
||||
|
||||
CLOSE-SQUARE := ']'
|
||||
|
||||
OPEN-CURLY := '{'
|
||||
|
||||
CLOSE-CURLY := '}'
|
||||
|
||||
WHITESPACE := ' ' | '\t' | '\n' | '\r'
|
||||
|
||||
COMMENT := ';' ???
|
||||
|
||||
STRING := '"' ??? '"'
|
||||
|
||||
CONSTANT := '*' ??? '*'
|
||||
|
||||
BOOLEAN := 'true' | 'false'
|
||||
|
||||
SYMBOL := ???
|
||||
|
||||
NUMBER := ???
|
||||
|
||||
HASH := '#!' ???
|
||||
|
||||
|
||||
## Grammar ## ([example](http://docs.python.org/2/reference/grammar.html))
|
||||
|
||||
Hy := HASH | COMMENT | WHITESPACE | Expression
|
||||
|
||||
Expression := OPEN-PAREN Operator Args Close-Paren
|
||||
|
||||
Operator := ???
|
||||
|
||||
Args := Value(*)
|
||||
|
||||
List := OPEN-SQUARE Value(*) CLOSE-SQUARE
|
||||
|
||||
Map := OPEN-CURLY ( Value Value )(*) CLOSE-CURLY
|
||||
|
||||
Value := STRING | CONSTANT | BOOLEAN | SYMBOL | NUMBER | Expression | List | Map
|
||||
|
||||
|
|
@ -1,493 +0,0 @@
|
|||
# output ast for cpython 2.7
|
||||
import ast
|
||||
import imp
|
||||
|
||||
from hy.lang.expression import HYExpression
|
||||
from hy.lang.number import HYNumber
|
||||
from hy.lang.string import HYString
|
||||
from hy.lang.symbol import HYSymbol
|
||||
from hy.lang.list import HYList
|
||||
from hy.lang.bool import HYBool
|
||||
from hy.lang.map import HYMap
|
||||
|
||||
|
||||
def _ast_print(node, children, obj):
|
||||
""" Handle `print' statements """
|
||||
return ast.Print(dest=None, values=children, nl=True)
|
||||
|
||||
|
||||
def _ast_raise(node, children, obj):
|
||||
return ast.Raise(type=children[0])
|
||||
|
||||
|
||||
def _ast_binop(node, children, obj):
|
||||
""" Handle basic Binary ops """
|
||||
# operator = Add | Sub | Mult | Div | Mod | Pow | LShift
|
||||
# | RShift | BitOr | BitXor | BitAnd | FloorDiv
|
||||
# XXX: Add these folks in
|
||||
|
||||
inv = node.get_invocation()
|
||||
ops = {"+": ast.Add, "/": ast.Div, "*": ast.Mult, "-": ast.Sub}
|
||||
op = ops[inv['function']]
|
||||
left = children.pop(0)
|
||||
calc = None
|
||||
for child in children:
|
||||
calc = ast.BinOp(left=left, op=op(), right=child)
|
||||
left = calc
|
||||
return calc
|
||||
|
||||
|
||||
def _ast_cmp(node, children, obj):
|
||||
inv = node.get_invocation()
|
||||
ops = {
|
||||
"==": ast.Eq, "<=": ast.LtE, ">=": ast.GtE, ">": ast.Gt, "<": ast.Lt,
|
||||
"!=": ast.NotEq, "in": ast.In, "not-in": ast.NotIn, "is": ast.Is,
|
||||
"is-not": ast.IsNot
|
||||
}
|
||||
op = ops[inv['function']]
|
||||
left = children.pop(0)
|
||||
|
||||
cop = [op()] * len(children)
|
||||
return ast.Compare(left=left, ops=cop, comparators=children)
|
||||
|
||||
|
||||
def _ast_import(tree):
|
||||
i = tree.get_invocation()
|
||||
c = i['args']
|
||||
return ast.Import(names=[ast.alias(name=str(x), asname=None) for x in c])
|
||||
|
||||
|
||||
def _ast_import_from(tree):
|
||||
i = tree.get_invocation()
|
||||
c = i['args']
|
||||
mod = c.pop(0)
|
||||
return ast.ImportFrom(
|
||||
module=str(mod),
|
||||
names=[
|
||||
ast.alias(
|
||||
name=str(x),
|
||||
asname=None
|
||||
) for x in c
|
||||
],
|
||||
level=0
|
||||
)
|
||||
|
||||
|
||||
def _ast_if(node, children, obj):
|
||||
cond = children.pop(0)
|
||||
true = children.pop(0)
|
||||
flse = []
|
||||
if children != []:
|
||||
flse = children.pop(0)
|
||||
|
||||
true = true if isinstance(true, list) else [true]
|
||||
flse = flse if isinstance(flse, list) else [flse]
|
||||
|
||||
true = _adjust_body(true, do_ret=obj.in_fn)
|
||||
flse = _adjust_body(flse, do_ret=obj.in_fn)
|
||||
|
||||
ret = ast.If(test=cond, body=true, orelse=flse)
|
||||
return ret
|
||||
|
||||
|
||||
def _ast_do(node, children, obj):
|
||||
return children
|
||||
|
||||
|
||||
def _ast_return(node, children, obj):
|
||||
return ast.Return(value=children[-1])
|
||||
|
||||
|
||||
def _ast_yield(node, chile, obj):
|
||||
val = chile.pop(0)
|
||||
# XXX: Check to make sure chile is now []
|
||||
return ast.Yield(value=val)
|
||||
|
||||
|
||||
special_cases = {
|
||||
"print": _ast_print,
|
||||
|
||||
"+": _ast_binop, "/": _ast_binop,
|
||||
"-": _ast_binop, "*": _ast_binop,
|
||||
|
||||
"==": _ast_cmp, "<=": _ast_cmp,
|
||||
">=": _ast_cmp, "<": _ast_cmp,
|
||||
">": _ast_cmp, "!=": _ast_cmp,
|
||||
"in": _ast_cmp, "not-in": _ast_cmp,
|
||||
"is": _ast_cmp, "is-not": _ast_cmp,
|
||||
|
||||
"if": _ast_if,
|
||||
"do": _ast_do,
|
||||
"raise": _ast_raise,
|
||||
"yield": _ast_yield
|
||||
}
|
||||
|
||||
|
||||
def _meta_ast_subscript(val, sl, ctx):
|
||||
return ast.Subscript(value=val, slice=sl, ctx=ctx)
|
||||
|
||||
|
||||
class AST27Converter(object):
|
||||
""" Convert a lexed Hy tree into a Python AST for cpython 2.7 """
|
||||
|
||||
def __init__(self):
|
||||
self.table = {
|
||||
HYString: self.render_string,
|
||||
HYExpression: self.render_expression,
|
||||
HYNumber: self.render_number,
|
||||
HYSymbol: self.render_symbol,
|
||||
HYBool: self.render_bool,
|
||||
HYList: self.render_list,
|
||||
HYMap: self.render_map,
|
||||
}
|
||||
|
||||
self.startswith = {
|
||||
".": self._ast_dot
|
||||
}
|
||||
|
||||
self.native_cases = {
|
||||
"defn": self._defn,
|
||||
"fn": self._defn,
|
||||
"def": self._def,
|
||||
"import": _ast_import,
|
||||
|
||||
"import_from": _ast_import_from, # Remember, "-" --> "_"
|
||||
"decorate_with": self._ast_decorate,
|
||||
|
||||
"index": self._ast_index,
|
||||
"set_index": self._ast_set_index,
|
||||
"while": self._ast_while,
|
||||
|
||||
"doseq": self._ast_for,
|
||||
"for": self._ast_for,
|
||||
"kwapply": self._ast_kwapply,
|
||||
}
|
||||
self.special_types = {
|
||||
HYMap: self._ast_fn_index,
|
||||
HYList: self._ast_fn_index,
|
||||
}
|
||||
self.in_fn = False
|
||||
|
||||
def _ast_set_index(self, node):
|
||||
i = node.get_invocation()
|
||||
c = i['args']
|
||||
val = c.pop(0)
|
||||
sl = c.pop(0)
|
||||
tar = c.pop(0)
|
||||
|
||||
return ast.Assign(
|
||||
targets=[
|
||||
_meta_ast_subscript(
|
||||
self.render(val),
|
||||
ast.Index(value=self.render(sl)),
|
||||
ast.Store())
|
||||
],
|
||||
value=self.render(tar)
|
||||
)
|
||||
|
||||
def _ast_index(self, node):
|
||||
i = node.get_invocation()
|
||||
c = i['args']
|
||||
val = c.pop(0)
|
||||
tar = c.pop(0)
|
||||
|
||||
return _meta_ast_subscript(
|
||||
self.render(val),
|
||||
ast.Index(value=self.render(tar), ctx=ast.Load()),
|
||||
ast.Load())
|
||||
|
||||
def _ast_fn_index(self, node):
|
||||
i = node.get_invocation()
|
||||
cmd = ["index"]
|
||||
cmd.append(i['function'])
|
||||
cmd.extend(i['args'])
|
||||
return self.render_expression(HYExpression(cmd))
|
||||
|
||||
def _ast_dot(self, node):
|
||||
inv = node.get_invocation()
|
||||
args = inv['args']
|
||||
target = args.pop(0)
|
||||
attr = inv['function'][1:]
|
||||
|
||||
return ast.Call(
|
||||
func=ast.Attribute(
|
||||
value=self.render(target),
|
||||
attr=str(attr),
|
||||
ctx=ast.Load()
|
||||
),
|
||||
args=[self.render(x) for x in args],
|
||||
keywords=[],
|
||||
starargs=None,
|
||||
kwargs=None
|
||||
)
|
||||
|
||||
def _ast_decorate(self, node):
|
||||
i = node.get_invocation()
|
||||
c = i['args']
|
||||
meth = c.pop(-1)
|
||||
fn = self.render(meth)
|
||||
for chile in c:
|
||||
fn.decorator_list.append(self.render(chile))
|
||||
|
||||
return fn
|
||||
|
||||
def _def(self, node):
|
||||
""" For the `def` operator """
|
||||
inv = node.get_invocation()
|
||||
args = inv['args']
|
||||
name = args.pop(0)
|
||||
blob = self.render(args[0])
|
||||
|
||||
ret = ast.Assign(
|
||||
targets=[ast.Name(id=str(name), ctx=ast.Store())],
|
||||
value=blob
|
||||
)
|
||||
return ret
|
||||
|
||||
def _ast_kwapply(self, node):
|
||||
i = node.get_invocation()
|
||||
args = i['args']
|
||||
fn = args.pop(0)
|
||||
kwargs = args.pop(0)
|
||||
ret = self.render(fn)
|
||||
ret.keywords = [
|
||||
ast.keyword(
|
||||
arg=str(x),
|
||||
value=self.render(kwargs[x])
|
||||
) for x in kwargs
|
||||
]
|
||||
return ret
|
||||
|
||||
def _ast_while(self, node):
|
||||
i = node.get_invocation()
|
||||
args = i['args']
|
||||
test = args.pop(0)
|
||||
test = self.render(test)
|
||||
body = args.pop(0)
|
||||
body = self.render(body)
|
||||
body = body if isinstance(body, list) else [body]
|
||||
orel = []
|
||||
|
||||
body = _adjust_body(body, do_ret=self.in_fn)
|
||||
orel = _adjust_body(orel, do_ret=self.in_fn)
|
||||
|
||||
return ast.While(
|
||||
test=test,
|
||||
body=body,
|
||||
orelse=orel,
|
||||
)
|
||||
|
||||
def _ast_for(self, node):
|
||||
i = node.get_invocation()
|
||||
args = i['args']
|
||||
sig = args.pop(0)
|
||||
body = args.pop(0)
|
||||
aname, seq = sig
|
||||
|
||||
body = self.render(body)
|
||||
body = body if isinstance(body, list) else [body]
|
||||
orel = []
|
||||
|
||||
body = _adjust_body(body, do_ret=False)
|
||||
orel = _adjust_body(orel, do_ret=False)
|
||||
|
||||
return ast.For(
|
||||
target=ast.Name(id=str(aname), ctx=ast.Store()),
|
||||
iter=self.render(seq),
|
||||
body=body,
|
||||
orelse=orel,
|
||||
)
|
||||
|
||||
def _defn(self, node):
|
||||
""" For the defn operator """
|
||||
inv = node.get_invocation()
|
||||
args = inv['args']
|
||||
name = args.pop(0)
|
||||
sig = args.pop(0)
|
||||
doc = None
|
||||
|
||||
if type(args[0]) == HYString:
|
||||
doc = args.pop(0)
|
||||
|
||||
# verify child count...
|
||||
c = []
|
||||
_pop_fn = self.in_fn
|
||||
|
||||
self.in_fn = True
|
||||
for child in args:
|
||||
c.append(self.render(child))
|
||||
|
||||
self.in_fn = _pop_fn
|
||||
|
||||
cont = c[-1] # XXX: Wrong...
|
||||
body = cont if isinstance(cont, list) else [cont]
|
||||
|
||||
if doc:
|
||||
# Shim in docstrings
|
||||
body.insert(0, ast.Expr(value=ast.Str(s=str(doc))))
|
||||
|
||||
body = _adjust_body(body, do_ret=True)
|
||||
|
||||
ret = ast.FunctionDef(
|
||||
name=str(name),
|
||||
args=ast.arguments(
|
||||
args=[
|
||||
ast.Name(
|
||||
arg=str(x),
|
||||
id=str(x),
|
||||
ctx=ast.Param()
|
||||
) for x in sig
|
||||
],
|
||||
vararg=None,
|
||||
kwarg=None,
|
||||
kwonlyargs=[],
|
||||
kw_defaults=[],
|
||||
defaults=[]
|
||||
),
|
||||
body=body,
|
||||
decorator_list=[]
|
||||
)
|
||||
return ret
|
||||
|
||||
def render_string(self, node):
|
||||
""" Render a string to AST """
|
||||
return ast.Str(s=str(node))
|
||||
|
||||
def render_list(self, node):
|
||||
ret = []
|
||||
for c in node:
|
||||
ret.append(self.render(c))
|
||||
return ast.List(elts=ret, ctx=ast.Load())
|
||||
|
||||
def render_map(self, node):
|
||||
keys = []
|
||||
values = []
|
||||
for key in node:
|
||||
keys.append(self.render(key))
|
||||
values.append(self.render(node[key]))
|
||||
return ast.Dict(keys=keys, values=values)
|
||||
|
||||
def render_bool(self, node):
|
||||
""" Render a boolean to AST """
|
||||
thing = "True" if node._val else "False"
|
||||
return ast.Name(id=thing, ctx=ast.Load())
|
||||
|
||||
def render_symbol(self, node):
|
||||
""" Render a symbol to AST """
|
||||
# the only time we have a bare symbol is if we
|
||||
# deref it.
|
||||
if "." in node:
|
||||
glob, local = node.rsplit(".", 1)
|
||||
ret = ast.Attribute(
|
||||
value=self.render_symbol(glob),
|
||||
attr=str(local),
|
||||
ctx=ast.Load()
|
||||
)
|
||||
return ret
|
||||
|
||||
return ast.Name(id=str(node), ctx=ast.Load())
|
||||
|
||||
def render_number(self, node):
|
||||
""" Render a number to AST """
|
||||
return ast.Num(n=node)
|
||||
|
||||
def render_expression(self, node):
|
||||
""" Render an expression (function) to AST """
|
||||
|
||||
inv = node.get_invocation()
|
||||
|
||||
if type(inv['function']) in self.special_types:
|
||||
return self.special_types[type(inv['function'])](node)
|
||||
|
||||
if inv['function'] in self.native_cases:
|
||||
return self.native_cases[inv['function']](node)
|
||||
|
||||
for key in self.startswith:
|
||||
if inv['function'].startswith(key):
|
||||
return self.startswith[key](node)
|
||||
|
||||
c = []
|
||||
for child in node.get_children():
|
||||
c.append(self.render(child))
|
||||
|
||||
if inv['function'] in special_cases:
|
||||
return special_cases[inv['function']](node, c, self)
|
||||
|
||||
ret = ast.Call(
|
||||
func=self.render_symbol(inv['function']),
|
||||
args=c,
|
||||
keywords=[],
|
||||
starargs=None,
|
||||
kwargs=None
|
||||
)
|
||||
return ret
|
||||
|
||||
def render(self, tree):
|
||||
""" Entry point """
|
||||
t = type(tree)
|
||||
handler = self.table[t]
|
||||
ret = handler(tree)
|
||||
|
||||
def _correct_tree(_ast, tree):
|
||||
for node in ast.walk(_ast):
|
||||
node.lineno = tree.line
|
||||
node.col_offset = tree.column
|
||||
|
||||
if isinstance(ret, list):
|
||||
for r in ret:
|
||||
_correct_tree(r, tree)
|
||||
else:
|
||||
_correct_tree(ret, tree)
|
||||
|
||||
return ret
|
||||
|
||||
|
||||
def _adjust_body(at, do_ret=True):
|
||||
ret = []
|
||||
|
||||
first = True
|
||||
at.reverse()
|
||||
|
||||
for el in at:
|
||||
if not isinstance(el, ast.stmt):
|
||||
if first and do_ret:
|
||||
ret.append(ast.Return(
|
||||
value=el,
|
||||
lineno=el.lineno,
|
||||
col_offset=el.col_offset
|
||||
))
|
||||
else:
|
||||
ret.append(ast.Expr(
|
||||
value=el,
|
||||
lineno=el.lineno,
|
||||
col_offset=el.col_offset
|
||||
))
|
||||
else:
|
||||
ret.append(el)
|
||||
first = False
|
||||
|
||||
ret.reverse()
|
||||
return ret
|
||||
|
||||
|
||||
def forge_ast(name, forest):
|
||||
""" Make an AST for hacking with """
|
||||
conv = AST27Converter()
|
||||
|
||||
statements = []
|
||||
for tree in forest:
|
||||
ret = conv.render(tree)
|
||||
statements.append(ret)
|
||||
|
||||
statements = _adjust_body(statements, do_ret=False)
|
||||
|
||||
return ast.Module(body=statements)
|
||||
#return ast.fix_missing_locations(ast.Module(body=statements))
|
||||
|
||||
|
||||
def forge_module(name, fpath, forest):
|
||||
mod = imp.new_module(name)
|
||||
mod.__file__ = fpath
|
||||
ast = forge_ast(name, forest)
|
||||
eval(compile(ast, fpath, "exec"), mod.__dict__)
|
||||
return mod
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
from hy.lang.hyobj import HYObject
|
||||
|
||||
|
||||
class HYBool(HYObject):
|
||||
def __init__(self, val):
|
||||
self._val = val
|
||||
|
||||
def eval(self, lns, *args, **kwargs):
|
||||
return self._val is True
|
||||
|
|
@ -1,94 +0,0 @@
|
|||
#
|
||||
import sys
|
||||
from hy.lang.string import HYString
|
||||
|
||||
|
||||
def _define(obj, lns):
|
||||
fd = obj.get_invocation()
|
||||
args = fd['args']
|
||||
obj.namespace[args[0]] = args[1]()
|
||||
|
||||
|
||||
def _loop(obj, lns):
|
||||
fd = obj.get_invocation()
|
||||
args = fd['args']
|
||||
while True:
|
||||
for arg in args:
|
||||
arg.eval(lns.clone())
|
||||
|
||||
|
||||
def _fn(obj, lns, name=None):
|
||||
fd = obj.get_invocation()
|
||||
args = fd['args']
|
||||
sig = args[0]
|
||||
|
||||
docstring = None
|
||||
if isinstance(args[1], HYString):
|
||||
docstring = args.pop(1)
|
||||
|
||||
meth = args[1]
|
||||
|
||||
def _(*args, **kwargs):
|
||||
l = lns.clone()
|
||||
for i in range(0, len(sig)):
|
||||
name = sig[i]
|
||||
value = args[i]
|
||||
l[name] = value
|
||||
|
||||
ret = meth.eval(l, *args, **kwargs)
|
||||
return ret
|
||||
|
||||
_.__name__ = "hyfn"
|
||||
if name:
|
||||
_.__name__ = name
|
||||
|
||||
_.__doc__ = docstring
|
||||
return _
|
||||
|
||||
|
||||
def _kwapply(obj, lns):
|
||||
fd = obj.get_invocation()
|
||||
subshell, kwargs = fd['args']
|
||||
return subshell.eval(lns.clone(), **kwargs)
|
||||
|
||||
|
||||
def _import(obj, lns):
|
||||
ns = obj.namespace
|
||||
fd = obj.get_invocation()
|
||||
args = fd['args']
|
||||
mods = args[0]
|
||||
|
||||
for module in mods:
|
||||
basename = module.split(".", 1)[0]
|
||||
mod = __import__(module)
|
||||
sys.modules[module] = mod
|
||||
ns[basename] = mod
|
||||
|
||||
|
||||
def _progn(obj, lns):
|
||||
fd = obj.get_invocation()
|
||||
args = fd['args']
|
||||
ret = []
|
||||
for arg in args:
|
||||
ret.append(arg.eval(lns.clone()))
|
||||
return ret
|
||||
|
||||
|
||||
def _if(obj, lns):
|
||||
fd = obj.get_invocation()
|
||||
args = fd['args']
|
||||
if args[0].eval(lns.clone()):
|
||||
return args[1].eval(lns.clone())
|
||||
else:
|
||||
return args[2].eval(lns.clone())
|
||||
|
||||
|
||||
builtins = {
|
||||
"def": _define,
|
||||
"fn": _fn,
|
||||
"import": _import,
|
||||
"kwapply": _kwapply,
|
||||
"if": _if,
|
||||
"loop": _loop,
|
||||
"progn": _progn,
|
||||
}
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
from hy.lang.hyobj import HYObject
|
||||
from hy.lang.builtins import builtins
|
||||
|
||||
|
||||
class HYExpression(HYObject, list):
|
||||
def __init__(self, nodes):
|
||||
self += nodes
|
||||
|
||||
def get_children(self):
|
||||
ret = []
|
||||
for node in self.get_invocation()['args']:
|
||||
ret.append(node)
|
||||
return ret
|
||||
|
||||
def get_invocation(self):
|
||||
fn = self[0] if len(self) > 0 else ""
|
||||
args = self[1:] if len(self) > 1 else []
|
||||
|
||||
return {
|
||||
"function": fn,
|
||||
"args": args,
|
||||
}
|
||||
|
||||
def peek(self):
|
||||
return self.get_invocation()['function']
|
||||
|
||||
def eval(self, lns, *args, **kwargs):
|
||||
fn = self.peek()
|
||||
|
||||
if fn in builtins:
|
||||
# special-case builtin handling.
|
||||
return builtins[fn](self, lns)
|
||||
|
||||
things = []
|
||||
for child in self.get_children():
|
||||
c = child.copy()
|
||||
things.append(c.eval(lns.clone()))
|
||||
|
||||
ret = self.lookup(lns, fn)(*things, **kwargs)
|
||||
return ret
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
from hy.lang.internals import HYNamespaceCOW
|
||||
|
||||
|
||||
class HYObject(object):
|
||||
def set_namespace(self, ns):
|
||||
self.namespace = ns
|
||||
for c in self.get_children():
|
||||
c.set_namespace(ns)
|
||||
|
||||
def get_children(self):
|
||||
return []
|
||||
|
||||
def __call__(self, *args, **kwargs):
|
||||
ns = HYNamespaceCOW({}) # Each invocation needs it's own ns
|
||||
return self.eval(ns, *args, **kwargs)
|
||||
|
||||
def lookup(self, lns, fn):
|
||||
if fn in lns:
|
||||
return lns[fn]
|
||||
|
||||
if fn in self.namespace:
|
||||
return self.namespace[fn]
|
||||
|
||||
if fn in self.namespace['__builtins__']:
|
||||
return self.namespace['__builtins__'][fn]
|
||||
# builtin lookup
|
||||
|
||||
if "." in fn:
|
||||
lon, short = fn.rsplit(".", 1)
|
||||
holder = self.lookup(lns, lon)
|
||||
return getattr(holder, short)
|
||||
|
||||
raise Exception("No such symbol: `%s`" % (fn))
|
||||
|
||||
def eval(self, lns, *args, **kwargs):
|
||||
for node in self.get_children():
|
||||
node.eval(lns, *args, **kwargs)
|
||||
return self
|
||||
|
||||
def _issue_job(self, job, *args, **kwargs):
|
||||
pass
|
||||
|
||||
def _join(self):
|
||||
pass
|
||||
|
||||
def copy(self):
|
||||
new = type(self)(self)
|
||||
new.set_namespace(self.namespace)
|
||||
return new
|
||||
|
|
@ -1,77 +0,0 @@
|
|||
# from hy.compiler.modfaker import forge_module
|
||||
from hy.compiler.ast27 import forge_module
|
||||
|
||||
from hy.lex.tokenize import tokenize
|
||||
import sys
|
||||
import os
|
||||
|
||||
|
||||
def _hy_import_file(fd, name):
|
||||
m = forge_module(
|
||||
name,
|
||||
fd,
|
||||
tokenize(open(fd, 'r').read())
|
||||
)
|
||||
return m
|
||||
|
||||
|
||||
class HyFinder(object):
|
||||
def is_package(self, fullname):
|
||||
dirpath = "/".join(fullname.split("."))
|
||||
for pth in sys.path:
|
||||
pth = os.path.abspath(pth)
|
||||
composed_path = "%s/%s/__init__.hy" % (pth, dirpath)
|
||||
if os.path.exists(composed_path):
|
||||
return True
|
||||
return False
|
||||
|
||||
def find_on_path(self, fullname):
|
||||
fls = ["%s/__init__.hy", "%s.hy"]
|
||||
dirpath = "/".join(fullname.split("."))
|
||||
|
||||
for pth in sys.path:
|
||||
pth = os.path.abspath(pth)
|
||||
for fp in fls:
|
||||
composed_path = fp % ("%s/%s" % (pth, dirpath))
|
||||
if os.path.exists(composed_path):
|
||||
return composed_path
|
||||
|
||||
|
||||
class MetaLoader(HyFinder):
|
||||
def load_module(self, fullname):
|
||||
if fullname in sys.modules:
|
||||
return sys.modules[fullname]
|
||||
|
||||
pth = self.find_on_path(fullname)
|
||||
if pth is None:
|
||||
return
|
||||
|
||||
sys.modules[fullname] = None
|
||||
mod = _hy_import_file(pth, fullname)
|
||||
|
||||
ispkg = self.is_package(fullname)
|
||||
|
||||
mod.__file__ = pth
|
||||
mod.__loader__ = self
|
||||
mod.__name__ = fullname
|
||||
|
||||
if ispkg:
|
||||
mod.__path__ = []
|
||||
mod.__package__ = fullname
|
||||
else:
|
||||
mod.__package__ = fullname.rpartition('.')[0]
|
||||
|
||||
sys.modules[fullname] = mod
|
||||
return mod
|
||||
|
||||
|
||||
class MetaImporter(HyFinder):
|
||||
def find_module(self, fullname, path=None):
|
||||
pth = self.find_on_path(fullname)
|
||||
if pth is None:
|
||||
return
|
||||
return MetaLoader()
|
||||
|
||||
|
||||
sys.meta_path.append(MetaImporter())
|
||||
sys.path.insert(0, "")
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
#
|
||||
|
||||
|
||||
class HYNamespaceCOW(object):
|
||||
def __init__(self, inmutable_copy):
|
||||
self._inmute = inmutable_copy
|
||||
self._mute = {}
|
||||
|
||||
def __contains__(self, key):
|
||||
if key in self._mute:
|
||||
return True
|
||||
return key in self._inmute
|
||||
|
||||
def __getitem__(self, key):
|
||||
if key in self._mute:
|
||||
return self._mute[key]
|
||||
return self._inmute[key]
|
||||
|
||||
def __setitem__(self, key, value):
|
||||
self._mute[key] = value
|
||||
|
||||
def clone(self):
|
||||
return HYNamespaceCOW(self)
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
from hy.lang.hyobj import HYObject
|
||||
|
||||
|
||||
class HYList(HYObject, list):
|
||||
def __init__(self, nodes):
|
||||
[self.append(node) for node in nodes]
|
||||
|
||||
def get_children(self):
|
||||
return self
|
||||
|
||||
def eval(self, ln, *args, **kwargs):
|
||||
ret = []
|
||||
for node in self.get_children():
|
||||
ret.append(node.eval(ln, *args, **kwargs))
|
||||
return ret
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
from hy.lang.hyobj import HYObject
|
||||
|
||||
|
||||
class HYMap(HYObject, dict):
|
||||
def __init__(self, nodes):
|
||||
for node in nodes:
|
||||
self[node] = nodes[node]
|
||||
|
||||
def get_children(self):
|
||||
ret = []
|
||||
for v in self.keys():
|
||||
ret.append(v)
|
||||
for v in self.values():
|
||||
ret.append(v)
|
||||
return ret
|
||||
|
|
@ -1,137 +0,0 @@
|
|||
from hy.lex.tokenize import tokenize as _hy_tok
|
||||
import sys
|
||||
|
||||
|
||||
def _print(*args, **kwargs):
|
||||
sys.stdout.write(" ".join([str(x) for x in args]) + "\n")
|
||||
sys.stdout.flush()
|
||||
|
||||
|
||||
def _read(*args):
|
||||
return sys.stdin.readline()
|
||||
|
||||
|
||||
def _lex(*args):
|
||||
ret = []
|
||||
for thing in args:
|
||||
ret.append(_hy_tok(thing))
|
||||
return ret
|
||||
|
||||
|
||||
def _foreach(*args):
|
||||
a = args[0]
|
||||
for arg in a:
|
||||
args[1](arg)
|
||||
|
||||
|
||||
def _get(*args):
|
||||
m = args[0]
|
||||
k = args[1]
|
||||
if k in m:
|
||||
return m[k]
|
||||
else:
|
||||
if len(args) > 2:
|
||||
return args[2]
|
||||
raise KeyError("No such key `%s` in map." % (k))
|
||||
|
||||
|
||||
def _plus(*args):
|
||||
ret = args[0]
|
||||
args = args[1:]
|
||||
for x in args:
|
||||
ret += x
|
||||
return ret
|
||||
|
||||
|
||||
def _subtract(*args):
|
||||
ret = args[0]
|
||||
args = args[1:]
|
||||
for x in args:
|
||||
ret -= x
|
||||
return ret
|
||||
|
||||
|
||||
def _mult(*args):
|
||||
ret = args[0]
|
||||
args = args[1:]
|
||||
for x in args:
|
||||
ret *= x
|
||||
return ret
|
||||
|
||||
|
||||
def _divide(*args):
|
||||
ret = args[0]
|
||||
args = args[1:]
|
||||
for x in args:
|
||||
ret /= x
|
||||
return ret
|
||||
|
||||
|
||||
def _eq(*args):
|
||||
car, cdr = args[0], args[1:]
|
||||
for arg in cdr:
|
||||
if arg != car:
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def _ne(*args):
|
||||
seen = set()
|
||||
for arg in args:
|
||||
if arg in seen:
|
||||
return False
|
||||
seen.add(arg)
|
||||
return True
|
||||
|
||||
|
||||
def _gt(*args):
|
||||
for i in range(1, len(args)):
|
||||
if not (args[i - 1] > args[i]):
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def _ge(*args):
|
||||
for i in range(1, len(args)):
|
||||
if not (args[i - 1] >= args[i]):
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def _le(*args):
|
||||
for i in range(1, len(args)):
|
||||
if not (args[i - 1] <= args[i]):
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def _lt(*args):
|
||||
for i in range(1, len(args)):
|
||||
if not (args[i - 1] < args[i]):
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def _throw(*args):
|
||||
raise args[0]
|
||||
|
||||
|
||||
natives = {
|
||||
"print": _print,
|
||||
"puts": _print,
|
||||
"+": _plus,
|
||||
"-": _subtract,
|
||||
"*": _mult,
|
||||
"/": _divide,
|
||||
"==": _eq,
|
||||
">": _gt,
|
||||
">=": _ge,
|
||||
"<": _lt,
|
||||
"<=": _le,
|
||||
"!=": _ne,
|
||||
"lex": _lex,
|
||||
"read": _read,
|
||||
"foreach": _foreach,
|
||||
"get": _get,
|
||||
"throw": _throw
|
||||
}
|
||||
|
|
@ -1,10 +0,0 @@
|
|||
from hy.lang.hyobj import HYObject
|
||||
|
||||
|
||||
class HYNumber(HYObject, int):
|
||||
def __new__(cls, number, *args, **kwargs):
|
||||
number = int(number)
|
||||
return super(HYNumber, cls).__new__(cls, number)
|
||||
|
||||
def eval(self, lns, *args, **kwargs):
|
||||
return int(self)
|
||||
|
|
@ -1,17 +0,0 @@
|
|||
from hy.lang.hyobj import HYObject
|
||||
import sys
|
||||
|
||||
|
||||
if sys.version_info[0] >= 3:
|
||||
_str_type = str
|
||||
else:
|
||||
_str_type = unicode
|
||||
|
||||
|
||||
class HYString(HYObject, _str_type):
|
||||
def __new__(cls, value):
|
||||
obj = _str_type.__new__(cls, value)
|
||||
return obj
|
||||
|
||||
def eval(self, ln, *args, **kwargs):
|
||||
return str(self)
|
||||
|
|
@ -1,10 +0,0 @@
|
|||
from hy.lang.string import HYString
|
||||
|
||||
|
||||
class HYSymbol(HYString):
|
||||
def __init__(self, string):
|
||||
self += string
|
||||
|
||||
def eval(self, lns, *args, **kwargs):
|
||||
obj = self.lookup(lns, self)
|
||||
return obj
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
class LexException(Exception):
|
||||
pass
|
||||
|
|
@ -1,29 +0,0 @@
|
|||
class Machine(object):
|
||||
def __init__(self, state):
|
||||
# print "New machine: %s" % (state)
|
||||
self.nodes = []
|
||||
self.state = state(self)
|
||||
self.state.enter()
|
||||
self.line = 1
|
||||
self.column = 1
|
||||
|
||||
def add_node(self, node):
|
||||
node.line = self.line
|
||||
node.column = self.column
|
||||
self.nodes.append(node)
|
||||
|
||||
def process(self, buf):
|
||||
for i in range(0, len(buf)):
|
||||
char = buf[i]
|
||||
|
||||
self.column += 1
|
||||
if char == "\n":
|
||||
self.line += 1
|
||||
self.column = 0
|
||||
|
||||
nx = self.state.process(char)
|
||||
if nx:
|
||||
# print "New state: %s" % (nx)
|
||||
self.state.exit()
|
||||
self.state = nx(self)
|
||||
self.state.enter()
|
||||
250
hy/lex/states.py
250
hy/lex/states.py
|
|
@ -1,250 +0,0 @@
|
|||
from hy.lang.expression import HYExpression
|
||||
from hy.lex.errors import LexException
|
||||
from hy.lang.string import HYString
|
||||
from hy.lang.symbol import HYSymbol
|
||||
from hy.lang.number import HYNumber
|
||||
from hy.lex.machine import Machine
|
||||
from hy.lang.list import HYList
|
||||
from hy.lang.bool import HYBool
|
||||
from hy.lang.map import HYMap
|
||||
|
||||
|
||||
WHITESPACE = [" ", "\t", "\n", "\r"]
|
||||
|
||||
|
||||
def _resolve_atom(value, self):
|
||||
def _mangle(obj):
|
||||
obj.line = self.machine.line
|
||||
obj.column = self.machine.column
|
||||
return obj
|
||||
|
||||
if value == "true":
|
||||
return _mangle(HYBool(True))
|
||||
elif value == "false":
|
||||
return _mangle(HYBool(False))
|
||||
|
||||
try:
|
||||
return _mangle(HYNumber(value))
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
# LISP Variants tend to use *foo* for constants. Let's make it
|
||||
# the more pythonic "FOO"
|
||||
if value.startswith("*") and value.endswith("*") and len(value) > 1:
|
||||
value = value.upper()[1:-1]
|
||||
|
||||
# LISP Variants have a tendency to use "-" in symbols n' shit.
|
||||
if value != "-": # we need subtraction
|
||||
value = value.replace("-", "_")
|
||||
|
||||
return _mangle(HYSymbol(value))
|
||||
|
||||
|
||||
class State(object):
|
||||
def __init__(self, machine):
|
||||
self.machine = machine
|
||||
self.sub_machine = None
|
||||
|
||||
def enter(self):
|
||||
pass
|
||||
|
||||
def exit(self):
|
||||
pass
|
||||
|
||||
def sub(self, machine):
|
||||
self.sub_machine = Machine(machine)
|
||||
|
||||
def process(self, x):
|
||||
if self.sub_machine:
|
||||
self.sub_machine.process(x)
|
||||
idle = type(self.sub_machine.state) == Idle
|
||||
if idle:
|
||||
self.nodes += self.sub_machine.nodes
|
||||
self.sub_machine = None
|
||||
return
|
||||
|
||||
return self.p(x)
|
||||
|
||||
|
||||
class Comment(State):
|
||||
def p(self, x):
|
||||
if x == '\n':
|
||||
return Idle
|
||||
|
||||
|
||||
class Idle(State):
|
||||
def p(self, x):
|
||||
if x == "#":
|
||||
return HashExpression
|
||||
if x == ";":
|
||||
return Comment
|
||||
if x == "(":
|
||||
return Expression
|
||||
if x in WHITESPACE:
|
||||
return
|
||||
|
||||
raise LexException("Unknown char: %s" % (x))
|
||||
|
||||
|
||||
class HashExpression(State):
|
||||
def p(self, x):
|
||||
if x == "!":
|
||||
return Comment
|
||||
|
||||
raise LexException("Unknwon Hash modifier - %s" % (x))
|
||||
|
||||
|
||||
class Expression(State):
|
||||
def enter(self):
|
||||
self.nodes = HYExpression([])
|
||||
self.bulk = ""
|
||||
|
||||
def exit(self):
|
||||
if self.bulk:
|
||||
self.nodes.append(_resolve_atom(self.bulk, self))
|
||||
|
||||
self.machine.add_node(self.nodes)
|
||||
|
||||
def commit(self):
|
||||
if self.bulk.strip() != "":
|
||||
self.nodes.append(_resolve_atom(self.bulk, self))
|
||||
self.bulk = ""
|
||||
|
||||
def p(self, x):
|
||||
if x == ")":
|
||||
return Idle
|
||||
if x in WHITESPACE:
|
||||
self.commit()
|
||||
return
|
||||
if x == "\"":
|
||||
self.sub(String)
|
||||
return
|
||||
if x == "(":
|
||||
self.sub(Expression)
|
||||
return
|
||||
if x == "[":
|
||||
self.sub(List)
|
||||
return
|
||||
if x == "{":
|
||||
self.sub(Map)
|
||||
return
|
||||
if x == ";":
|
||||
self.sub(Comment)
|
||||
return
|
||||
self.bulk += x
|
||||
|
||||
|
||||
class List(State):
|
||||
def enter(self):
|
||||
self.nodes = HYList([])
|
||||
self.bulk = ""
|
||||
|
||||
def exit(self):
|
||||
if self.bulk:
|
||||
self.nodes.append(_resolve_atom(self.bulk, self))
|
||||
self.machine.add_node(self.nodes)
|
||||
|
||||
def commit(self):
|
||||
if self.bulk.strip() != "":
|
||||
self.nodes.append(_resolve_atom(self.bulk, self))
|
||||
self.bulk = ""
|
||||
|
||||
def p(self, x):
|
||||
if x == "]":
|
||||
return Idle
|
||||
if x in WHITESPACE:
|
||||
self.commit()
|
||||
return
|
||||
if x == "\"":
|
||||
self.sub(String)
|
||||
return
|
||||
if x == "[":
|
||||
self.sub(List)
|
||||
return
|
||||
if x == "(":
|
||||
self.sub(Expression)
|
||||
return
|
||||
if x == "{":
|
||||
self.sub(Map)
|
||||
return
|
||||
if x == ";":
|
||||
self.sub(Comment)
|
||||
return
|
||||
self.bulk += x
|
||||
|
||||
|
||||
class Map(State):
|
||||
def enter(self):
|
||||
self.nodes = []
|
||||
self.bulk = ""
|
||||
|
||||
def exit(self):
|
||||
if self.bulk:
|
||||
self.nodes.append(_resolve_atom(self.bulk, self))
|
||||
|
||||
if (len(self.nodes) % 2) != 0:
|
||||
raise LexException("Hash map is screwed up")
|
||||
|
||||
ret = HYMap({})
|
||||
i = iter(self.nodes)
|
||||
hmap = zip(i, i)
|
||||
for key, val in hmap:
|
||||
ret[key] = val
|
||||
self.machine.add_node(ret)
|
||||
|
||||
def commit(self):
|
||||
if self.bulk.strip() != "":
|
||||
self.nodes.append(_resolve_atom(self.bulk, self))
|
||||
self.bulk = ""
|
||||
|
||||
def p(self, x):
|
||||
if x == "}":
|
||||
return Idle
|
||||
if x in WHITESPACE:
|
||||
self.commit()
|
||||
return
|
||||
if x == "\"":
|
||||
self.sub(String)
|
||||
return
|
||||
if x == "[":
|
||||
self.sub(List)
|
||||
return
|
||||
if x == "{":
|
||||
self.sub(Map)
|
||||
return
|
||||
if x == "(":
|
||||
self.sub(Expression)
|
||||
return
|
||||
if x == ";":
|
||||
self.sub(Comment)
|
||||
return
|
||||
self.bulk += x
|
||||
|
||||
|
||||
class String(State):
|
||||
magic = {"n": "\n", "t": "\t", "\\": "\\", "\"": "\""}
|
||||
|
||||
def enter(self):
|
||||
self.buf = ""
|
||||
self.esc = False
|
||||
|
||||
def exit(self):
|
||||
self.machine.add_node(HYString(self.buf))
|
||||
|
||||
def p(self, x):
|
||||
if x == "\\":
|
||||
self.esc = True
|
||||
return
|
||||
|
||||
if x == "\"" and not self.esc:
|
||||
return Idle
|
||||
|
||||
if self.esc and x not in self.magic:
|
||||
raise LexException("Unknown escape: \\%s" % (x))
|
||||
|
||||
elif self.esc:
|
||||
x = self.magic[x]
|
||||
|
||||
self.esc = False
|
||||
|
||||
self.buf += x
|
||||
|
|
@ -1,11 +0,0 @@
|
|||
from hy.lex.machine import Machine
|
||||
from hy.lex.states import Idle
|
||||
from hy.lex.errors import LexException
|
||||
|
||||
|
||||
def tokenize(buff):
|
||||
m = Machine(Idle)
|
||||
m.process(buff)
|
||||
if type(m.state) != Idle:
|
||||
raise LexException("Reached end of file before we were done parsing")
|
||||
return m.nodes
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
#!/bin/bash
|
||||
|
||||
echo "Pulling repo."
|
||||
ssh metatron.pault.ag "cd /srv/www/uwsgi/app/hy; git pull"
|
||||
ssh -l www metatron.pault.ag "kill-apps; start-apps"
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
flake8
|
||||
nose
|
||||
coverage
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
[nosetests]
|
||||
detailed-errors=1
|
||||
with-coverage=1
|
||||
cover-package=hy
|
||||
nocapture=1
|
||||
32
setup.py
32
setup.py
|
|
@ -1,32 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
from setuptools import setup
|
||||
|
||||
long_description = """This thing does stuff and
|
||||
things with other things until things looks like other
|
||||
things. """
|
||||
|
||||
appname = "hy"
|
||||
version = "0.8.2"
|
||||
|
||||
setup(**{
|
||||
"name": appname,
|
||||
"version": version,
|
||||
"packages": [
|
||||
'hy',
|
||||
'hy.lang',
|
||||
'hy.lex',
|
||||
'hy.compiler'
|
||||
],
|
||||
"author": "Paul Tagliamonte",
|
||||
"author_email": "tag@pault.ag",
|
||||
"long_description": long_description,
|
||||
"description": 'lisp and python love eachother',
|
||||
"license": "Expat",
|
||||
"url": "http://hy.pault.ag/",
|
||||
"platforms": ['any'],
|
||||
"scripts": [
|
||||
"bin/hython",
|
||||
"bin/bhython"
|
||||
]
|
||||
})
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
(defn test-map-index []
|
||||
({"foo" "bar"} "foo"))
|
||||
|
||||
(defn test-list-index []
|
||||
(["first" "second"] 1))
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
; vim: tabstop=2 expandtab shiftwidth=2 softtabstop=2 filetype=lisp
|
||||
|
||||
(defn square [arg]
|
||||
(* arg arg))
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
; vim: tabstop=2 expandtab shiftwidth=2 softtabstop=2 filetype=lisp
|
||||
|
||||
(import "tests.lang.test_kwargs")
|
||||
|
||||
(defn kiwi []
|
||||
(kwapply (tests.lang.test_kwargs.shim "one" "two") {
|
||||
"three" "three"
|
||||
"four" "four"
|
||||
}))
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
from hy.lex.tokenize import tokenize
|
||||
from hy.lang.expression import HYExpression
|
||||
|
||||
code = """
|
||||
(+ 1 1) ; this is a test.
|
||||
(fn foo bar) ; this is a test.
|
||||
"""
|
||||
|
||||
|
||||
def test_basics():
|
||||
"""Test the basics"""
|
||||
assert {
|
||||
"function": "fn",
|
||||
"args": [
|
||||
"one"
|
||||
]
|
||||
} == HYExpression(["fn", "one"]).get_invocation()
|
||||
|
||||
|
||||
def test_fn_split():
|
||||
"""Test if we can get a statement something right."""
|
||||
one, two = tokenize(code)
|
||||
assert one.get_invocation() == {
|
||||
"function": "+",
|
||||
"args": [
|
||||
1, 1
|
||||
]
|
||||
}
|
||||
assert two.get_invocation() == {
|
||||
"function": "fn",
|
||||
"args": [
|
||||
"foo", "bar"
|
||||
]
|
||||
}
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
import hy.lang.importer
|
||||
import tests.lang.foo
|
||||
|
||||
|
||||
def square(x):
|
||||
return x * x
|
||||
|
||||
|
||||
def test_squares_properly():
|
||||
assert tests.lang.foo.square
|
||||
assert tests.lang.foo.square(2) == 4
|
||||
for x in range(0, 10):
|
||||
tests.lang.foo.square(x)
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
import hy.lang.importer
|
||||
|
||||
|
||||
def shim(*args, **kwargs):
|
||||
return {"a": args,
|
||||
"k": kwargs}
|
||||
|
||||
|
||||
def test_kwargs_proper():
|
||||
import tests.lang.kwargs
|
||||
val = tests.lang.kwargs.kiwi()
|
||||
assert val == {
|
||||
"a": ('one', 'two'),
|
||||
"k": {
|
||||
"three": "three",
|
||||
"four": "four"
|
||||
}
|
||||
}
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
from hy.lex.tokenize import tokenize
|
||||
|
||||
def test_map_lex():
|
||||
assert tokenize('(def {"foo" "bar"})') == [['def', {'foo': 'bar'}]]
|
||||
|
||||
|
||||
def test_map_lex():
|
||||
assert tokenize('(def {"foo" "bar" "baz" {"one" "two"}})') == [
|
||||
['def', {
|
||||
'foo': 'bar',
|
||||
'baz': {
|
||||
"one": "two"
|
||||
}
|
||||
}]
|
||||
]
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
import tests.lang.colls
|
||||
|
||||
def test_map_index():
|
||||
assert tests.lang.colls.test_map_index() == "bar"
|
||||
|
||||
def test_list_index():
|
||||
assert tests.lang.colls.test_list_index() == "second"
|
||||
|
|
@ -1,80 +0,0 @@
|
|||
from hy.lex.tokenize import tokenize
|
||||
|
||||
|
||||
def test_simple_tokenize():
|
||||
"""Checking we can still handle something simple."""
|
||||
|
||||
assert [["+", 1, 1]] == tokenize("(+ 1 1)")
|
||||
|
||||
|
||||
def test_double_tokenize():
|
||||
"""Checking if we can lex two things at once."""
|
||||
|
||||
assert [
|
||||
["+", 1, 2],
|
||||
["-", 1, 1]
|
||||
] == tokenize("(+ 1 2) (- 1 1)")
|
||||
|
||||
|
||||
def test_simple_recurse():
|
||||
""" Test recursion """
|
||||
assert [
|
||||
['fn',
|
||||
'one',
|
||||
['fn', 'two'],
|
||||
]
|
||||
] == tokenize("(fn one (fn two))")
|
||||
|
||||
|
||||
def test_mid_recurse():
|
||||
""" Test some crazy recursion """
|
||||
|
||||
assert [
|
||||
['fn',
|
||||
'one',
|
||||
['fn', 'two'],
|
||||
['fn', 'three'],
|
||||
]
|
||||
] == tokenize("(fn one (fn two)(fn three))")
|
||||
|
||||
|
||||
def test_mid_recurse_comment():
|
||||
""" Test some crazy recursion with a comment """
|
||||
|
||||
assert [
|
||||
['fn',
|
||||
'one',
|
||||
['fn', 'two'],
|
||||
['fn', 'three'],
|
||||
]
|
||||
] == tokenize("""
|
||||
(fn one ; this is a test
|
||||
(fn two)(fn three)) ; and so is this
|
||||
""")
|
||||
|
||||
|
||||
def test_full_recurse():
|
||||
""" Test something we could see for real """
|
||||
assert [
|
||||
['fn',
|
||||
'el',
|
||||
['+',
|
||||
1,
|
||||
2,
|
||||
['==',
|
||||
1,
|
||||
20
|
||||
],
|
||||
['-',
|
||||
1,
|
||||
1
|
||||
],
|
||||
]
|
||||
],
|
||||
['fn1', 'foo', 'bar']
|
||||
] == tokenize("(fn el (+ 1 2 (== 1 20) (- 1 1)))(fn1 foo bar)")
|
||||
|
||||
|
||||
def test_string():
|
||||
""" Lex a lone string """
|
||||
assert ['"a string"'] == tokenize('"a string"')
|
||||
|
|
@ -1,44 +0,0 @@
|
|||
from hy.lex.tokenize import tokenize
|
||||
|
||||
|
||||
def test_list_lex():
|
||||
"""test basic lexing of lists"""
|
||||
fn = tokenize("(fn [1 2 3 4])")[0]
|
||||
assert fn == [
|
||||
"fn", [1, 2, 3, 4]
|
||||
]
|
||||
|
||||
|
||||
def test_list_recurse():
|
||||
""" test we can recurse lists """
|
||||
fn = tokenize("(fn [1 2 3 4 [5 6 7]])")[0]
|
||||
assert fn == [
|
||||
"fn", [1, 2, 3, 4, [5, 6, 7]]
|
||||
]
|
||||
|
||||
|
||||
def test_double_rainbow():
|
||||
""" DOUBLE LISTS """
|
||||
fn = tokenize("(fn [1 2 3 4] [5 6 7])")[0]
|
||||
assert fn == [
|
||||
"fn", [1, 2, 3, 4], [5, 6, 7]
|
||||
]
|
||||
|
||||
|
||||
def test_string_in_list():
|
||||
""" String in list """
|
||||
fn = tokenize('(fn [1 2 "three four" 5])')[0]
|
||||
assert fn == [
|
||||
"fn", [1, 2, "three four", 5]
|
||||
]
|
||||
|
||||
|
||||
def test_list_recurse_with_comment():
|
||||
""" test we can recurse lists """
|
||||
fn = tokenize("""
|
||||
(fn [1 ; this is a test
|
||||
2 3 4 [5 6 7]])
|
||||
""")[0]
|
||||
assert fn == [
|
||||
"fn", [1, 2, 3, 4, [5, 6, 7]]
|
||||
]
|
||||
Loading…
Reference in New Issue