solidity 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3920e32ab53156b256507811437d64f62f38bd42472aecb5c51a4fd3eb2f57e1
-  data.tar.gz: 4a5c36c583ba102881417af5d184c6351ef9d6a1f20154ab6096fb4722694bc6
+  metadata.gz: 92328b174c85612323db86d1d50654934da8b46d878831b99d49086673cda0df
+  data.tar.gz: 487298452cd42474065d694a87ef23f8425371dfd8ce29742c38b38227beaade
 SHA512:
-  metadata.gz: b7227cdec56deceba0230c0f8946ea0182e2e144919bb2b0227d52a19c4085d89a0b2f3a62c796b162c9fba59880d5ee1cb154bfc0f5de1455cb4bd353d4602d
-  data.tar.gz: 9840c43aade93aaec0b0222c2db7dc4f50246565da9e52c69363fe599e43bed8e0e800ac31349a846ab7cfeb4e28126bde9fcfd8d6a85b884d9d26240b1fc35b
+  metadata.gz: 18ee1772f0ea6d2c5579d955301140bf7930e3f9b94810682da34d5929c9c93c7b10f62e7781d01abe16527f54502837cd2424c773b0177c3fc767ba43734706
+  data.tar.gz: 1dcd402d83754b2bee56794fe465f02f7f874770188dffb971ff3fe34ea7aa0f084416f6a0f64508e90132d2ea03795e2f364c29f023b7f767e62d0d450a682d

data/Manifest.txt

@@ -3,5 +3,6 @@ Manifest.txt
 README.md
 Rakefile
 lib/solidity.rb
+lib/solidity/lexer.rb
 lib/solidity/parser.rb
 lib/solidity/version.rb

data/README.md

