sweet-lang 0.2.2 → 0.3.7

data/lib/lexer.rb

@@ -1,3 +1,4 @@
+require "lexer/files"
 require "lexer/tags"
 require "lexer/strings"
 require "lexer/core"

data/lib/lexer/core.rb

@@ -3,7 +3,9 @@ class Lexer
 
   def treat(code)
     tags = Tags.new
-    code = tags.implement_tag(code)
+    strings = Strings.new
+    files = Files.new
+    code = strings.rollingback_strings(tags.implement_tag(files.includes(code)))
   end
   
   def tokenize(code)
@@ -14,11 +16,9 @@ class Lexer
     code = code.gsub( /[ ]+\n/, "\n" )
 		code = code.gsub( "\n ", "\n\t" )
 		code = code.gsub( /^\s*$/m, '' )
-    
-    tags = Tags.new
+    code = code.gsub( /^((\t)+)?\n/, '' )
 
 		code = treat(code)
-
     # Current character position we're parsing
     i = 0
     
@@ -66,37 +66,50 @@ class Lexer
       
      	# Here's the indentation magic!
 			elsif indent = chunk[/\A\n(\t+)/m, 1]
-				# Create a new block we expect the indent level to go up.
-				if indent.size < current_indent
-					indent_stack.pop
-					current_indent = indent_stack.last || 0
-					tokens << [:DEDENT, indent.size]
-					tokens << [:NEWLINE, "\n"]
-								
-				elsif indent.size == current_indent
-					tokens << [:NEWLINE, "\n"]
-					
-				else
-					# Adjust the current indentation level.
-					current_indent = indent.size
-					indent_stack.push(current_indent)
-					tokens << [:INDENT, indent.size]
-				end
-
+       # p "-----------"
+       # p indent.size
+       # p current_indent
+        # Create a new block we expect the indent level to go up.
+        if indent.size < current_indent
+          while current_indent > indent.size
+            indent_stack.pop
+            current_indent = indent_stack.last || 0
+            tokens << [:DEDENT, indent.size]
+            tokens << [:NEWLINE, "\n"]
+          end
+                
+        elsif indent.size == current_indent
+          tokens << [:NEWLINE, "\n"]
+          
+        else
+          # Adjust the current indentation level.
+          current_indent = indent.size
+          indent_stack << current_indent
+          tokens << [:INDENT, indent.size]
+        end
+       #  p tokens
+       # p "-----------"
+       # p "+++++#{current_indent}"
 				i += indent.size + 1
-
 			elsif indent = chunk[/\A\n(	*)/m, 1]
+        #       p "============"
+        # p indent.size
+        # p current_indent
 				if indent.size == current_indent
 					# Nothing to do, we're still in the same block
 					tokens << [:NEWLINE, "\n"]
 				elsif indent.size < current_indent
-					indent_stack.pop
-					current_indent = indent_stack.last || 0
-					tokens << [:DEDENT, indent.size]
-					tokens << [:NEWLINE, "\n"]
+          while current_indent > indent.size
+					 indent_stack.pop
+					 current_indent = indent_stack.last || 0
+					 tokens << [:DEDENT, indent.size]
+					 tokens << [:NEWLINE, "\n"]
+          end
 				end
+        # p tokens
+        #       p "============"
+        #       p "+++++#{current_indent}"
 				i += indent.size + 1
-      
       # Match long operators such as ||, &&, ==, !=, <= and >=.
       # One character long operators are matched by the catch all `else` at the bottom.
       elsif operator = chunk[/\A(\|\||&&|==|!=|<=|>=)/, 1]
@@ -122,7 +135,9 @@ class Lexer
     while indent = indent_stack.pop
       tokens << [:DEDENT, indent_stack.last || 0]
     end
-    
+    # p "================================"
+    # p tokens
+    # p "================================"
     tokens
   end
 end

data/lib/lexer/files.rb

