parser.pegjs 9.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230
  1. start = method
  2. separator = [ \t\v\f\u00A0\uFEFF\n\r\u2028\u2029]+
  3. comments = (["][^"]*["])+
  4. ws = (separator / comments)*
  5. identifier = first:[a-zA-Z] others:[a-zA-Z0-9]* {return first + others.join("")}
  6. varIdentifier = first:[a-z] others:[a-zA-Z0-9]* {return first + others.join("")}
  7. keyword = first:identifier last:[:] {return first + last}
  8. className = first:[A-Z] others:[a-zA-Z0-9]* {return first + others.join("")}
  9. string = ['] val:(("''" {return "'"} / [^'])*) ['] {
  10. return smalltalk.ValueNode._new()
  11. ._value_(val.join("").replace(/\"/ig, '"'))
  12. }
  13. symbol = "#"val:(
  14. digits:[a-zA-Z0-9\:]+ {return digits.join("")}
  15. / node:string {return node._value()})*
  16. {
  17. return smalltalk.ValueNode._new()
  18. ._value_(val.join("").replace(/\"/ig, '"'))
  19. }
  20. number = n:(hex / float / integer) {
  21. return smalltalk.ValueNode._new()
  22. ._value_(n)
  23. }
  24. hex = neg:[-]? "16r" num:[0-9a-fA-F]+ {return parseInt((neg + num.join("")), 16)}
  25. float = neg:[-]?int:[0-9]+ "." dec:[0-9]+ {return parseFloat((neg + int.join("") + "." + dec.join("")), 10)}
  26. integer = neg:[-]?digits:[0-9]+ {return (parseInt(neg+digits.join(""), 10))}
  27. literalArray = "#(" ws lits:(lit:parseTimeLiteral ws {return lit._value()})* ws ")" {
  28. return smalltalk.ValueNode._new()
  29. ._value_(lits)
  30. }
  31. dynamicArray = "{" ws expressions:expressions? ws "."? "}" {
  32. return smalltalk.DynamicArrayNode._new()
  33. ._nodes_(expressions)
  34. }
  35. dynamicDictionary = "#{" ws expressions: expressions? ws "}" {
  36. return smalltalk.DynamicDictionaryNode._new()
  37. ._nodes_(expressions)
  38. }
  39. pseudoVariable = val:(
  40. 'true' {return true}
  41. / 'false' {return false}
  42. / 'nil' {return nil}) {
  43. return smalltalk.ValueNode._new()
  44. ._value_(val)
  45. }
  46. parseTimeLiteral = pseudoVariable / number / literalArray / string / symbol
  47. runtimeLiteral = dynamicDictionary / dynamicArray / block
  48. literal = runtimeLiteral / parseTimeLiteral
  49. variable = identifier:varIdentifier {
  50. return smalltalk.VariableNode._new()
  51. ._value_(identifier)
  52. }
  53. classReference = className:className {
  54. return smalltalk.ClassReferenceNode._new()
  55. ._value_(className)
  56. }
  57. reference = variable / classReference
  58. keywordPair = key:keyword ws arg:binarySend ws {return {key:key, arg: arg}}
  59. binarySelector = bin:[\\+*/=><,@%~|&-]+ {return bin.join("")}
  60. unarySelector = identifier
  61. keywordPattern = pairs:(ws key:keyword ws arg:identifier {return {key:key, arg: arg}})+ {
  62. var keywords = [];
  63. var params = [];
  64. for(var i=0;i<pairs.length;i++){
  65. keywords.push(pairs[i].key);
  66. }
  67. for(var i=0;i<pairs.length;i++){
  68. params.push(pairs[i].arg);
  69. }
  70. return [keywords.join(""), params]
  71. }
  72. binaryPattern = ws selector:binarySelector ws arg:identifier {return [selector, [arg]]}
  73. unaryPattern = ws selector:unarySelector {return [selector, []]}
  74. expression = assignment / cascade / keywordSend / binarySend
  75. expressionList = ws "." ws expression:expression {return expression}
  76. expressions = first:expression others:expressionList* {
  77. var result = [first];
  78. for(var i=0;i<others.length;i++) {
  79. result.push(others[i]);
  80. }
  81. return result;
  82. }
  83. assignment = variable:variable ws ':=' ws expression:expression {
  84. return smalltalk.AssignmentNode._new()
  85. ._left_(variable)
  86. ._right_(expression)
  87. }
  88. ret = '^' ws expression:expression ws '.'? {
  89. return smalltalk.ReturnNode._new()
  90. ._nodes_([expression])
  91. }
  92. temps = "|" vars:(ws variable:identifier ws {return variable})* "|" {return vars}
  93. blockParamList = params:((ws ":" ws param:identifier {return param})+) ws "|" {return params}
  94. subexpression = '(' ws expression:expression ws ')' {return expression}
  95. statements = ret:ret [.]* {return [ret]}
  96. / exps:expressions ws [.]+ ws ret:ret [.]* {
  97. var expressions = exps;
  98. expressions.push(ret);
  99. return expressions
  100. }
  101. / expressions:expressions? [.]* {
  102. return expressions || []
  103. }
  104. sequence = jsSequence / stSequence
  105. stSequence = temps:temps? ws statements:statements? ws {
  106. return smalltalk.SequenceNode._new()
  107. ._temps_(temps || [])
  108. ._nodes_(statements || [])
  109. }
  110. jsSequence = jsStatement
  111. block = '[' ws params:blockParamList? ws sequence:sequence? ws ']' {
  112. return smalltalk.BlockNode._new()
  113. ._parameters_(params || [])
  114. ._nodes_([sequence._asBlockSequenceNode()])
  115. }
  116. operand = literal / reference / subexpression
  117. unaryMessage = ws selector:unarySelector ![:] {
  118. return smalltalk.SendNode._new()
  119. ._selector_(selector)
  120. }
  121. unaryTail = message:unaryMessage ws tail:unaryTail? ws {
  122. if(tail) {
  123. return tail._valueForReceiver_(message);
  124. }
  125. else {
  126. return message;
  127. }
  128. }
  129. unarySend = receiver:operand ws tail:unaryTail? {
  130. if(tail) {
  131. return tail._valueForReceiver_(receiver);
  132. }
  133. else {
  134. return receiver;
  135. }
  136. }
  137. binaryMessage = ws selector:binarySelector ws arg:(unarySend / operand) {
  138. return smalltalk.SendNode._new()
  139. ._selector_(selector)
  140. ._arguments_([arg])
  141. }
  142. binaryTail = message:binaryMessage tail:binaryTail? {
  143. if(tail) {
  144. return tail._valueForReceiver_(message);
  145. }
  146. else {
  147. return message;
  148. }
  149. }
  150. binarySend = receiver:unarySend tail:binaryTail? {
  151. if(tail) {
  152. return tail._valueForReceiver_(receiver);
  153. }
  154. else {
  155. return receiver;
  156. }
  157. }
  158. keywordMessage = ws pairs:(pair:keywordPair ws {return pair})+ {
  159. var selector = [];
  160. var args = [];
  161. for(var i=0;i<pairs.length;i++) {
  162. selector.push(pairs[i].key);
  163. args.push(pairs[i].arg);
  164. }
  165. return smalltalk.SendNode._new()
  166. ._selector_(selector.join(""))
  167. ._arguments_(args)
  168. }
  169. keywordSend = receiver:binarySend tail:keywordMessage {
  170. return tail._valueForReceiver_(receiver);
  171. }
  172. message = binaryMessage / unaryMessage / keywordMessage
  173. cascade = ws send:(keywordSend / binarySend) messages:(ws ";" ws mess:message ws {return mess})+ {
  174. var cascade = [];
  175. cascade.push(send);
  176. for(var i=0;i<messages.length;i++) {
  177. cascade.push(messages[i]);
  178. }
  179. return smalltalk.CascadeNode._new()
  180. ._receiver_(send._receiver())
  181. ._nodes_(cascade)
  182. }
  183. jsStatement = "<" val:((">>" {return ">"} / [^>])*) ">" {
  184. return smalltalk.JSStatementNode._new()
  185. ._source_(val.join(""))
  186. }
  187. method = ws pattern:(keywordPattern / binaryPattern / unaryPattern) ws sequence:sequence? ws {
  188. return smalltalk.MethodNode._new()
  189. ._selector_(pattern[0])
  190. ._arguments_(pattern[1])
  191. ._nodes_([sequence])
  192. }