Got for working with bitstrings

bryanjos · bryanjos · commit e8cf4b9a76e4 · 2016-02-23T09:39:00.000-06:00
diff --git a/src/javascript/lib/core/bit_string.js b/src/javascript/lib/core/bit_string.js
@@ -1,13 +1,9 @@
 class BitString {
   constructor(...args){
-    this.raw_value = function(){
-      return Object.freeze(args);
-    };
-
     this.value = Object.freeze(this.process(args));
     this.length = this.value.length;
-    this.bit_size = this.raw_value().reduce((prev, current) => prev + (current.unit * current.size), 0);
-    this.byte_size = (this.bit_size / 8) + (this.bit_size % 8 > 0 ? 1 : 0);
+    this.bit_size = this.length * 8;
+    this.byte_size = this.length;
   }
 
   get(index){
@@ -18,6 +14,12 @@ class BitString {
     return this.value.length;
   }
 
+  slice(start, end = null){
+    let s = this.value.slice(start, end);
+    let ms = s.map((elem) => BitString.integer(elem));
+    return new BitString(...ms);
+  }
+
   [Symbol.iterator]() {
     return this.value[Symbol.iterator]();
   }
@@ -34,14 +36,14 @@ class BitString {
     return "<<" + s + ">>";
   }
 
-  process(){
+  process(bitStringParts){
     let processed_values = [];
 
     var i;
-    for (i = 0; i < this.raw_value().length; i++) {
-      let processed_value = this['process_' + this.raw_value()[i].type](this.raw_value()[i]);
+    for (i = 0; i < bitStringParts.length; i++) {
+      let processed_value = this['process_' + bitStringParts[i].type](bitStringParts[i]);
 
-      for(let attr of this.raw_value()[i].attributes){
+      for(let attr of bitStringParts[i].attributes){
         processed_value = this['process_' + attr](processed_value);
       }
 
diff --git a/src/javascript/lib/core/patterns/types.js b/src/javascript/lib/core/patterns/types.js
@@ -59,15 +59,6 @@ export class Bound {
 export class BitStringMatch {
   values: Array<Object>
 
-    //{'value': value, 'attributes': [type, unit, size]};
-
-    //length = unit * size
-
-    //use that info to map value to subset of bitstring
-    //use type to turn subset of bitstring into desired type
-    //if value is a variable, add variable to args list
-    //if value is just a value, match up substring with generated bitstring from value
-
   constructor(...values: Array<Object>){
     this.values = values;
   }
@@ -76,11 +67,15 @@ export class BitStringMatch {
     return values.length;
   }
 
-  size(){
+  bit_size() {
+    return this.byte_size() * 8;
+  }
+
+  byte_size(){
     let s = 0;
 
     for(let val of this.values){
-      s = s + val.unit * val.size;
+      s = s + ((val.unit * val.size)/8);
     }
 
     return s;
diff --git a/src/javascript/lib/core/special_forms.js b/src/javascript/lib/core/special_forms.js
@@ -29,25 +29,58 @@ function _for(collections, fun, filter = () => true, into = [], previousValues =
   let collection = collections[0][1];
 
   if(collections.length === 1){
+    if(collection instanceof BitString){
+      let bsSlice = collection.slice(0, pattern.byte_size());
+      let i = 1;
 
-    for(let elem of collection){
-      let r = Patterns.match_no_throw(pattern, elem);
-      let args = previousValues.concat(r);
+      while(bsSlice.byte_size == pattern.byte_size()){
+        let r = Patterns.match_no_throw(pattern, bsSlice);
+        let args = previousValues.concat(r);
 
-      if(r && filter.apply(this, args)){
-        into = into.concat([fun.apply(this, args)]);
+        if(r && filter.apply(this, args)){
+          into = into.concat([fun.apply(this, args)]);
+        }
+
+        bsSlice = collection.slice(pattern.byte_size() * i, pattern.byte_size() * (i + 1));
+        i++;
+      }
+
+      return into;
+    }else{
+      for(let elem of collection){
+        let r = Patterns.match_no_throw(pattern, elem);
+        let args = previousValues.concat(r);
+
+        if(r && filter.apply(this, args)){
+          into = into.concat([fun.apply(this, args)]);
+        }
       }
-    }
 
-    return into;
+      return into;
+    }
   }else{
     let _into = [];
 
-    for(let elem of collection){
-      let r = Patterns.match_no_throw(pattern, elem);
-      if(r){
-        _into = into.concat(this._for(collections.slice(1), fun, filter, _into, previousValues.concat(r)));
+    if(collection instanceof BitString){
+      let bsSlice = collection.slice(0, pattern.byte_size());
+      let i = 1;
+
+      while(bsSlice.byte_size == pattern.byte_size()){
+        let r = Patterns.match_no_throw(pattern, bsSlice);
+        if(r){
+          _into = into.concat(this._for(collections.slice(1), fun, filter, _into, previousValues.concat(r)));
+        }
+
+        bsSlice = collection.slice(pattern.byte_size() * i, pattern.byte_size() * (i + 1));
+        i++;
       }
+    }else{
+      for(let elem of collection){
+        let r = Patterns.match_no_throw(pattern, elem);
+        if(r){
+          _into = into.concat(this._for(collections.slice(1), fun, filter, _into, previousValues.concat(r)));
+        }
+      } 
     }
 
     return _into;
diff --git a/src/javascript/tests/for.spec.js b/src/javascript/tests/for.spec.js
@@ -1,6 +1,8 @@
 import Core from "../lib/core";
 const Patterns = Core.Patterns;
 const SpecialForms = Core.SpecialForms;
+const Tuple = Core.Tuple;
+const BitString = Core.BitString;
 
 import Enum from "../lib/enum";
 
@@ -56,4 +58,34 @@ describe('for', () => {
 
     expect(result).to.eql(["JOHN", "MEG"]);
   });
+
+
+  it('for with bitstring', () => {
+    //for <<r::8, g::8, b::8 <- <<213, 45, 132, 64, 76, 32, 76, 0, 0, 234, 32, 15>> >>, do: {r, g, b}
+    
+    let collections = [
+      [
+        Patterns.bitStringMatch(BitString.integer({value: $}), BitString.integer({value: $}), BitString.integer({value: $})),
+        new BitString(
+          BitString.integer(213),
+          BitString.integer(45),
+          BitString.integer(132),
+          BitString.integer(64),
+          BitString.integer(76),
+          BitString.integer(32),
+          BitString.integer(76),
+          BitString.integer(0),
+          BitString.integer(0),
+          BitString.integer(234),
+          BitString.integer(32),
+          BitString.integer(15)
+        )
+      ]
+    ];
+
+    let result = SpecialForms._for(collections, (r, g, b) => new Tuple(r, g, b));
+
+    expect(result).to.eql([new Tuple(213, 45, 132), new Tuple(64, 76, 32), new Tuple(76, 0, 0), new Tuple(234, 32, 15)]);
+  });
+
 });
