resin 0.0.1

data/amber/js/parser.pegjs

@@ -0,0 +1,220 @@
+start = method
+
+separator      = [ \t\v\f\u00A0\uFEFF\n\r\u2028\u2029]+
+comments       = (["][^"]*["])+
+ws             = (separator / comments)*
+identifier     = first:[a-z] others:[a-zA-Z0-9]* {return first + others.join("")}
+keyword        = first:identifier last:[:] {return first + last}
+className      = first:[A-Z] others:[a-zA-Z0-9]* {return first + others.join("")}
+string         = ['] val:(("''" {return "'"} / [^'])*) ['] {
+               	   return smalltalk.ValueNode._new()
+               	   	._value_(val.join("").replace(/\"/ig, '"'))
+	         }
+
+symbol         = "#"val:[a-zA-Z0-9]* {
+		  return smalltalk.ValueNode._new()
+               	   	._value_('smalltalk.symbolFor(val.join("").replace(/\"/ig, '"')))
+               	 }
+number         = n:(float / integer) {
+		  return smalltalk.ValueNode._new()
+               	   	._value_(n)
+               	 }
+float          = neg:[-]?int:integer "." dec:integer {return parseFloat((neg+int+"."+dec), 10)}
+integer        = neg:[-]?digits:[0-9]+ {return (parseInt(neg+digits.join(""), 10))}
+literalArray   = "#(" ws lits:(lit:literal ws {return lit._value()})* ws ")" {
+		  return smalltalk.ValueNode._new()
+               	   	._value_(lits)
+               	 }
+dynamicArray   = "{" ws expressions:expressions? ws "}" {
+	       	  return smalltalk.DynamicArrayNode._new()
+		        ._nodes_(expressions)
+		  }
+dynamicDictionary = "#{" ws expressions: expressions? ws "}" {
+	       	  return smalltalk.DynamicDictionaryNode._new()
+		        ._nodes_(expressions)
+		  }
+pseudoVariable = val:(
+	          'true' {return true} 
+	       	/ 'false' {return false}
+		/ 'nil' {return nil}) {
+			return smalltalk.ValueNode._new()._value_(val)
+		    }
+literal        = pseudoVariable / number / literalArray / dynamicDictionary / dynamicArray / string / symbol / block
+
+
+variable       = identifier:identifier {
+		  return smalltalk.VariableNode._new()
+			._value_(identifier)
+		  }
+classReference = className:className {
+		  return smalltalk.ClassReferenceNode._new()
+		  	._value_(className)
+		  }
+
+reference      = variable / classReference
+
+keywordPair    = key:keyword ws arg:binarySend ws {return {key:key, arg: arg}}
+
+binarySelector = bin:[\\+*/=><,@%~|&-]+ {return bin.join("").replace(/\\/g, '\\\\')}
+unarySelector  = identifier
+
+keywordPattern = pairs:(ws key:keyword ws arg:identifier {return {key:key, arg: arg}})+ {
+	             var keywords = [];
+                     var params = [];
+                     for(var i=0;i<pairs.length;i++){
+                         keywords.push(pairs[i].key);
+                     }
+                     for(var i=0;i<pairs.length;i++){
+                         params.push(pairs[i].arg);
+                     }
+		     return [keywords.join(""), params]
+	         }
+binaryPattern  = ws selector:binarySelector ws arg:identifier {return [selector, [arg]]}
+unaryPattern   = ws selector:unarySelector {return [selector, []]}
+
+expression     = assignment / cascade / keywordSend / binarySend / jsStatement
+
+expressionList = ws "." ws expression:expression {return expression}
+expressions    = first:expression others:expressionList* {
+	       	     var result = [first];
+		     for(var i=0;i<others.length;i++) {
+		 	 result.push(others[i]);
+		     }
+		     return result;
+	       } 
+
+assignment     = variable:variable ws ':=' ws expression:expression {
+	       	     return smalltalk.AssignmentNode._new()
+	       	     	._left_(variable)
+	       	     	._right_(expression)
+		 }
+
+ret            = '^' ws expression:expression ws '.'? {
+	       	     return smalltalk.ReturnNode._new()
+	       	     	._nodes_([expression])
+	       }
+  
+temps          = "|" vars:(ws variable:identifier ws {return variable})* "|" {return vars}
+
+blockParamList = params:((ws ":" ws param:identifier {return param})+) ws "|" {return params}
+
+subexpression  = '(' ws expression:expression ws ')' {return expression}
+
+statements    = ret:ret [.]* {return [ret]}
+  	      / exps:expressions ws [.]+ ws ret:ret [.]* {
+      	      	  var expressions = exps;
+      		  expressions.push(ret);
+      		  return expressions
+  		}
+  	      / expressions:expressions? [.]* {
+      	          return expressions || []
+  	        }
+
+sequence      = temps:temps? ws statements:statements? ws {
+	      	  return smalltalk.SequenceNode._new()
+	      	  	._temps_(temps || [])
+	      	  	._nodes_(statements || [])
+		}
+
+block         = '[' ws params:blockParamList? ws sequence:sequence? ws ']' {
+	          return smalltalk.BlockNode._new()
+	          	._parameters_(params || [])
+	          	._nodes_([sequence._asBlockSequenceNode()])
+		}
+
+operand       = literal / reference / subexpression
+
+
+
+unaryMessage  = ws selector:unarySelector ![:] {
+	      	return smalltalk.SendNode._new()
+	      		._selector_(selector)
+	      }
+
+unaryTail     = message:unaryMessage ws tail:unaryTail? ws {
+		  if(tail) {
+          	      return tail._valueForReceiver_(message);
+      		  }
+      		  else {
+          	      return message;
+      		  }
+  	      }
+
+unarySend     = receiver:operand ws tail:unaryTail? {
+		  if(tail) {
+          	      return tail._valueForReceiver_(receiver);
+      		  }
+      		  else {
+          	      return receiver;
+      		  }
+	      }
+
+binaryMessage = ws selector:binarySelector ws arg:(unarySend / operand) {
+	          return smalltalk.SendNode._new()
+	          	._selector_(selector)
+	          	._arguments_([arg])
+	      }
+
+binaryTail    = message:binaryMessage tail:binaryTail? {
+      	          if(tail) {
+          	      return tail._valueForReceiver_(message);
+      		  }
+      		  else {
+          	      return message;
+      		  }
+  	      }
+
+binarySend    = receiver:unarySend tail:binaryTail? {
+	      	  if(tail) {
+          	      return tail._valueForReceiver_(receiver);
+      		  }
+      		  else {
+          	      return receiver;
+      		  }
+	      }
+	      
+
+keywordMessage = ws pairs:(pair:keywordPair ws {return pair})+ {
+      		  var selector = [];
+      		  var args = [];
+      		  for(var i=0;i<pairs.length;i++) {
+          	      selector.push(pairs[i].key);
+          	      args.push(pairs[i].arg);
+      		  }
+      		  return smalltalk.SendNode._new()
+      		  	._selector_(selector.join(""))
+      		  	._arguments_(args)
+  	      }
+
+keywordSend   = receiver:binarySend tail:keywordMessage {
+	          return tail._valueForReceiver_(receiver);
+	      }
+
+message       = binaryMessage / unaryMessage / keywordMessage
+
+cascade       = ws send:(keywordSend / binarySend) messages:(ws ";" ws mess:message ws {return mess})+ 
+  	      {
+		var cascade = [];
+      		cascade.push(send);
+      		for(var i=0;i<messages.length;i++) {
+          		cascade.push(messages[i]);
+      		}
+      		return smalltalk.CascadeNode._new()
+          	       ._receiver_(send._receiver())
+          	       ._nodes_(cascade)
+  	      }
+
+jsStatement   = "<" val:((">>" {return ">"} / [^>])*) ">"
+  	      {
+		return smalltalk.JSStatementNode._new()
+			._source_(val.join(""))
+  	      }
+
+
+method        = ws pattern:(keywordPattern / binaryPattern / unaryPattern) ws sequence:sequence? ws {
+	      	return smalltalk.MethodNode._new()
+		       ._selector_(pattern[0])
+		       ._arguments_(pattern[1])
+		       ._nodes_([sequence])
+	      }
+

data/amber/st/Benchfib.st

@@ -0,0 +1,124 @@
+Smalltalk current createPackage: 'Benchfib' properties: #{}!
+Object subclass: #Benchfib
+	instanceVariableNames: ''
+	category: 'Benchfib'!
+
+!Benchfib class methodsFor: 'not yet classified'!
+
+main
+
+	| result |
+	result := 0 tinyBenchmarks.
+	console log: '0 tinyBenchmarks => ' , result
+! !
+
+!Number methodsFor: '*Benchfib'!
+
+benchFib 
+	"Handy send-heavy benchmark"
+	"(result // seconds to run) = approx calls per second"
+	" | r t |
+	  t := Time millisecondsToRun: [r := 26 benchFib].
+	  (r * 1000) // t"
+	"138000 on a Mac 8100/100"
+	^ self < 2 
+		ifTrue: [1] 
+		ifFalse: [(self-1) benchFib + (self-2) benchFib + 1]
+!
+
+benchmark 
+	"Handy bytecode-heavy benchmark"
+	"(500000 // time to run) = approx bytecodes per second"
+	"5000000 // (Time millisecondsToRun: [10 benchmark]) * 1000"
+	"3059000 on a Mac 8100/100"
+    | size flags prime k count |
+    size := 8190.
+    1 to: self do:
+        [:iter |
+        count := 0.
+        flags := Array new.
+        size timesRepeat: [ flags add: true].
+        1 to: size do:
+            [:i | (flags at: i) ifTrue:
+                [prime := i+1.
+                k := i + prime.
+                [k <= size] whileTrue:
+                    [flags at: k put: false.
+                    k := k + prime].
+                count := count + 1]]].
+    ^ count
+!
+
+tinyBenchmarks 
+	"Report the results of running the two tiny Squeak benchmarks.
+	ar 9/10/1999: Adjusted to run at least 1 sec to get more stable results"
+	"0 tinyBenchmarks"
+	"On a 292 MHz G3 Mac: 22727272 bytecodes/sec; 984169 sends/sec"
+	"On a 400 MHz PII/Win98:  18028169 bytecodes/sec; 1081272 sends/sec"
+	| t1 t2 r n1 n2 |
+	n1 := 1.
+	[t1 := Date millisecondsToRun: [n1 benchmark].
+	t1 < 1000] whileTrue:[n1 := n1 * 2]. "Note: #benchmark's runtime is about O(n)"
+
+	n2 := 16.
+	[t2 := Date millisecondsToRun: [r := n2 benchFib].
+	t2 < 1000] whileTrue:[n2 := n2 + 1]. 
+	"Note: #benchFib's runtime is about O(k^n),
+		where k is the golden number = (1 + 5 sqrt) / 2 = 1.618...."
+
+	^ ((n1 * 500000 * 1000) / t1) printString, ' bytecodes/sec; ',
+	  ((r * 1000) / t2) printString, ' sends/sec'
+!
+
+jsbenchFib
+ 
+	<if (this < 2) {
+return 1;
+} else {
+return (this-1)._jsbenchFib() + (this-2)._jsbenchFib() + 1;}>
+!
+
+jsbenchmark
+
+<
+var size = 8190;
+var count;
+for (var z=0;z<this;z++) {
+  count = 0;
+  var flags = new Array();
+  for (var p=0; p<size; p++) {
+    flags[p] = true;
+  }
+  for (var i=1;i<=size;i++) {
+    if (flags[i-1]) {
+      var prime = i+1;
+      var k = i + prime;
+      while (k <= size) {
+        flags[k-1] = false;
+        k = k + prime;
+      }
+      count = count + 1;
+    }
+  }
+}
+return count>
+!
+
+jstinyBenchmarks
+	"0 jstinyBenchmarks"
+
+	| t1 t2 r n1 n2 |
+	n1 := 1.
+	[t1 := Date millisecondsToRun: [n1 jsbenchmark].
+	t1 < 1000] whileTrue:[n1 := n1 * 2]. "Note: #benchmark's runtime is about O(n)"
+
+	n2 := 28.
+	[t2 := Date millisecondsToRun: [r := n2 jsbenchFib].
+	t2 < 1000] whileTrue:[n2 := n2 + 1]. 
+	"Note: #jsbenchFib's runtime is about O(k^n),
+		where k is the golden number = (1 + 5 sqrt) / 2 = 1.618...."
+
+	^ ((n1 * 500000 * 1000) / t1) printString, ' bytecodes/sec; ',
+	  ((r * 1000) / t2) printString, ' sends/sec'
+! !
+

data/amber/st/Canvas.st

@@ -0,0 +1,556 @@
+Smalltalk current createPackage: 'Canvas' properties: #{}!
+Object subclass: #HTMLCanvas
+	instanceVariableNames: 'root'
+	category: 'Canvas'!
+
+!HTMLCanvas methodsFor: 'accessing'!
+
+root: aTagBrush
+    root := aTagBrush
+!
+
+root
+    ^root
+! !
+
+!HTMLCanvas methodsFor: 'adding'!
+
+with: anObject
+    ^self root with: anObject
+! !
+
+!HTMLCanvas methodsFor: 'initialization'!
+
+initialize
+    super initialize.
+    root ifNil: [root := TagBrush fromString: 'div' canvas: self]
+!
+
+initializeFromJQuery: aJQuery
+    root := TagBrush fromJQuery: aJQuery canvas: self
+! !
+
+!HTMLCanvas methodsFor: 'tags'!
+
+newTag: aString
+    ^TagBrush fromString: aString canvas: self
+!
+
+tag: aString
+    ^root addBrush: (self newTag: aString)
+!
+
+h1
+    ^self tag: 'h1'
+!
+
+h2
+    ^self tag: 'h2'
+!
+
+h3
+    ^self tag: 'h3'
+!
+
+h4
+    ^self tag: 'h4'
+!
+
+h5
+    ^self tag: 'h5'
+!
+
+h6
+    ^self tag: 'h6'
+!
+
+p
+    ^self tag: 'p'
+!
+
+div
+    ^self tag: 'div'
+!
+
+span
+    ^self tag: 'span'
+!
+
+img
+    ^self tag: 'img'
+!
+
+ul
+    ^self tag: 'ul'
+!
+
+ol
+    ^self tag: 'ol'
+!
+
+li
+    ^self tag: 'li'
+!
+
+table
+    ^self tag: 'table'
+!
+
+tr
+    ^self tag: 'tr'
+!
+
+td 
+    ^self tag: 'td'
+!
+
+th
+    ^self tag: 'th'
+!
+
+form
+    ^self tag: 'form'
+!
+
+input
+    ^self tag: 'input'
+!
+
+button
+    ^self tag: 'button'
+!
+
+select
+    ^self tag: 'select'
+!
+
+option
+    ^self tag: 'option'
+!
+
+textarea
+    ^self tag: 'textarea'
+!
+
+a
+    ^self tag: 'a'
+!
+
+canvas
+	^self tag: 'canvas'
+!
+
+pre
+    ^self tag: 'pre'
+!
+
+code
+    ^self tag: 'code'
+!
+
+br
+    ^self tag: 'br'
+!
+
+script
+    ^self tag: 'script'
+!
+
+link
+    ^self tag: 'link'
+!
+
+style
+	^ root addBrush:  (StyleTag canvas: self)
+!
+
+p: anObject
+    ^self p with: anObject
+!
+
+h1: anObject
+    ^self h1 with: anObject
+!
+
+iframe
+    ^self tag: 'iframe'
+!
+
+iframe: aString
+    ^self iframe src: aString
+!
+
+h2: anObject
+    ^ self h2 with: anObject
+!
+
+h3: anObject
+    ^self h3 with: anObject
+!
+
+h4: anObject
+    ^self h4 with: anObject
+!
+
+h5: anObject
+    ^self h5 with: anObject
+!
+
+h6: anObject
+    ^self h6 with: anObject
+!
+
+img: aString
+    ^self img src: aString
+!
+
+ol: anObject
+    ^self ol with: anObject
+!
+
+li: anObject
+    ^self li with: anObject
+!
+
+ul: anObject
+    ^self ul with: anObject
+!
+
+span: anObject
+    ^self span with: anObject
+!
+
+style: aString
+	^ self style with: aString; yourself
+!
+
+articles
+    ^self tag: 'articles'
+!
+
+audio
+    ^self tag: 'audio'
+!
+
+fieldset
+    ^self tag: 'fieldset'
+!
+
+footer
+    ^self tag: 'footer'
+!
+
+header
+    ^self tag: 'header'
+!
+
+hr
+    ^self tag: 'hr'
+!
+
+section
+    ^self tag: 'section'
+!
+
+tbody
+    ^self tag: 'tbody'
+!
+
+tfoot
+    ^self tag: 'tfoot'
+!
+
+thead
+    ^self tag: 'thead'
+!
+
+video
+    ^self tag: 'video'
+! !
+
+!HTMLCanvas class methodsFor: 'instance creation'!
+
+onJQuery: aJQuery
+	^self basicNew
+		initializeFromJQuery: aJQuery;
+		initialize;
+		yourself
+! !
+
+Object subclass: #TagBrush
+	instanceVariableNames: 'canvas element'
+	category: 'Canvas'!
+
+!TagBrush methodsFor: 'accessing'!
+
+element
+    ^element
+! !
+
+!TagBrush methodsFor: 'adding'!
+
+contents: anObject
+    self 
+	empty;
+   	append: anObject
+!
+
+addBrush: aTagBrush
+    self appendChild: aTagBrush element.
+    ^aTagBrush
+!
+
+with: anObject
+    self append: anObject
+!
+
+append: anObject
+    anObject appendToBrush: self
+!
+
+appendToBrush: aTagBrush
+    aTagBrush addBrush: self
+!
+
+appendBlock: aBlock
+    | root |
+    root := canvas root.
+    canvas root: self.
+    aBlock value: canvas.
+    canvas root: root
+!
+
+appendChild: anElement
+	"In IE7 and IE8 appendChild fails on several node types. So we need to check" 
+ 	<var element=self['@element'];
+ 	if (null == element.canHaveChildren || element.canHaveChildren) {
+		element.appendChild(anElement);
+ 	} else {
+ 		element.text = String(element.text) +  anElement.innerHTML;
+ 	} >
+!
+
+appendString: aString
+    self appendChild: (self createTextNodeFor: aString)
+!
+
+empty
+	self asJQuery empty
+! !
+
+!TagBrush methodsFor: 'attributes'!
+
+at: aString put: aValue
+    <self['@element'].setAttribute(aString, aValue)>
+!
+
+removeAt: aString
+    <self['@element'].removeAttribute(aString)>
+!
+
+class: aString
+      <self['@element'].className = aString>
+!
+
+id: aString
+    self at: 'id' put: aString
+!
+
+src: aString
+    self  at: 'src' put: aString
+!
+
+href: aString
+    self at: 'href' put: aString
+!
+
+title: aString
+    self at: 'title' put: aString
+!
+
+style: aString
+    self at: 'style' put: aString
+!
+
+type: aString
+    self at: 'type' put: aString
+!
+
+media: aString
+    self at: 'media' put: aString
+!
+
+rel: aString
+    self  at: 'rel' put: aString
+!
+
+width: aString
+    self  at: 'width' put: aString
+!
+
+height: aString
+    self  at: 'height' put: aString
+!
+
+value: aString
+    self  at: 'value' put: aString
+! !
+
+!TagBrush methodsFor: 'converting'!
+
+asJQuery
+    ^window jQuery: self element
+! !
+
+!TagBrush methodsFor: 'events'!
+
+onKeyDown: aBlock
+    self asJQuery bind: 'keydown' do: aBlock
+!
+
+onKeyPress: aBlock
+    self asJQuery bind: 'keypress' do: aBlock
+!
+
+onKeyUp: aBlock
+    self asJQuery bind: 'keyup' do: aBlock
+!
+
+onFocus: aBlock
+    self asJQuery bind: 'focus' do: aBlock
+!
+
+onBlur: aBlock
+    self asJQuery bind: 'blur' do: aBlock
+!
+
+onChange: aBlock
+    self asJQuery bind: 'change' do: aBlock
+!
+
+onClick: aBlock
+    self asJQuery bind: 'click' do: aBlock
+! !
+
+!TagBrush methodsFor: 'initialization'!
+
+initializeFromString: aString canvas: aCanvas
+    element := self createElementFor: aString.
+    canvas := aCanvas
+!
+
+initializeFromJQuery: aJQuery canvas: aCanvas
+    element := aJQuery get: 0.
+    canvas := aCanvas
+! !
+
+!TagBrush methodsFor: 'private'!
+
+createElementFor: aString
+	<return document.createElement(String(aString))>
+!
+
+createTextNodeFor: aString
+	<return document.createTextNode(String(aString))>
+! !
+
+!TagBrush class methodsFor: 'instance creation'!
+
+fromString: aString canvas: aCanvas
+    ^self new
+	initializeFromString: aString canvas: aCanvas;
+	yourself
+!
+
+fromJQuery: aJQuery canvas: aCanvas
+    ^self new
+	initializeFromJQuery: aJQuery canvas: aCanvas;
+	yourself
+! !
+
+Object subclass: #Widget
+	instanceVariableNames: ''
+	category: 'Canvas'!
+
+!Widget methodsFor: 'adding'!
+
+appendToBrush: aTagBrush
+    self appendToJQuery: aTagBrush asJQuery
+!
+
+appendToJQuery: aJQuery
+   self renderOn: (HTMLCanvas onJQuery: aJQuery)
+! !
+
+!Widget methodsFor: 'rendering'!
+
+renderOn: html
+    self
+! !
+
+TagBrush subclass: #StyleTag
+	instanceVariableNames: 'canvas element'
+	category: 'Canvas'!
+!StyleTag commentStamp!
+I'm a <style> tag use to inline CSS or load a stylesheet.
+
+For inlining handle IE compatibility problems.!
+
+!StyleTag methodsFor: 'adding'!
+
+with: aString
+	self isBrowserIE
+		ifTrue: [self element styleSheet cssText: aString ]
+		ifFalse: [super with: aString ].
+! !
+
+!StyleTag methodsFor: 'testing'!
+
+isBrowserIE
+	|ie|
+	ie := <jQuery.browser.msie>.
+	^ ie notNil.
+! !
+
+!StyleTag class methodsFor: 'instance creation'!
+
+canvas: aCanvas
+    ^self new
+	initializeFromString: 'style' canvas: aCanvas;
+	yourself
+! !
+
+!Object methodsFor: '*Canvas'!
+
+appendToJQuery: aJQuery
+    aJQuery append: self asString
+!
+
+appendToBrush: aTagBrush
+    aTagBrush append: self asString
+! !
+
+!BlockClosure methodsFor: '*Canvas'!
+
+appendToJQuery: aJQuery
+    self value: (HTMLCanvas onJQuery: aJQuery)
+!
+
+appendToBrush: aTagBrush
+    aTagBrush appendBlock: self
+! !
+
+!String methodsFor: '*Canvas'!
+
+asJQuery
+    <return jQuery(String(self))>
+!
+
+appendToJQuery: aJQuery
+    aJQuery append: self
+!
+
+appendToBrush: aTagBrush
+    aTagBrush appendString: self
+! !
+