@@ -0,0 +1,20 @@
+class Files
+
+	def includes(code)
+		includes = code.scan(/(((\t)+)?<~([ .\/=-_a-zA-Z0-9]+))/)
+		includes.uniq!
+		includes.each do |include_|
+			result = ""
+			file_ = include_[3].gsub(" ", "")
+			indent = (include_[1].nil?) ? 0 : include_[1].count("\t") 
+			indent = "\t" * indent
+			file_ = File.new("#{$path}#{file_}", "r")
+			while (line = file_.gets)
+				result += "#{indent}#{line}"
+			end
+			code = code.gsub(/^#{include_[0]}$/, result)
+		end
+		return code
+	end
+
+end

data/lib/lexer/strings.rb

@@ -1,7 +1,8 @@
 class Strings
 
-	def convert_string(code, indent)
+	def convert_string(code, indent, defs=false)
 		strings = code.scan(/\t("[^"]+")/m)
+		defs_back = code.scan(/\t(\/("[^"]+")\/)/m)
 		strings.uniq!
 		strings.each do |string|
 			original_tabs = code.scan(/((\t)+)#{string[0]}/)
@@ -18,18 +19,35 @@ class Strings
 					n_string = n_string.sub(/(\t)+/, "#{ '  ' * (actual_tab - original_tabs) }")
 				end
 			end
-			new_string = "print(#{n_string})"
+			new_string = ( defs ) ? "/#{n_string}/" : "print(#{n_string})"
 			code = code.gsub(string[0], new_string)
 		end
 		return code
 	end
 
+	def treat_def(code)
+		defs = code.scan(/^(\t*)(def(()$| )(((\n)?[a-zA-Z0-9= _\-#.\\'\/\"]+)+)?(((\n)+?\1{1,}\t+)?(["#a= ()a-zA-Z0-9_.,\--\\'\/&]+)?)+)/)
+		defs.map! {|x| x[1]}
+		defs.each do |def_|
+			code = code.gsub(def_, convert_string( def_, 1, true ))
+		end
+		code
+	end
+
+	def rollingback_strings(code)
+		defs_back = code.scan(/\t(\/("[^"]+")\/)/m)
+		defs_back.each do |def_|
+			code = code.gsub(def_[0], def_[1])
+		end
+		code
+	end
+
 	def fix_atr(code, indent)
 		strings = code.scan(/print\(.*\)/m)
 		strings.uniq!
 		n_string = strings[0].gsub("\\=", "=")
 		code = code.gsub(strings[0], n_string)
-		return code
+		code
 	end
 
 end

data/lib/lexer/tags.rb

@@ -14,7 +14,7 @@ class Tags
 		"var"]
 
 	def convert_tag(code, index, indent, tag, atr, inline=false)
-		content = code.scan(/(\t+[a-zA-Z0-9]+.*)/)
+		content = code.scan(/(\t+[\/"a-zA-Z0-9]+.*)/)
 		tab = ""
 		p_tab = ""
 		for i in 0..indent
@@ -53,8 +53,8 @@ class Tags
 			end
 			orig.uniq!
 			orig.each do |_old|
-				_new = "#{a[0]}=#{_old[1]}"
-				code = code.gsub(_old[0], _new)
+				_new = " #{a[0]}=#{_old[1]}"
+				code = code.gsub(/ #{_old[0]}/, _new)
 			end
 		end
 		return code
@@ -80,15 +80,17 @@ class Tags
 			end
 		end
 		@@tags.each do |tag|
-			general = code.scan(/(^(#{tag}(()$| )([ :\/\?\+#.=_\-a-zA-Z0-9]+)?((\n\t.*)+)?).*)/m)
-			general.map! {|x| x[0]}
+			general = code.scan(/(^(#{tag}(()$| )([ :;\/\?\+#.=_\-a-zA-Z0-9]+)?((\n\t.*)+)?).*)/)
+			general_old = general
+			general.map! {|x| x[1]}
+			general.uniq!
 			general.each_with_index do |block, index|
 				_code_block = block
 				code_block = adding_attributes(block, tag)
-				code_block = @strings.convert_string( code_block, indent )
-				@@tags.each do |r_tag|
-					if !code_block.scan(/^(\t){#{indent}}(#{r_tag}(()$| )((\n)+?[a-zA-Z0-9= \t_\-#.\\'\/]+)?(((\n)+?\1{#{indent+1},})?(["#a= ()a-zA-Z0-9_.,\--\\'\/&]+)?)+)/m).empty?
-						r_code = code_block.scan(/^(\t){#{indent}}(#{r_tag}(()$| )((\n)+?[a-zA-Z0-9= \t_\-#.\\'\/]+)?(((\n)+?\1{#{indent+1},})?(["#a= ()a-zA-Z0-9_.,\--\\'\/&]+)?)+)/m)
+				code_block = @strings.treat_def(code_block)
+				@@tags.each do |r_tag|		
+					if !code_block.scan(/^(\t){#{indent}}(#{r_tag}(()$| )(((\n)?[a-zA-Z0-9= _\-#.\\'\/\"]+)+)?(((\n)+?\1{#{indent+1},})?(["#a= ()a-zA-Z0-9_.,\--\\'\/&]+)?)+)/m).empty?
+						r_code = code_block.scan(/^(\t){#{indent}}(#{r_tag}(()$| )(((\n)?[a-zA-Z0-9= _\-#.\\'\/\"]+)+)?(((\n)+?\1{#{indent+1},})?(["\!\?#a= ()a-zA-Z0-9_.,\--\\'\/&]+)?)+)/m)
 						r_code.each do |r|
 							new_indent = indent + 1
 							new_block = implement_tag(r[1], new_indent)
@@ -96,9 +98,12 @@ class Tags
 						end
 					end
 				end
-				atr = code_block.scan(/([a-zA-Z0-9_-]+=)([\.\/:a-zA-Z0-9_-]+)/)
+				atr = code_block.scan(/([a-zA-Z0-9_-]+=)([\.\/:;#a-zA-Z0-9_-]+)/)
+				code_block = @strings.convert_string( code_block, indent )
 				code_block = convert_tag( code_block , index, indent, tag, atr)
-				code = code.gsub(_code_block, code_block)
+				_code_block = _code_block.gsub("(", '\(')
+				_code_block = _code_block.gsub(")", '\)')
+				code = code.gsub(/^#{_code_block}$/m, code_block)
 			end
 		end
 		code = @strings.fix_atr( code, indent )

data/lib/sweet.rb

@@ -10,7 +10,7 @@ class Sweet
   def parsing_options
 
     opts = Trollop::options do
-      version "Sweet 0.1.9 (c) 2011 Joao Moura a.k.a D3TR1"
+      version "Sweet 0.3.7 (c) 2012 Joao Moura a.k.a D3TR1"
       banner <<-EOS
       A Sweet Language, that compiles for HTML.
 
@@ -49,7 +49,7 @@ class Sweet
 end
 
 def compile_file(file)
-
+  $path = file.split(/[ =-_a-zA-Z0-9]+\.s/)[0]
   interpreter = Interpreter.new
   @filename = file.split(".")[0]
   File.new("#{@filename}.html", "w")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sweet-lang
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-13 00:00:00.000000000Z
+date: 2012-01-11 00:00:00.000000000Z
 dependencies: []
 description: ! "Sweet is a pre-compiled language based on Ruby and Python. \n    Sweet
   makes possible to use all the class, defs, conditionals, global and \n    local
@@ -31,6 +31,7 @@ files:
 - lib/lexer/core.rb
 - lib/lexer/strings.rb
 - lib/lexer/tags.rb
+- lib/lexer/files.rb
 - lib/runtime/bootstrap.rb
 - lib/runtime/class.rb
 - lib/runtime/context.rb