emfrp 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 739151824444ba84586ec87772d5cbb30bb2157c
+  data.tar.gz: 76b48e983b31abd5459cea456f68976af359fa0f
+SHA512:
+  metadata.gz: 1b77eb4ab6596bcb41269a2b72fc22ad28b8137895c604ef013e0b7047677698b2bce41396c5b84eb0f535fdb5de6c9447773f4e66d953b21702a838c79e8de3
+  data.tar.gz: 73353f055c801bb8b2841651137b75112f1f96c94b93ffe2979c3e7a8a4eaadb36a7727ca3f65a494a3ab7c3fcbdd71b9af34a95a8025628a894751970dcff60

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in emfrp.gemspec
+gemspec
+colorize
+parser_combinator

data/LICENSE

@@ -0,0 +1,28 @@
+Copyright (c) 2015, Kensuke Sawada
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,27 @@
+# Emfrp
+
+Pure Functional Programming with your microcomputer.
+
+# Requirement
+
+* Ruby2.0 or later (and it's Gem client)
+
+## Installation
+You can get executables via RubyGems.
+```sh
+$ gem install emfrp
+```
+
+# Command-line-interpreter (REPL)
+```sh
+$ emfrpi
+```
+
+# Compiler
+```sh
+$ emfrp <src-file>
+```
+
+## Usage
+
+In prepraration...

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/emfrp

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'emfrp'
+
+unless ARGV[0]
+  puts "usage: emfrp <emfrp-module-file-path>"
+  exit(1)
+end
+
+begin
+  inter = Emfrp::Interpreter.new(Emfrp::IncludeDirs, STDOUT, ARGV[0])
+  if inter.compile_default()
+    exit(1)
+  end
+rescue Emfrp::Interpreter::InterpreterError
+  exit(1)
+rescue Emfrp::FileLoader::FileLoadError => err
+  puts err.message
+  exit(1)
+end

data/bin/emfrpi

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'emfrp'
+require 'readline'
+
+begin
+  inter = Emfrp::Interpreter.new(Emfrp::IncludeDirs, STDOUT, ARGV[0] || "Std")
+  Readline.completion_proc = inter.completion_proc
+  while true
+    input = Readline.readline("emfrpi:#{inter.current_readline_id}> ", true)
+    if input == nil
+      inter.close()
+      exit(0)
+    else
+      inter.process_repl_line(input)
+    end
+  end
+rescue Emfrp::Interpreter::InterpreterError
+  exit(1)
+rescue Emfrp::FileLoader::FileLoadError => err
+  puts err.message
+  exit(1)
+end

data/emfrp.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'emfrp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "emfrp"
+  spec.version       = Emfrp::VERSION
+  spec.authors       = ["Kensuke Sawada"]
+  spec.email         = ["sasasawada@gmail.com"]
+  spec.summary       = %q{A compier of Emfrp, a FRP language for small embeded systems.}
+  spec.description   = %q{Pure Functional Programming with your microcomputer.}
+  spec.homepage      = ""
+  spec.license       = "The BSD 3-Clause License"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "colorize", ">= 0.7.7"
+  spec.add_dependency "parser_combinator", ">= 0.0.3"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/examples/LCDPositioner/LCDPositioner.c

@@ -0,0 +1,278 @@
+#include "LCDPositioner.h"
+/* Primitive functions (Macros) */
+#define _plus_(a, b) (a + b)
+#define _anpersand_anpersand(a, b) (a && b)
+#define _eq__eq_(a, b) (a == b)
+#define _parcent_(a, b) (a % b)
+#define boolToInt(a) (a)
+#define _minus_(a, b) (a - b)
+/* Data types */
+struct Tuple2_Int_Int{
+  int mark;
+  union {
+    struct {
+      int member0;
+      int member1;
+    }Tuple2;
+  }value;
+};
+struct Tuple2_Bool_Int{
+  int mark;
+  union {
+    struct {
+      int member0;
+      int member1;
+    }Tuple2;
+  }value;
+};
+/* Global variables */
+int node_memory_up[2];
+int node_memory_down[2];
+int node_memory_left[2];
+int node_memory_right[2];
+int node_memory_pulse10ms[2];
+struct Tuple2_Bool_Int* node_memory_k[2];
+int node_memory_dx[2];
+int node_memory_dy[2];
+int node_memory_pulse40ms[2];
+int node_memory_pulse40msCount[2];
+struct Tuple2_Int_Int* node_memory_pos[2];
+int node_memory_x[2];
+int node_memory_y[2];
+struct Tuple2_Bool_Int memory_Tuple2_Bool_Int[2];
+int size_Tuple2_Bool_Int = 2;
+int counter_Tuple2_Bool_Int = 0;
+struct Tuple2_Int_Int memory_Tuple2_Int_Int[2];
+int size_Tuple2_Int_Int = 2;
+int counter_Tuple2_Int_Int = 0;
+int Counter = 1;
+int NodeSize = 8;
+/* Static prototypes */
+static struct Tuple2_Int_Int* Tuple2_0(int, int);
+static void mark_Tuple2_Int_Int(struct Tuple2_Int_Int*, int);
+static struct Tuple2_Bool_Int* Tuple2_1(int, int);
+static void mark_Tuple2_Bool_Int(struct Tuple2_Bool_Int*, int);
+static int node_k(int, int, struct Tuple2_Bool_Int**);
+static struct Tuple2_Bool_Int* init_k();
+static int node_dx(int, int, int*);
+static int node_dy(int, int, int*);
+static int node_pulse40ms(struct Tuple2_Bool_Int*, int*);
+static int init_pulse40ms();
+static int node_pulse40msCount(struct Tuple2_Bool_Int*, int*);
+static int init_pulse40msCount();
+static int node_pos(int, int, int, int, int, struct Tuple2_Int_Int*, struct Tuple2_Int_Int**);
+static struct Tuple2_Int_Int* init_pos();
+static int node_x(struct Tuple2_Int_Int*, int*);
+static int init_x();
+static int node_y(struct Tuple2_Int_Int*, int*);
+static int init_y();
+static void refreshMark();
+extern void Input(int*, int*, int*, int*, int*);
+extern void Output(int*, int*);
+/* Functions, Constructors, GCMarkers, etc... */
+static struct Tuple2_Int_Int* Tuple2_0(int member0, int member1) {
+  struct Tuple2_Int_Int* x;
+  while (1) {
+    counter_Tuple2_Int_Int++;
+    counter_Tuple2_Int_Int %= size_Tuple2_Int_Int;
+    if (memory_Tuple2_Int_Int[counter_Tuple2_Int_Int].mark < Counter) { x = memory_Tuple2_Int_Int + counter_Tuple2_Int_Int; break; }
+  }
+  x->value.Tuple2.member0 = member0;
+  x->value.Tuple2.member1 = member1;
+  return x;
+}
+static void mark_Tuple2_Int_Int(struct Tuple2_Int_Int* x, int mark) {
+  x->mark = mark;
+}
+static struct Tuple2_Bool_Int* Tuple2_1(int member0, int member1) {
+  struct Tuple2_Bool_Int* x;
+  while (1) {
+    counter_Tuple2_Bool_Int++;
+    counter_Tuple2_Bool_Int %= size_Tuple2_Bool_Int;
+    if (memory_Tuple2_Bool_Int[counter_Tuple2_Bool_Int].mark < Counter) { x = memory_Tuple2_Bool_Int + counter_Tuple2_Bool_Int; break; }
+  }
+  x->value.Tuple2.member0 = member0;
+  x->value.Tuple2.member1 = member1;
+  return x;
+}
+static void mark_Tuple2_Bool_Int(struct Tuple2_Bool_Int* x, int mark) {
+  x->mark = mark;
+}
+static int node_k(int pulse10ms, int pulse40msCount_at_last, struct Tuple2_Bool_Int** output) {
+  int _tmp001;
+  struct Tuple2_Bool_Int* _tmp000;
+  _tmp001 = _parcent_(_plus_(pulse40msCount_at_last, boolToInt(pulse10ms)), 4);
+  if (1) {
+    int pvar0_c = _tmp001;
+    _tmp000 = Tuple2_1(_anpersand_anpersand(_eq__eq_(pvar0_c, 0), pulse10ms), pvar0_c);
+  }
+  *output = _tmp000;
+  return 1;
+}
+static struct Tuple2_Bool_Int* init_k() {
+  return Tuple2_1(0, 0);
+}
+static int node_dx(int right, int left, int* output) {
+  *output = _minus_(boolToInt(right), boolToInt(left));
+  return 1;
+}
+static int node_dy(int down, int up, int* output) {
+  *output = _minus_(boolToInt(down), boolToInt(up));
+  return 1;
+}
+static int node_pulse40ms(struct Tuple2_Bool_Int* k, int* output) {
+  int _tmp002;
+  if (1) {
+    struct Tuple2_Bool_Int* pvar1_k = k;
+    int pvar1_pulse40ms = k->value.Tuple2.member0;
+    int pvar1_pulse40msCount = k->value.Tuple2.member1;
+    _tmp002 = pvar1_pulse40ms;
+  }
+  *output = _tmp002;
+  return 1;
+}
+static int init_pulse40ms() {
+  struct Tuple2_Bool_Int* _tmp004;
+  int _tmp003;
+  _tmp004 = Tuple2_1(0, 0);
+  if (1) {
+    struct Tuple2_Bool_Int* pvar2_k = _tmp004;
+    int pvar2_pulse40ms = _tmp004->value.Tuple2.member0;
+    int pvar2_pulse40msCount = _tmp004->value.Tuple2.member1;
+    _tmp003 = pvar2_pulse40ms;
+  }
+  return _tmp003;
+}
+static int node_pulse40msCount(struct Tuple2_Bool_Int* k, int* output) {
+  int _tmp005;
+  if (1) {
+    struct Tuple2_Bool_Int* pvar3_k = k;
+    int pvar3_pulse40ms = k->value.Tuple2.member0;
+    int pvar3_pulse40msCount = k->value.Tuple2.member1;
+    _tmp005 = pvar3_pulse40msCount;
+  }
+  *output = _tmp005;
+  return 1;
+}
+static int init_pulse40msCount() {
+  struct Tuple2_Bool_Int* _tmp007;
+  int _tmp006;
+  _tmp007 = Tuple2_1(0, 0);
+  if (1) {
+    struct Tuple2_Bool_Int* pvar4_k = _tmp007;
+    int pvar4_pulse40ms = _tmp007->value.Tuple2.member0;
+    int pvar4_pulse40msCount = _tmp007->value.Tuple2.member1;
+    _tmp006 = pvar4_pulse40msCount;
+  }
+  return _tmp006;
+}
+static int node_pos(int pulse40ms, int x_at_last, int dx, int y_at_last, int dy, struct Tuple2_Int_Int* pos_at_last, struct Tuple2_Int_Int** output) {
+  struct Tuple2_Int_Int* _tmp008;
+  if (pulse40ms == 1) {
+    _tmp008 = Tuple2_0(_plus_(x_at_last, dx), _plus_(y_at_last, dy));
+  }
+  else if (pulse40ms == 0) {
+    _tmp008 = pos_at_last;
+  }
+  *output = _tmp008;
+  return 1;
+}
+static struct Tuple2_Int_Int* init_pos() {
+  return Tuple2_0(0, 0);
+}
+static int node_x(struct Tuple2_Int_Int* pos, int* output) {
+  int _tmp009;
+  if (1) {
+    struct Tuple2_Int_Int* pvar5_pos = pos;
+    int pvar5_x = pos->value.Tuple2.member0;
+    int pvar5_y = pos->value.Tuple2.member1;
+    _tmp009 = pvar5_x;
+  }
+  *output = _tmp009;
+  return 1;
+}
+static int init_x() {
+  struct Tuple2_Int_Int* _tmp011;
+  int _tmp010;
+  _tmp011 = Tuple2_0(0, 0);
+  if (1) {
+    struct Tuple2_Int_Int* pvar6_pos = _tmp011;
+    int pvar6_x = _tmp011->value.Tuple2.member0;
+    int pvar6_y = _tmp011->value.Tuple2.member1;
+    _tmp010 = pvar6_x;
+  }
+  return _tmp010;
+}
+static int node_y(struct Tuple2_Int_Int* pos, int* output) {
+  int _tmp012;
+  if (1) {
+    struct Tuple2_Int_Int* pvar7_pos = pos;
+    int pvar7_x = pos->value.Tuple2.member0;
+    int pvar7_y = pos->value.Tuple2.member1;
+    _tmp012 = pvar7_y;
+  }
+  *output = _tmp012;
+  return 1;
+}
+static int init_y() {
+  struct Tuple2_Int_Int* _tmp014;
+  int _tmp013;
+  _tmp014 = Tuple2_0(0, 0);
+  if (1) {
+    struct Tuple2_Int_Int* pvar8_pos = _tmp014;
+    int pvar8_x = _tmp014->value.Tuple2.member0;
+    int pvar8_y = _tmp014->value.Tuple2.member1;
+    _tmp013 = pvar8_y;
+  }
+  return _tmp013;
+}
+static void refreshMark() {
+  int i;
+  for (i = 0; i < size_Tuple2_Bool_Int; i++) {
+    if (memory_Tuple2_Bool_Int[i].mark < Counter) memory_Tuple2_Bool_Int[i].mark = 0;
+    else memory_Tuple2_Bool_Int[i].mark -= Counter - 1;
+  }
+  for (i = 0; i < size_Tuple2_Int_Int; i++) {
+    if (memory_Tuple2_Int_Int[i].mark < Counter) memory_Tuple2_Int_Int[i].mark = 0;
+    else memory_Tuple2_Int_Int[i].mark -= Counter - 1;
+  }
+}
+void ActivateLCDPositioner() {
+  int current_side = 0, last_side = 1;
+  node_memory_k[last_side] = init_k();
+  mark_Tuple2_Bool_Int(node_memory_k[last_side], 0);
+  node_memory_pulse40ms[last_side] = init_pulse40ms();
+  node_memory_pulse40msCount[last_side] = init_pulse40msCount();
+  node_memory_pos[last_side] = init_pos();
+  mark_Tuple2_Int_Int(node_memory_pos[last_side], 6);
+  node_memory_x[last_side] = init_x();
+  node_memory_y[last_side] = init_y();
+  Counter = NodeSize + 1;
+  refreshMark();
+  while (1) {
+    Counter = 1;
+    Input(&node_memory_up[current_side], &node_memory_down[current_side], &node_memory_left[current_side], &node_memory_right[current_side], &node_memory_pulse10ms[current_side]);
+    node_k(node_memory_pulse10ms[current_side], node_memory_pulse40msCount[last_side], &node_memory_k[current_side]);
+    mark_Tuple2_Bool_Int(node_memory_k[current_side], Counter + 4);
+    Counter++;
+    node_dx(node_memory_right[current_side], node_memory_left[current_side], &node_memory_dx[current_side]);
+    Counter++;
+    node_dy(node_memory_down[current_side], node_memory_up[current_side], &node_memory_dy[current_side]);
+    Counter++;
+    node_pulse40ms(node_memory_k[current_side], &node_memory_pulse40ms[current_side]);
+    Counter++;
+    node_pulse40msCount(node_memory_k[current_side], &node_memory_pulse40msCount[current_side]);
+    Counter++;
+    node_pos(node_memory_pulse40ms[current_side], node_memory_x[last_side], node_memory_dx[current_side], node_memory_y[last_side], node_memory_dy[current_side], node_memory_pos[last_side], &node_memory_pos[current_side]);
+    mark_Tuple2_Int_Int(node_memory_pos[current_side], Counter + 8);
+    Counter++;
+    node_x(node_memory_pos[current_side], &node_memory_x[current_side]);
+    Counter++;
+    node_y(node_memory_pos[current_side], &node_memory_y[current_side]);
+    Counter++;
+    Output(&node_memory_x[current_side], &node_memory_y[current_side]);
+    refreshMark();
+    current_side ^= 1;
+    last_side ^= 1;
+  }
+}

data/examples/LCDPositioner/LCDPositioner.h

@@ -0,0 +1,6 @@
+#ifndef LCDPOSITIONER_H
+#define LCDPOSITIONER_H
+
+void ActivateLCDPositioner();
+
+#endif /* end of include guard */

data/examples/LCDPositioner/LCDPositioner.mfrp

@@ -0,0 +1,30 @@
+module LCDPositioner
+in
+  up : Bool,
+  down : Bool,
+  left : Bool,
+  right : Bool,
+  pulse10ms : Bool
+out
+  x, y
+use
+  Std
+
+node dy = down.boolToInt - up.boolToInt
+node dx = right.boolToInt - left.boolToInt
+
+node init[(False, 0)] (pulse40ms, pulse40msCount) as pulse = {
+  c = (pulse40msCount@last + pulse10ms.boolToInt) % 4
+  (c == 0 && pulse10ms, c)
+}
+
+node init[(0,0)] (x, y) as pos =
+  if pulse40ms then (x@last + dx, y@last + dy) else pos@last
+
+
+#@ :assert-module
+#-   True, False, False, False, True => 0, 0
+#@ : True, False, False, False, True => 0, 0
+#@ : True, False, False, False, True => 0, 0
+#@ : True, False, False, False, True => 0, -1
+#@ : True, False, False, False, True => 0, -1

data/examples/LCDPositioner/LCDPositionerMain.c

@@ -0,0 +1,15 @@
+#include "LCDPositioner.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+void Input(int* up, int* down, int* left, int* right, int* pulse10ms) {
+  if (scanf("%d %d %d %d %d", up, down, left, right, pulse10ms) == EOF) {
+    exit(0);
+  }
+}
+void Output(int* x, int* y) {
+  printf("%d %d\n", *x, *y);
+}
+int main() {
+  ActivateLCDPositioner();
+}

