resin 0.3.1 → 0.4.0

data/amber/js/parser.pegjs

@@ -8,61 +8,64 @@ varIdentifier  = 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, '"'))
-	         }
+                     return smalltalk.ValueNode._new()
+                            ._value_(val.join("").replace(/\"/ig, '"'))
+                 }
 
 symbol         = "#"val:(
-			digits:[a-zA-Z0-9\:]+ {return digits.join("")} / 
-			node:string {return node._value()})* {
-		  		    return smalltalk.ValueNode._new()
-               	   		    	   ._value_(smalltalk.symbolFor(val.join("").replace(/\"/ig, '"')))
-               	 }
-number         = n:(float / integer) {
-		  return smalltalk.ValueNode._new()
-               	   	._value_(n)
-               	 }
+                         digits:[a-zA-Z0-9\:]+ {return digits.join("")}
+                       / node:string {return node._value()})*
+                  {
+                      return smalltalk.ValueNode._new()
+                             ._value_(smalltalk.symbolFor(val.join("").replace(/\"/ig, '"')))
+                  }
+number         = n:(hex / float / integer) {
+                     return smalltalk.ValueNode._new()
+                            ._value_(n)
+                 }
+hex            = neg:[-]? "16r" num:[0-9a-fA-F]+ {return parseInt((neg + num.join("")), 16)}
 float          = neg:[-]?int:[0-9]+ "." dec:[0-9]+ {return parseFloat((neg + int.join("") + "." + dec.join("")), 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)
-               	 }
+                     return smalltalk.ValueNode._new()
+                            ._value_(lits)
+                 }
 dynamicArray   = "{" ws expressions:expressions? ws "."? "}" {
-	       	  return smalltalk.DynamicArrayNode._new()
-		        ._nodes_(expressions)
-		  }
+                     return smalltalk.DynamicArrayNode._new()
+                            ._nodes_(expressions)
+                 }
 dynamicDictionary = "#{" ws expressions: expressions? ws "}" {
-	       	  return smalltalk.DynamicDictionaryNode._new()
-		        ._nodes_(expressions)
-		  }
+                        return smalltalk.DynamicDictionaryNode._new()
+                               ._nodes_(expressions)
+                    }
 pseudoVariable = val:(
-	          'true' {return true} 
-	       	/ 'false' {return false}
-		/ 'nil' {return nil}) {
-			return smalltalk.ValueNode._new()._value_(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:varIdentifier {
-		  return smalltalk.VariableNode._new()
-			._value_(identifier)
-		  }
+                     return smalltalk.VariableNode._new()
+                            ._value_(identifier)
+                 }
 classReference = className:className {
-		  return smalltalk.ClassReferenceNode._new()
-		  	._value_(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, '\\\\')}
+binarySelector = bin:[\\+*/=><,@%~|&-]+ {return bin.join("")}
 unarySelector  = identifier
 
 keywordPattern = pairs:(ws key:keyword ws arg:identifier {return {key:key, arg: arg}})+ {
-	             var keywords = [];
+                     var keywords = [];
                      var params = [];
                      for(var i=0;i<pairs.length;i++){
                          keywords.push(pairs[i].key);
@@ -70,32 +73,32 @@ keywordPattern = pairs:(ws key:keyword ws arg:identifier {return {key:key, arg:
                      for(var i=0;i<pairs.length;i++){
                          params.push(pairs[i].arg);
                      }
-		     return [keywords.join(""), params]
-	         }
+                     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
+expression     = assignment / cascade / keywordSend / binarySend
 
 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;
-	       } 
+                     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)
-		 }
+                     return smalltalk.AssignmentNode._new()
+                            ._left_(variable)
+                            ._right_(expression)
+                 }
 
 ret            = '^' ws expression:expression ws '.'? {
-	       	     return smalltalk.ReturnNode._new()
-	       	     	._nodes_([expression])
-	       }
+                     return smalltalk.ReturnNode._new()
+                            ._nodes_([expression])
+                 }
   
 temps          = "|" vars:(ws variable:identifier ws {return variable})* "|" {return vars}
 
@@ -103,121 +106,123 @@ blockParamList = params:((ws ":" ws param:identifier {return param})+) ws "|" {r
 
 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;
-      		  }
-	      }
-	      
+statements     = ret:ret [.]* {return [ret]}
+                 / exps:expressions ws [.]+ ws ret:ret [.]* {
+                       var expressions = exps;
+                       expressions.push(ret);
+                       return expressions
+                   }
+                 / expressions:expressions? [.]* {
+                       return expressions || []
+                   }
+
+sequence       = jsSequence / stSequence
+
+stSequence     = temps:temps? ws statements:statements? ws {
+                     return smalltalk.SequenceNode._new()
+                            ._temps_(temps || [])
+                            ._nodes_(statements || [])
+                 }
+
+jsSequence     = jsStatement
+
+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])
-	      }
+                     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/Canvas.st