@@ -1,23 +1,6 @@
-
----
-
-_The Ruby Programming Language for Contract / Transaction Scripts on the Blockchain World Computer - Yes, It's Just Ruby_
-
-**sruby - Small, Smart, Secure, Safe, Solid & Sound (S6) Ruby**
-
-sruby is a subset of mruby that is a subset of "classic" ruby.
-
-
-For more see the [**Red Paper »**](https://github.com/s6ruby/redpaper)
-
----
-
-
-
-
 # Solidity
 
-solidity gem - (fuzzy) parser for (crypto) contracts for ethereum & co.
+solidity gem - (fuzzy) lexer & parser for (crypto) contracts for ethereum & co.
 
 
 * home  :: [github.com/rubycocos/blockchain](https://github.com/rubycocos/blockchain)
@@ -29,25 +12,7 @@ solidity gem - (fuzzy) parser for (crypto) contracts for ethereum & co.
 
 ## New to the Solidity (Contract) Programming Language?
 
-_Official_
-
-Solidity Language @ <https://soliditylang.org>
-
-- Read the Docs @ <https://docs.soliditylang.org/en/latest/>
-- Blog @  <https://blog.soliditylang.org>
-- Forum @ <https://forum.soliditylang.org>
-- Source @ <https://github.com/ethereum/solidity>
-
-<!-- break -->
-
-_More_
-
-Solidity by Example @ <https://solidity-by-example.org>
-
-Learn X in Y Minutes (Where X=Solidity) @ <https://learnxinyminutes.com/docs/solidity>
-
-Awesome Solidity @ <https://github.com/bkrem/awesome-solidity>
-
+See [**Awesome Solidity @ Open Blockchains »**](https://github.com/openblockchains/awesome-solidity)
 
 
 
@@ -95,24 +60,24 @@ Note:  The outline includes:
 
 1. contract definitions e.g.
 
-    contract NounsDescriptor is INounsDescriptor, Ownable
+        contract NounsDescriptor is INounsDescriptor, Ownable
 
 2. abstract contract definitions e.g.
 
-    abstract contract Ownable is Context
-    abstract contract Context
+        abstract contract Ownable is Context
+        abstract contract Context
 
 3. library definitions e.g.
 
-    library Strings
-    library NFTDescriptor
-    library MultiPartRLEToSVG
-    library Base64
+        library Strings
+        library NFTDescriptor
+        library MultiPartRLEToSVG
+        library Base64
 
 4. interface definitions e.g.
 
-    interface INounsDescriptor
-    interface INounsSeeder
+        interface INounsDescriptor
+        interface INounsSeeder
 
 
 

data/Rakefile

@@ -14,7 +14,7 @@ Hoe.spec 'solidity' do
 
   self.version = Solidity::VERSION
 
-  self.summary = "solidity - (fuzzy) parser for (crypto) contracts for ethereum & co."
+  self.summary = "solidity - (fuzzy) lexer & parser for (crypto) contracts for ethereum & co."
   self.description = summary
 
   self.urls    = { home: 'https://github.com/rubycocos/blockchain' }

data/lib/solidity/lexer.rb

@@ -0,0 +1,187 @@
+module Solidity
+
+class Lexer
+
+   def self.read( path )
+      txt = read_text( path )
+      new( txt )
+   end
+
+
+
+   def initialize( txt )
+     @txt    = txt
+     @tokens = tokenize
+     @pos    = 0
+   end
+
+
+
+  ###############
+  ## quotes
+  ##
+  ## note: regex pattern \\ needs to get escaped twice, thus, \\.
+  ##  and for literal \\ use \\\\\.
+
+  ## => \\\\.    --  allow backslash escapes e.g. \n \t \\ etc.
+  ## => [^`]     --  everything except backquote
+
+  ## todo/fix - check if [^`] includes/matches newline too (yes)? -- add \n for multi-line!
+
+
+  ## from the solidity grammar
+  ##
+  ## StringLiteralFragment
+  ##  : 'unicode'? '"' DoubleQuotedStringCharacter* '"'
+  ##  | 'unicode'? '\'' SingleQuotedStringCharacter* '\'' ;
+  ##
+  ## fragment
+  ## DoubleQuotedStringCharacter
+  ##   : ~["\r\n\\] | ('\\' .) ;
+  ##
+  ## fragment
+  ## SingleQuotedStringCharacter
+  ##   : ~['\r\n\\] | ('\\' .) ;
+
+  DOUBLE_QUOTE       = %r{"
+                           ( \\\\. | [^"\r\n\\] )*
+                          "}x
+
+  SINGLE_QUOTE       = %r{'
+                           ( \\\\. | [^'\r\n\\] )*
+                         '}x
+
+
+  ## from the solidity grammar
+  ##  > An identifier in solidity has to start with a letter,
+  ##  >  a dollar-sign or an underscore and
+  ##  >  may additionally contain numbers after the first symbol.
+  ##
+  ## Identifier
+  ##   : IdentifierStart IdentifierPart* ;
+  ##
+  ##  fragment
+  ##    IdentifierStart
+  ##    : [a-zA-Z$_] ;
+  ##
+  ##  fragment
+  ##    IdentifierPart
+  ##   : [a-zA-Z0-9$_] ;
+
+   NAME  = /[a-zA-Z$_][a-zA-Z0-9$_]*/
+
+
+  ## from the solidity grammar
+  ##
+  ## COMMENT
+  ##   : '/*' .*? '*/'  ;
+  ## LINE_COMMENT
+  ##   : '//' ~[\r\n]* ;
+
+  COMMENT = %r{/\*
+                .*?
+                \*/}x
+
+  LINE_COMMENT = %r{//
+                     [^\r\n]*}x
+
+   def tokenize
+     t = []
+     s = StringScanner.new( @txt )
+
+     until s.eos?   ## loop until hitting end-of-string (file)
+       if s.scan( /[ \t]+/ )   ## one or more spaces
+          ## note: (auto-)convert tab to space - why? why not?
+          t << [:sp, s.matched.gsub( /[\t]/, ' ') ]
+       elsif s.scan( /\r?\n/ )    ## check for (windows) carriage return (\r) - why? why not?
+          t << [:nl, "\n" ]
+       elsif s.scan( COMMENT )
+          t << [:comment, s.matched]
+       elsif s.scan( LINE_COMMENT )
+          t << [:comment, s.matched]
+       elsif s.scan( DOUBLE_QUOTE )  ## double-quoted string
+          t << [:string, s.matched]
+       elsif s.scan( SINGLE_QUOTE )  ## single-quoted string
+          t << [:string, s.matched]
+       elsif s.scan( NAME )
+          name = s.matched
+          case name
+          when 'pragma'    then  t << [:pragma, name]
+          when 'contract'  then  t << [:contract, name]
+          when 'abstract'  then  t << [:abstract, name]
+          when 'library'   then  t << [:library, name]
+          when 'interface' then  t << [:interface, name]
+          when 'function'  then  t << [:function, name]
+          when 'struct'    then  t << [:struct, name]
+          when 'enum'      then  t << [:enum, name]
+          when 'event'     then  t << [:event, name]
+          else
+             t << [:ident, name]
+          end
+       elsif s.scan( /;/ )   then   t << [:';', ';']
+       elsif s.scan( /\{/ )  then   t << [:'{', '{']
+       elsif s.scan( /\}/ )  then   t << [:'}', '}']
+       else    ## slurp until hitting a "tracked" token again
+           last = t[-1]
+           if last.is_a?( String )
+              last << s.getch  ## append char to last chunk
+           else
+              t << s.getch     ## start a new chunk
+           end
+       end
+     end
+     t
+   end
+
+
+
+   def reset() @pos = 0; end
+   def pos()   @pos;  end
+   def peek
+      ## note: returns token type for now (e.g. :string, :sp, etc.)
+      ##              and NOT token struct for now - why? why not?
+      t = @tokens[@pos]
+      t.nil? || t.is_a?( String ) ? t : t[0]
+   end
+   def next
+      ## note: returns type lexeme (string content) for now
+      ##            and NOT token struct for now - why? why not?
+      t = @tokens[@pos]
+      str =  t.nil? || t.is_a?( String ) ? t : t[1]
+      @pos += 1      unless t.nil?
+      str
+   end
+   def eos?()  peek().nil?; end
+
+
+
+
+   #################################################
+   #  "higher-level" helpers
+   def scan_until( tt, include: false )
+      code = String.new('')
+      while (peek=self.peek) != tt do
+         ## note:  turn inline comments into a single space
+         code <<   if peek == :comment
+                       self.next   ## note: next (w/o self) is parsed as keyword
+                       ' '
+                   else
+                       self.next  ## note: next (w/o self) is parsed as keyword
+                   end
+      end
+      code << self.next       if include  ## include ';' too - why? why not?
+      code = _norm_whitespace( code )
+      code
+   end
+
+   def _norm_whitespace( str )
+      ## change newlines to spaces and
+      ##   all multiple spaces to one
+      str = str.gsub( /[ \t\n\r]+/, ' ' )
+      str.strip
+   end
+
+
+
+end  # class Lexer
+end  # module Solidity

data/lib/solidity/parser.rb

@@ -14,168 +14,62 @@ class Parser
    end
 
 
-  ###############
-  ## quotes
-  ##
-  ## note: regex pattern \\ needs to get escaped twice, thus, \\.
-  ##  and for literal \\ use \\\\\.
-
-  ## => \\\\.    --  allow backslash escapes e.g. \n \t \\ etc.
-  ## => [^`]     --  everything except backquote
-
-  ## todo/fix - check if [^`] includes/matches newline too (yes)? -- add \n for multi-line!
-
-
-  ## from the solidity grammar
-  ##
-  ## StringLiteralFragment
-  ##  : 'unicode'? '"' DoubleQuotedStringCharacter* '"'
-  ##  | 'unicode'? '\'' SingleQuotedStringCharacter* '\'' ;
-  ##
-  ## fragment
-  ## DoubleQuotedStringCharacter
-  ##   : ~["\r\n\\] | ('\\' .) ;
-  ##
-  ## fragment
-  ## SingleQuotedStringCharacter
-  ##   : ~['\r\n\\] | ('\\' .) ;
-
-
-  SINGLE_QUOTE       = %r{'
-                           ( \\\\. | [^'] )*
-                         '}x
-
-  DOUBLE_QUOTE       = %r{"
-                           ( \\\\. | [^"] )*
-                          "}x
-
-
-  ## from the solidity grammar
-  ##  > An identifier in solidity has to start with a letter,
-  ##  >  a dollar-sign or an underscore and
-  ##  >  may additionally contain numbers after the first symbol.
-  ##
-  ## Identifier
-  ##   : IdentifierStart IdentifierPart* ;
-  ##
-  ##  fragment
-  ##    IdentifierStart
-  ##    : [a-zA-Z$_] ;
-  ##
-  ##  fragment
-  ##    IdentifierPart
-  ##   : [a-zA-Z0-9$_] ;
-
-   NAME                    = /[a-zA-Z$_][a-zA-Z0-9$_]*/
-
-
-   END_OF_LINE             = /\n|$/
-   ## inline comments (multi- or end-of-line)
-   END_OF_LINE_OR_COMMENT_OR_KEYWORD_OR_QUOTE  = / \n
-                                         | $
-                                         | (?=['"])
-                                         | (?=\/(\/|\*))
-                                         | (?=\bpragma\b)
-                                         | (?=\bcontract\b)
-                                         | (?=\babstract\b)
-                                         | (?=\blibrary\b)
-                                         | (?=\binterface\b)
-                                       /x
-
-
-  ## from the solidity grammar
-  ##
-  ## COMMENT
-  ##   : '/*' .*? '*/'  ;
-  ##
-  ## LINE_COMMENT
-  ##   : '//' ~[\r\n]* ;
-
-
-
-   def _norm_whitespace( str )
-      ## change newlines to spaces and
-      ##   all multiple spaces to one
-      str = str.gsub( /[ \t\n\r]+/, ' ' )
-      str.strip
-   end
 
-   def _quick_pass_one
-     ## note:  CANNOT handle inline comments
-     ##           in pragma, contract, etc.  (get "silently" slurped)
-     ##         report a parse error - if comments slurped - why? why not?
-     ##
 
 
+   def _quick_pass_one
      tree = []
 
-     s = StringScanner.new( @txt )
-
-     loop do
-       s.skip( /[ \t]+/ )  ## note: do NOT skip newlines here; pass along blank/empty lines for now - why? why not?
-       if s.check( "'" )   ## single-quoted string
-          str = s.scan( SINGLE_QUOTE )
-          tree << [:string, str]
-       elsif s.check( '"' )  ## double-quoted string
-          str = s.scan( DOUBLE_QUOTE )
-          tree << [:string, str]
-       elsif s.check( '/*' )
-          comment = s.scan_until( /\*\// )
-          ## print "multi-line comment:"
-          ## pp comment
-          tree << [:comment, comment]
-       elsif s.check( '//' )
-          comment = s.scan_until( END_OF_LINE ).rstrip
-          ## print "comment:"
-          ## pp comment
-          tree << [:comment, comment]
-       else
-          name = s.check( NAME )
-          case name
-          when 'pragma'
-             code = s.scan_until( /;/ )
-             code = _norm_whitespace( code )
+     lex = Lexer.new( @txt )
+
+     until lex.eos?
+       case lex.peek
+       when :comment  ## single or multi-line comment
+           tree << [:comment, lex.next]
+           ## note:  if next token is newline - slurp / ignore
+           lex.next    if lex.peek == :nl
+       when :pragma
+            code = lex.scan_until( :';',
+                                   include: true )
              ## print "pragma:"
              ## pp code
              tree << [:pragma, code]
-          when 'contract'
-             code = s.scan_until( /(?=\{)/ )
-             code = _norm_whitespace( code )
+       when :contract
+             code = lex.scan_until( :'{' )
              ## print "contract:"
              ## pp code
              tree << [:contract, code]
-          when 'abstract'
-            code = s.scan_until( /(?=\{)/ )
-            code = _norm_whitespace( code )
-            ## print "abstract contract:"
-            ## pp code
-            tree << [:abstract_contract, code]
-          when 'library'
-            code = s.scan_until( /(?=\{)/ )
-            code = _norm_whitespace( code )
-            ## print "library:"
-            ## pp code
-            tree << [:library, code]
-          when 'interface'
-            code = s.scan_until( /(?=\{)/ )
-            code = _norm_whitespace( code )
-            ## print "interface:"
-            ## pp code
-            tree << [:interface, code]
-          else
+       when :abstract
+             code = lex.scan_until( :'{' )
+             ## print "abstract contract:"
+             ## pp code
+             tree << [:abstract_contract, code]
+       when :library
+             code = lex.scan_until( :'{' )
+             ## print "library:"
+             ## pp code
+             tree << [:library, code]
+       when :interface
+             code = lex.scan_until( :'{' )
+             ## print "interface:"
+             ## pp code
+             tree << [:interface, code]
+       else
             ## slurp chunk ,that is, until newline or comment or tracked keyword
-            chunk = s.scan_until( END_OF_LINE_OR_COMMENT_OR_KEYWORD_OR_QUOTE ).rstrip
-            ## puts "chunk: >#{chunk.inspect}<"
-            tree << chunk
-          end
+            last = tree[-1]
+            if last.is_a?( String )
+               last <<  lex.next   ## append lexeme to last chunk
+            else
+               tree << lex.next    ## start a new chunk
+            end
        end
-       break if s.eos?
-      end
+     end
 
      tree
    end
 
 
+
    def outline
       buf = String.new( '' )
       tree = _quick_pass_one

data/lib/solidity/version.rb

@@ -1,8 +1,8 @@
 
 module Solidity
   MAJOR = 0
-  MINOR = 1
-  PATCH = 4
+  MINOR = 2
+  PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/lib/solidity.rb

@@ -3,6 +3,7 @@ require 'cocos'
 
 ## our own code
 require_relative 'solidity/version'    # note: let version always go first
+require_relative 'solidity/lexer'
 require_relative 'solidity/parser'
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solidity
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-01 00:00:00.000000000 Z
+date: 2023-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cocos
@@ -58,7 +58,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.23'
-description: solidity - (fuzzy) parser for (crypto) contracts for ethereum & co.
+description: solidity - (fuzzy) lexer & parser for (crypto) contracts for ethereum
+  & co.
 email: wwwmake@googlegroups.com
 executables: []
 extensions: []
@@ -72,6 +73,7 @@ files:
 - README.md
 - Rakefile
 - lib/solidity.rb
+- lib/solidity/lexer.rb
 - lib/solidity/parser.rb
 - lib/solidity/version.rb
 homepage: https://github.com/rubycocos/blockchain
@@ -98,5 +100,5 @@ requirements: []
 rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
-summary: solidity - (fuzzy) parser for (crypto) contracts for ethereum & co.
+summary: solidity - (fuzzy) lexer & parser for (crypto) contracts for ethereum & co.
 test_files: []