data/examples/LCDPositioner/LCDPositionerMain.c.gen

@@ -0,0 +1,11 @@
+#include "LCDPositioner.h"
+
+void Input(int* up, int* down, int* left, int* right, int* pulse10ms) {
+  /* Your code goes here... */
+}
+void Output(int* x, int* y) {
+  /* Your code goes here... */
+}
+int main() {
+  ActivateLCDPositioner();
+}

data/examples/LCDPositioner/graph.dot

@@ -0,0 +1,31 @@
+digraph LCDPositioner {
+  pulse10ms [label = "pulse10ms : Bool", shape = "invhouse"];
+  pulse40msCount [label = "pulse40msCount : Int"];
+  pulse [label = "pulse : Tuple2[Bool, Int]"];
+  pulse40ms [label = "pulse40ms : Bool"];
+  right [label = "right : Bool", shape = "invhouse"];
+  left [label = "left : Bool", shape = "invhouse"];
+  dx [label = "dx : Int"];
+  y [label = "y : Int", style = filled, fillcolor = "#e4e4e4"];
+  down [label = "down : Bool", shape = "invhouse"];
+  up [label = "up : Bool", shape = "invhouse"];
+  dy [label = "dy : Int"];
+  pos [label = "pos : Tuple2[Int, Int]"];
+  x [label = "x : Int", style = filled, fillcolor = "#e4e4e4"];
+  pos -> x;
+  pulse40ms -> pos;
+  pulse -> pulse40ms;
+  pulse10ms -> pulse;
+  pulse40msCount -> pulse [style = dashed];
+  pulse -> pulse40msCount;
+  x -> pos [style = dashed];
+  dx -> pos;
+  right -> dx;
+  left -> dx;
+  y -> pos [style = dashed];
+  pos -> y;
+  dy -> pos;
+  down -> dy;
+  up -> dy;
+  pos -> pos [style = dashed];
+}