solidity 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a34efb053c8fd9211832cedb2a99a05362f10fb3e43323d6bca7cd69783a88d
-  data.tar.gz: 3e113d90344d4a4745836b3b8bea5f18f4ac3c621d56914e5610c331f25dba20
+  metadata.gz: 7039440cfd0f451c6d990c35cdbef3a23309b86ce3c380cb4716ad9647b27f5d
+  data.tar.gz: e69c2a1a4273a5c9abc2858d5fe5a9cc27dc46656acf321e39cb520addb579c1
 SHA512:
-  metadata.gz: ea91690f94b665991f5f2e6934def21c1dd70ac475efc1e6cd578d84a05e31a7437dac0c1c3f9bffecb1283655ba3454d663f04a4ff190246ce240b4ea900535
-  data.tar.gz: f8b3f08e0691d3cfc34b25ab6652a632f41df90a6d0d593f699971886301a329fcb4f6fac048d3d041432d446030b89338cf9cabd01239a00a4a69aa50de9c45
+  metadata.gz: a97fb7eeac099baf18b2045fa60351b97ac36207c68517553498c35912f4eed73727aa94d8e9b70a7b2512e9efeb865d764161fa56876c1fcac2f87782333049
+  data.tar.gz: 68abe7d1bb83abdbd5a45f6cd3303a9ff368ae87f73046a9f3d40858e4407fc4f8fb300e599aca915a68921a9d3ff286b88ae4b29746e5fcd7b2ac0d2634f324

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)
 
 
 
@@ -55,7 +20,6 @@ Awesome Solidity @ <https://github.com/bkrem/awesome-solidity>
 ## Usage
 
 Get / generate outline from source in the solidity (`.sol`) contract programming language:
-
 ```ruby
 [
  "0x34625ecaa75c0ea33733a05c584f4cf112c10b6b",
@@ -92,6 +56,36 @@ library Base64
 ```
 
 
+Note:  The outline includes:
+
+1. contract definitions e.g.
+
+        contract NounsDescriptor is INounsDescriptor, Ownable
+
+2. abstract contract definitions e.g.
+
+        abstract contract Ownable is Context
+        abstract contract Context
+
+3. library definitions e.g.
+
+        library Strings
+        library NFTDescriptor
+        library MultiPartRLEToSVG
+        library Base64
+
+4. interface definitions e.g.
+
+        interface INounsDescriptor
+        interface INounsSeeder
+
+
+
+
+<!-- break -->
+
+More outline samples:
+
 ```
 outline:
 contract Indelible is ERC721A, ReentrancyGuard, Ownable

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,166 @@
+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\\] | ('\\' .) ;
+
+
+  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$_]*/
+
+
+  ## from the solidity grammar
+  ##
+  ## COMMENT
+  ##   : '/*' .*? '*/'  ;
+  ##
+  ## LINE_COMMENT
+  ##   : '//' ~[\r\n]* ;
+
+
+   def tokenize
+     t = []
+     s = StringScanner.new( @txt )
+
+     until s.eos?   ## loop until hitting end-of-string (file)
+       if s.check( /[ \t]*\/\*/ )
+          ## note: auto-slurp leading (optinal) spaces!!!! - why? why not?
+          comment = s.scan_until( /\*\// )
+          ## print "multi-line comment:"
+          ## pp comment
+          t << [:comment, comment.lstrip]
+       elsif s.check( /[ \t]*\/\// )
+          ## note: auto-slurp leading (optinal) spaces!!!!  - why? why not?
+          ## note: auto-remove newline AND trailing whitespace - why? why not?
+          comment = s.scan_until( /\n|$/ ).strip
+          ## print "comment:"
+          ## pp comment
+          t << [:comment, comment]
+       elsif 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.check( "'" )   ## single-quoted string
+          str = s.scan( SINGLE_QUOTE )
+          t << [:string, str]
+       elsif s.check( '"' )  ## double-quoted string
+          str = s.scan( DOUBLE_QUOTE )
+          t << [:string, str]
+       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]
+      tt =  t.nil? || t.is_a?( String ) ? t : t[1]
+      @pos += 1      unless t.nil?
+      tt
+   end
+   def eos?()  peek().nil?; end
+
+
+
+end  # class Lexer
+end  # module Solidity

data/lib/solidity/parser.rb

@@ -14,40 +14,24 @@ 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!
-
-  SINGLE_QUOTE       = %r{'
-                           ( \\\\. | [^'] )*
-                         '}x
-
-  DOUBLE_QUOTE       = %r{"
-                           ( \\\\. | [^"] )*
-                          "}x
-
-
-   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
 
+   def _scan_until( lex, tt, include: false )
+      code = String.new('')
+      while (peek=lex.peek) != tt do
+         ## note:  turn inline comments into a single space
+         code <<   if peek == :comment
+                       lex.next
+                       ' '
+                   else
+                        lex.next
+                   end
+      end
+      code << lex.next     if include  ## include ';' too - why? why not?
+      code = _norm_whitespace( code )
+      code
+   end
 
    def _norm_whitespace( str )
       ## change newlines to spaces and
@@ -56,82 +40,62 @@ class Parser
       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?
-     ##
+     tree = []
 
+     lex = Lexer.new( @txt )
 
-     tree = []
+     until lex.eos?
+       while lex.peek == :sp do   ## note: do NOT skip newlines here; pass along blank/empty lines for now - why? why not?
+           lex.next
+       end
 
-     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 )
+       case lex.peek
+       when :comment  ## single or multi-line comment
+           tree << [:comment, lex.next]
+       when :pragma
+            code = _scan_until( lex, :';',
+                                 include: true )
              ## print "pragma:"
              ## pp code
              tree << [:pragma, code]
-          when 'contract'
-             code = s.scan_until( /(?=\{)/ )
-             code = _norm_whitespace( code )
+       when :contract
+             code = _scan_until( lex, :'{' )
              ## 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 = _scan_until( lex, :'{' )
+             ## print "abstract contract:"
+             ## pp code
+             tree << [:abstract_contract, code]
+       when :library
+             code = _scan_until( lex, :'{' )
+             ## print "library:"
+             ## pp code
+             tree << [:library, code]
+       when :interface
+             code = _scan_until( lex, :'{' )
+             ## 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

@@ -2,7 +2,7 @@
 module Solidity
   MAJOR = 0
   MINOR = 1
-  PATCH = 3
+  PATCH = 5
   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.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-01 00:00:00.000000000 Z
+date: 2023-02-05 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: []