@@ -882,3 +882,9 @@ asJQuery
     <return jQuery(String(self))>
 ! !
 
+!JSObjectProxy methodsFor: '*Canvas'!
+
+asJQuery
+    <return jQuery(self['@jsObject'])>
+! !
+

data/amber/st/Compiler-AST.st

@@ -1,9 +1,11 @@
 Smalltalk current createPackage: 'Compiler-AST' properties: #{}!
 Object subclass: #Node
-	instanceVariableNames: 'nodes shouldBeInlined shouldBeAliased'
+	instanceVariableNames: 'position nodes shouldBeInlined shouldBeAliased'
 	package: 'Compiler-AST'!
 !Node commentStamp!
-I am the abstract root class of the abstract syntax tree.!
+I am the abstract root class of the abstract syntax tree.
+
+position: holds a point containing lline- and column number of the symbol location in the original source file!
 
 !Node methodsFor: 'accessing'!
 
@@ -15,6 +17,10 @@ nodes
 	^nodes ifNil: [nodes := Array new]
 !
 
+position
+	^position ifNil: [position := 0@0]
+!
+
 shouldBeAliased
 	^ shouldBeAliased ifNil: [ false ]
 !
@@ -35,6 +41,10 @@ shouldBeInlined: aBoolean
 
 nodes: aCollection
 	nodes := aCollection
+!
+
+position: aPosition
+	position := aPosition
 ! !
 
 !Node methodsFor: 'testing'!
@@ -51,6 +61,14 @@ isBlockSequenceNode
 	^false
 !
 
+isImmutable
+	^false
+!
+
+isNode
+	^ true
+!
+
 isReturnNode
 	^false
 !
@@ -61,6 +79,11 @@ isSendNode
 
 isValueNode
 	^false
+!
+
+subtreeNeedsAliasing
+    ^(self shouldBeAliased or: [ self shouldBeInlined ]) or: [
+        (self nodes detect: [ :each | each subtreeNeedsAliasing ] ifNone: [ false ]) ~= false ]
 ! !
 
 !Node methodsFor: 'visiting'!
@@ -133,6 +156,10 @@ scope: aLexicalScope
 
 isBlockNode
 	^true
+!
+
+subtreeNeedsAliasing
+    ^ self shouldBeAliased or: [ self shouldBeInlined ]
 ! !
 
 !BlockNode methodsFor: 'visiting'!
@@ -202,7 +229,7 @@ accept: aVisitor
 ! !
 
 Node subclass: #MethodNode
-	instanceVariableNames: 'selector arguments source scope classReferences messageSends'
+	instanceVariableNames: 'selector arguments source scope classReferences messageSends superSends'
 	package: 'Compiler-AST'!
 
 !MethodNode methodsFor: 'accessing'!
@@ -253,6 +280,14 @@ source
 
 source: aString
 	source := aString
+!
+
+superSends
+	^ superSends
+!
+
+superSends: aCollection
+	superSends := aCollection
 ! !
 
 !MethodNode methodsFor: 'visiting'!
@@ -446,6 +481,10 @@ value: anObject
 
 !ValueNode methodsFor: 'testing'!
 
+isImmutable
+	^true
+!
+
 isValueNode
 	^true
 ! !
@@ -487,6 +526,12 @@ binding: aScopeVar
 	binding := aScopeVar
 ! !
 
+!VariableNode methodsFor: 'testing'!
+
+isImmutable
+	^false
+! !
+
 !VariableNode methodsFor: 'visiting'!
 
 accept: aVisitor
@@ -503,3 +548,9 @@ accept: aVisitor
 	^ aVisitor visitClassReferenceNode: self
 ! !
 
+!Object methodsFor: '*Compiler-AST'!
+
+isNode
+	^ false
+! !
+