diff --git a/.gitignore b/.gitignore
index 669d022..3d419c3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -59,3 +59,7 @@ target/
 # Others
 *.idea/
 *.vagrant/
+
+*dumped.out
+
+tmp/
\ No newline at end of file
diff --git a/netasm/back_ends/soft_switch/datapath.py b/netasm/back_ends/soft_switch/datapath.py
index a3006c4..049dacf 100644
--- a/netasm/back_ends/soft_switch/datapath.py
+++ b/netasm/back_ends/soft_switch/datapath.py
@@ -2,7 +2,7 @@
 # ##
 # ##  https://github.com/NetASM/NetASM-python
 # ##
-# ##  File:#
+# ##  File:
 # ##        datapath.py
 # ##
 # ##  Project:
@@ -40,9 +40,7 @@
 ./pox.py --no-openflow datapath --address=localhost
 '''
 
-import sys
 from ast import literal_eval
-from importlib import import_module
 from Queue import Queue
 from threading import Thread
 import logging
@@ -60,6 +58,7 @@
 from netasm.netasm.core.syntax import *
 from netasm.netasm.core.common import bitmap_to_ports, ports_to_bitmap
 from netasm.netasm import validate, execute, optimize, cost
+from netasm.front_ends.netasm_dsl import parser
 
 
 class OpenFlowWorker(BackoffWorker):
@@ -160,51 +159,48 @@ def up(event):
 
 _MAX_PORTS = 64
 
+_parser = parser.Parser()
 
-def load_policy(switch, policy_name):
+
+def load_policy(switch, policy_file):
     if switch.policy:
         switch.policy.stop()
-    switch.policy_name = ''
+    switch.policy_file = ''
     switch.policy = None
 
     try:
-        if policy_name in sys.modules:
-            del sys.modules[policy_name]
-        module = import_module(policy_name)
+        fd = open(policy_file)
+        policy, errors_cnt = _parser.parse(fd.read())
+        fd.close()
+
+        if errors_cnt > 0:
+            raise TypeError('%s errors found' % errors_cnt)
     except ImportError, e:
-        raise RuntimeError('Must be a valid python module\n' +
-                           'e.g, full module name,\n' +
-                           '     no .py suffix,\n' +
-                           '     located on the system PYTHONPATH\n' +
-                           '\n' +
-                           'Exception message for ImportError was:' + e.message)
-    main = module.main
-
-    if main:
-        policy = main()
-        if isinstance(policy, Policy):
-            try:
-                validate.type_check.type_check_Policy(policy, _MAX_PORTS)
-                print "Policy [%s] (type check): passed!" % policy_name
-            except Exception, e:
-                print "Policy [%s] (type check): failed... " % policy_name + e.message
-                switch.policy_name = ''
-                switch.policy = None
-
-            area, latency = cost.cost_Policy(policy)
-            print "policy [%s] (original cost): Area=%s, Latency=%s" % (policy_name, area, latency)
-
-            policy = optimize.optimize_Policy(policy)
-            area, latency = cost.cost_Policy(policy)
-            print "Policy [%s] (optimize cost): Area=%s, Latency=%s" % (policy_name, area, latency)
-
-            switch.policy_name = policy_name
-            switch.policy = execute.Execute(policy)
-            switch.policy.start()
-        else:
-            raise RuntimeError("Invalid policy: %s" % (policy_name, ))
+        raise RuntimeError('Must be a valid policy file\n' +
+                           'Exception message was:' + e.message)
+
+    if isinstance(policy, Policy):
+        try:
+            validate.type_check.type_check_Policy(policy, _MAX_PORTS)
+            print "Policy [%s] (type check): passed!" % policy_file
+        except Exception, e:
+            switch.policy_file = ''
+            switch.policy = None
+            raise RuntimeError('Policy [%s] (type check): failed... \n' % policy_file +
+                               'Exception message was:' + e.message)
+
+        area, latency = cost.cost_Policy(policy)
+        print "policy [%s] (original cost): Area=%s, Latency=%s" % (policy_file, area, latency)
+
+        policy = optimize.optimize_Policy(policy)
+        area, latency = cost.cost_Policy(policy)
+        print "Policy [%s] (optimize cost): Area=%s, Latency=%s" % (policy_file, area, latency)
+
+        switch.policy_file = policy_file
+        switch.policy = execute.Execute(policy)
+        switch.policy.start()
     else:
-        raise RuntimeError("Invalid policy: %s" % (policy_name, ))
+        raise RuntimeError("Invalid policy: %s" % policy_file)
 
 
 def _do_ctl(event):
@@ -251,16 +247,16 @@ def ra(low, high=None):
         elif event.first == 'set-policy':
             ra(2)
             switch = _switches[event.args[0]]
-            policy_name = event.args[1]
+            policy_file = event.args[1]
 
-            load_policy(switch, policy_name)
+            load_policy(switch, policy_file)
         elif event.first == 'clr-policy':
             ra(1)
             switch = _switches[event.args[0]]
 
             if switch.policy:
                 switch.policy.stop()
-            switch.policy_name = ''
+            switch.policy_file = ''
             switch.policy = None
         elif event.first == "add-table-entry":
             ra(4)
@@ -302,7 +298,7 @@ def ra(low, high=None):
             ra(0)
             s = []
             for switch in _switches.values():
-                s.append("Switch %s (%s)" % (switch.name, switch.policy_name))
+                s.append("Switch %s (%s)" % (switch.name, switch.policy_file))
                 for no, p in switch.ports.iteritems():
                     s.append(" %3s %s" % (no, p.name))
             return "\n".join(s)
@@ -372,9 +368,9 @@ def __init__(self, **kw):
         ports = kw.pop('ports', [])
         kw['ports'] = []
 
-        self.policy_name = kw.pop("policy", '')
-        if self.policy_name:
-            load_policy(self, self.policy_name)
+        self.policy_file = kw.pop("policy", '')
+        if self.policy_file:
+            load_policy(self, self.policy_file)
 
         super(ProgSwitch, self).__init__(**kw)
 
@@ -480,12 +476,13 @@ def _tx_vendor(self, vendor):
 
     def _handle_out_message(self, message, connection):
         if message['operation'] == 'set-policy':
-            policy_name = message['data']
+            policy_file = message['data']
 
-            load_policy(self, policy_name)
+            load_policy(self, policy_file)
         elif message['operation'] == 'clr-policy':
             if self.policy:
                 self.policy.stop()
+            self.policy_file = ''
             self.policy = None
         elif message['operation'] == 'add-table-entry':
             t_name = message['data'][0]
diff --git a/netasm/examples/front_ends/__init__.py b/netasm/examples/front_ends/__init__.py
new file mode 100644
index 0000000..e317e67
--- /dev/null
+++ b/netasm/examples/front_ends/__init__.py
@@ -0,0 +1 @@
+__author__ = 'shahbaz'
diff --git a/netasm/examples/front_ends/netasm_dsl/__init__.py b/netasm/examples/front_ends/netasm_dsl/__init__.py
new file mode 100644
index 0000000..e317e67
--- /dev/null
+++ b/netasm/examples/front_ends/netasm_dsl/__init__.py
@@ -0,0 +1 @@
+__author__ = 'shahbaz'
diff --git a/netasm/examples/front_ends/netasm_dsl/standalone/__init__.py b/netasm/examples/front_ends/netasm_dsl/standalone/__init__.py
new file mode 100644
index 0000000..e317e67
--- /dev/null
+++ b/netasm/examples/front_ends/netasm_dsl/standalone/__init__.py
@@ -0,0 +1 @@
+__author__ = 'shahbaz'
diff --git a/netasm/examples/front_ends/netasm_dsl/standalone/decrement_loop.netasm b/netasm/examples/front_ends/netasm_dsl/standalone/decrement_loop.netasm
new file mode 100644
index 0000000..9e0ceb8
--- /dev/null
+++ b/netasm/examples/front_ends/netasm_dsl/standalone/decrement_loop.netasm
@@ -0,0 +1,49 @@
+# ################################################################################-
+# ##
+# ##  https://github.com/NetASM/NetASM-python
+# ##
+# ##  File:
+# ##        decrement_loop.netasm
+# ##
+# ##  Project:
+# ##        NetASM: A Network Assembly Language for Programmable Dataplanes
+# ##
+# ##  Author:
+# ##        Muhammad Shahbaz
+# ##
+# ##  Copyright notice:
+# ##        Copyright (C) 2014 Princeton University
+# ##      Network Operations and Internet Security Lab
+# ##
+# ##  Licence:
+# ##        This file is a part of the NetASM development base package.
+# ##
+# ##        This file is free code: you can redistribute it and/or modify it under
+# ##        the terms of the GNU Lesser General Public License version 2.1 as
+# ##        published by the Free Software Foundation.
+# ##
+# ##        This package is distributed in the hope that it will be useful, but
+# ##        WITHOUT ANY WARRANTY; without even the implied warranty of
+# ##        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# ##        Lesser General Public License for more details.
+# ##
+# ##        You should have received a copy of the GNU Lesser General Public
+# ##        License along with the NetASM source package.  If not, see
+# ##        http://www.gnu.org/licenses/.
+
+.code (
+    .fields ()
+    .instrs (
+        ADD reg0 4'd16
+        LD reg0 4'd4
+        LBL "LBL_0"
+        BR reg0 Eq 4'd0 "LBL_HLT"
+        OP reg0 reg0 Sub 4'd1
+        JMP "LBL_0"
+        LBL "LBL_HLT"
+        LD outport_bitmap reg0
+        HLT
+    )
+)
+
+# TODO: This has some issue with type checking
\ No newline at end of file
diff --git a/netasm/netasm/core/parse.py b/netasm/examples/front_ends/netasm_dsl/standalone/hub.netasm
similarity index 88%
rename from netasm/netasm/core/parse.py
rename to netasm/examples/front_ends/netasm_dsl/standalone/hub.netasm
index 99223a7..3e1ef57 100644
--- a/netasm/netasm/core/parse.py
+++ b/netasm/examples/front_ends/netasm_dsl/standalone/hub.netasm
@@ -1,9 +1,9 @@
-# ################################################################################
+# ################################################################################-
 # ##
 # ##  https://github.com/NetASM/NetASM-python
 # ##
 # ##  File:
-# ##        parse.py
+# ##        hub.netasm
 # ##
 # ##  Project:
 # ##        NetASM: A Network Assembly Language for Programmable Dataplanes
@@ -31,6 +31,10 @@
 # ##        License along with the NetASM source package.  If not, see
 # ##        http://www.gnu.org/licenses/.
 
-__author__ = 'shahbaz'
-
-raise NotImplementedError()
\ No newline at end of file
+.code (
+    .fields ()
+    .instrs (
+        OP outport_bitmap inport_bitmap Xor 16'hFFFF
+        HLT
+    )
+)
\ No newline at end of file
diff --git a/netasm/examples/front_ends/netasm_dsl/standalone/learning_switch.netasm b/netasm/examples/front_ends/netasm_dsl/standalone/learning_switch.netasm
new file mode 100644
index 0000000..b3ebb64
--- /dev/null
+++ b/netasm/examples/front_ends/netasm_dsl/standalone/learning_switch.netasm
@@ -0,0 +1,147 @@
+# ################################################################################
+# ##
+# ##  https://github.com/NetASM/NetASM-python
+# ##
+# ##  File:
+# ##        learning_switch.netasm
+# ##
+# ##  Project:
+# ##        NetASM: A Network Assembly Language for Programmable Dataplanes
+# ##
+# ##  Author:
+# ##        Muhammad Shahbaz
+# ##
+# ##  Copyright notice:
+# ##        Copyright (C) 2014 Princeton University
+# ##      Network Operations and Internet Security Lab
+# ##
+# ##  Licence:
+# ##        This file is a part of the NetASM development base package.
+# ##
+# ##        This file is free code: you can redistribute it and/or modify it under
+# ##        the terms of the GNU Lesser General Public License version 2.1 as
+# ##        published by the Free Software Foundation.
+# ##
+# ##        This package is distributed in the hope that it will be useful, but
+# ##        WITHOUT ANY WARRANTY; without even the implied warranty of
+# ##        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# ##        Lesser General Public License for more details.
+# ##
+# ##        You should have received a copy of the GNU Lesser General Public
+# ##        License along with the NetASM source package.  If not, see
+# ##        http://www.gnu.org/licenses/.
+
+# NOTE: We are not considering loop avoidance but we do take into account host migration in this example
+
+.decls (
+    # Ethernet address table
+    eth_match_table = ([(eth_addr 16'd48 Binary)] 16'd16 CAM)
+    eth_params_table = ([(outport_bitmap 16'd3)] 16'd16 RAM)
+
+    # Index table
+    index_table = ([(index 16'd16)] 1'd1 RAM)
+)
+
+.code (
+    .fields ()
+
+    .instrs(
+        ##################
+        ## Parse packet ##
+        ##################
+
+        # Add ethernet header fields
+        ADD eth_dst 16'd48
+        ADD eth_src 16'd48
+        ADD eth_type 16'd16
+
+        # Load fields with default values
+        LD eth_dst 48'd0
+        LD eth_src 48'd0
+        LD eth_type 16'd0
+
+        # Parser packet
+        # load ethernet header fields from the packet
+        LD eth_dst 16'd0::l
+        LD eth_src 16'd48::l
+        LD eth_type 16'd96::l
+
+        ########################
+        ## Lookup MAC address ##
+        ########################
+
+        # Add index field
+        ADD index 16'd16
+
+        ATM (
+            .code (
+                .fields (index eth_dst eth_src)
+                .instrs (
+                    # Lookup in the match table and store the matched index
+                    LKt index eth_match_table [eth_dst]
+                    BR index Neq 16'd-1 "LBL_LKP_0"
+
+                    # Case: there is no match in the match table
+                    # Broadcast the packet
+                    OP outport_bitmap inport_bitmap Xor 16'hFFFF
+                    JMP "LBL_LRN"
+
+                    # Case: there is a match in the l2 match table
+                    LBL "LBL_LKP_0"
+
+                    # Load output port from the parameters table
+                    LDt [outport_bitmap] eth_params_table index
+
+                    #######################
+                    ## Learn MAC address ##
+                    #######################
+                    LBL "LBL_LRN"
+
+                    # Lookup in the match table and store the matched index
+                    LKt index eth_match_table [eth_src]
+                    BR index Neq 16'd-1 "LBL_LRN_0"
+
+                    # Case: there is no match in the match table
+                    # Read the running index from the index table
+                    LDt [index] index_table 1'd0
+
+                    # Store eth_src in the eth_match_table
+                    STt eth_match_table index [(eth_src 48'hFFFFFFFFFFFF)]
+
+                    # Store inport_bitmap in the eth_params_table
+                    STt eth_params_table index [inport_bitmap]
+
+                    # Increment the running index
+                    OP index index Add 16'd1
+
+                    # Check if the index is less than the MAC_TABLE_SIZE
+                    BR index Lt 16'd16 "LBL_LRN_1"
+
+                    # Reset the running index
+                    LD index 16'd0
+
+                    # Store the running index back in the table
+                    LBL "LBL_LRN_1"
+
+                    STt index_table 1'd0 [index]
+                    JMP "LBL_HLT"
+
+                    # Store the current inport_bitmap in the eth_params_table
+                    LBL "LBL_LRN_0"
+
+                    STt eth_params_table index [inport_bitmap]
+
+                    # Halt
+                    LBL "LBL_HLT"
+                    HLT
+                )
+            )
+        )
+
+        ##########
+        ## Halt ##
+        ##########
+        LBL "LBL_HLT"
+        HLT
+    )
+)
\ No newline at end of file
diff --git a/netasm/netasm/parse.py b/netasm/examples/front_ends/netasm_dsl/standalone/pass_through_2ports.netasm
similarity index 82%
rename from netasm/netasm/parse.py
rename to netasm/examples/front_ends/netasm_dsl/standalone/pass_through_2ports.netasm
index ca1295e..d09d430 100644
--- a/netasm/netasm/parse.py
+++ b/netasm/examples/front_ends/netasm_dsl/standalone/pass_through_2ports.netasm
@@ -3,7 +3,7 @@
 # ##  https://github.com/NetASM/NetASM-python
 # ##
 # ##  File:
-# ##        parse.py
+# ##        pass_through_2ports.netasm
 # ##
 # ##  Project:
 # ##        NetASM: A Network Assembly Language for Programmable Dataplanes
@@ -31,6 +31,17 @@
 # ##        License along with the NetASM source package.  If not, see
 # ##        http://www.gnu.org/licenses/.
 
-__author__ = 'shahbaz'
+.code (
+    .fields()
+    .instrs(
+        BR inport_bitmap Eq 2'd2 "LBL_1"
+        LD outport_bitmap 2'd2
+        JMP "LBL_HLT"
 
-from netasm.netasm.core.parse import *
\ No newline at end of file
+        LBL "LBL_1"
+        LD outport_bitmap 1'd1
+
+        LBL "LBL_HLT"
+        HLT
+    )
+)
\ No newline at end of file
diff --git a/netasm/examples/netasm/standalone/decrement_loop.py b/netasm/examples/netasm/standalone/decrement_loop.py
index 73d6861..be70f41 100644
--- a/netasm/examples/netasm/standalone/decrement_loop.py
+++ b/netasm/examples/netasm/standalone/decrement_loop.py
@@ -5,7 +5,7 @@
 # ##  https://github.com/NetASM/NetASM-python
 # ##
 # ##  File:
-# ##        hub.py
+# ##        decrement_loop.py
 # ##
 # ##  Project:
 # ##        NetASM: A Network Assembly Language for Programmable Dataplanes
diff --git a/netasm/front_ends/__init__.py b/netasm/front_ends/__init__.py
new file mode 100644
index 0000000..e317e67
--- /dev/null
+++ b/netasm/front_ends/__init__.py
@@ -0,0 +1 @@
+__author__ = 'shahbaz'
diff --git a/netasm/front_ends/netasm_dsl/__init__.py b/netasm/front_ends/netasm_dsl/__init__.py
new file mode 100644
index 0000000..bb2763c
--- /dev/null
+++ b/netasm/front_ends/netasm_dsl/__init__.py
@@ -0,0 +1 @@
+__author__ = 'shahbaz'
\ No newline at end of file
diff --git a/netasm/front_ends/netasm_dsl/dumper.py b/netasm/front_ends/netasm_dsl/dumper.py
new file mode 100644
index 0000000..d2a4e08
--- /dev/null
+++ b/netasm/front_ends/netasm_dsl/dumper.py
@@ -0,0 +1,66 @@
+# ################################################################################
+# ##
+# ##  https://github.com/NetASM/NetASM-python
+# ##
+# ##  File:
+# ##        dumper.py
+# ##
+# ##  Project:
+# ##        NetASM: A Network Assembly Language for Programmable Dataplanes
+# ##
+# ##  Author:
+# ##        Muhammad Shahbaz
+# ##
+# ##  Copyright notice:
+# ##        Copyright (C) 2014 Princeton University
+# ##      Network Operations and Internet Security Lab
+# ##
+# ##  Licence:
+# ##        This file is a part of the NetASM development base package.
+# ##
+# ##        This file is free code: you can redistribute it and/or modify it under
+# ##        the terms of the GNU Lesser General Public License version 2.1 as
+# ##        published by the Free Software Foundation.
+# ##
+# ##        This package is distributed in the hope that it will be useful, but
+# ##        WITHOUT ANY WARRANTY; without even the implied warranty of
+# ##        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# ##        Lesser General Public License for more details.
+# ##
+# ##        You should have received a copy of the GNU Lesser General Public
+# ##        License along with the NetASM source package.  If not, see
+# ##        http://www.gnu.org/licenses/.
+
+__author__ = 'shahbaz'
+
+from optparse import OptionParser
+from parser import Parser
+
+
+def main():
+    op = OptionParser()
+    op.add_option('--ifile', action="store", dest="ifile")
+    op.add_option('--ofile', action="store", dest="ofile")
+
+    op.set_defaults(ofile='./dumped.out')
+    options, args = op.parse_args()
+
+    if not options.ifile:
+        print '--ifile flag not specified.'
+        exit(1)
+
+    ifile = open(options.ifile)
+    ofile = open(options.ofile, 'w')
+
+    parser = Parser()
+    policy, errors_cnt = parser.parse(ifile.read())
+
+    ofile.write(str(policy))
+    ofile.write('\n')
+    ofile.write('Total errors: ' + str(errors_cnt))
+
+    ifile.close()
+    ofile.close()
+
+
+main()
diff --git a/netasm/front_ends/netasm_dsl/lexer.py b/netasm/front_ends/netasm_dsl/lexer.py
new file mode 100644
index 0000000..4f932b3
--- /dev/null
+++ b/netasm/front_ends/netasm_dsl/lexer.py
@@ -0,0 +1,185 @@
+# ################################################################################
+# ##
+# ##  https://github.com/NetASM/NetASM-python
+# ##
+# ##  File:
+# ##        lexer.py
+# ##
+# ##  Project:
+# ##        NetASM: A Network Assembly Language for Programmable Dataplanes
+# ##
+# ##  Author:
+# ##        Muhammad Shahbaz
+# ##
+# ##  Copyright notice:
+# ##        Copyright (C) 2014 Princeton University
+# ##      Network Operations and Internet Security Lab
+# ##
+# ##  Licence:
+# ##        This file is a part of the NetASM development base package.
+# ##
+# ##        This file is free code: you can redistribute it and/or modify it under
+# ##        the terms of the GNU Lesser General Public License version 2.1 as
+# ##        published by the Free Software Foundation.
+# ##
+# ##        This package is distributed in the hope that it will be useful, but
+# ##        WITHOUT ANY WARRANTY; without even the implied warranty of
+# ##        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# ##        Lesser General Public License for more details.
+# ##
+# ##        You should have received a copy of the GNU Lesser General Public
+# ##        License along with the NetASM source package.  If not, see
+# ##        http://www.gnu.org/licenses/.
+
+__author__ = 'shahbaz'
+
+from ply import lex
+from ply.lex import TOKEN
+
+
+class Lexer:
+    def __init__(self):
+        self.lexer = None
+
+    keywords = (
+        # Operators
+        'Add', 'Sub', 'Mul', 'Div', 'And', 'Or', 'Xor',
+
+        # Comparators
+        'Eq', 'Neq', 'Lt', 'Gt', 'Le', 'Ge',
+
+        # Instructions
+        'ID', 'DRP', 'CTR', 'ADD', 'RMV',
+        'LD', 'ST', 'OP', 'PUSH', 'POP',
+        'BR', 'JMP', 'LBL', 'LDt', 'STt',
+        'INCt', 'LKt', 'CRC', 'HSH', 'HLT',
+        'CNC', 'ATM', 'SEQ',
+
+        # Match types
+        'Binary', 'Ternary',
+
+        # Table types
+        'CAM', 'RAM', 'HASH'
+    )
+
+    keywords_map = {}
+    for keyword in keywords:
+        keywords_map[keyword] = keyword
+
+    tokens = (
+        # Identifiers and strings
+        'IDN', 'STR',
+
+        # Numbers and (Hexa)Decimal
+        'NUM', 'DEC', 'HEX',
+
+        # Delimeters
+        'LPAREN', 'RPAREN',  # ()
+        'LBRACKET', 'RBRACKET',  # []
+
+        # Assignment
+        'EQUAL',
+
+        # Location
+        'LOC',
+
+        # Special
+        'S_DECLS', 'S_CODE', 'S_FIELDS', 'S_INSTRS'
+    )
+
+    tokens += keywords
+
+    t_ignore = ' \t'
+
+    t_LPAREN = r'\('
+    t_RPAREN = r'\)'
+    t_LBRACKET = r'\['
+    t_RBRACKET = r'\]'
+
+    t_EQUAL = r'='
+
+    t_LOC = r'::[lL]'
+
+    t_S_DECLS = r'\.decls'
+    t_S_CODE = r'\.code'
+    t_S_FIELDS = r'\.fields'
+    t_S_INSTRS = r'\.instrs'
+
+    t_NUM = r'[0-9]+'
+    t_DEC = r"'[dD][-+]?[0-9]+"
+    t_HEX = r"'[hH][0-9a-fA-F]+"
+
+    identifier = r'[a-zA-Z_][0-9a-zA-Z_]*'
+
+    @TOKEN(identifier)
+    def t_IDN(self, t):
+        t.type = self.keywords_map.get(t.value, "IDN")
+        return t
+
+    t_STR = '\"[^\"]*\"'
+
+    comment = r'[#][^\n]*'
+
+    @TOKEN(comment)
+    def t_comment(self, t):
+        pass
+
+    newline = r'\n+'
+
+    @TOKEN(newline)
+    def t_newline(self, t):
+        t.lexer.lineno += len(t.value)
+
+    def t_error(self, t):
+        print "Illegal character '%s'" % t.value[0]
+        t.lexer.skip(1)
+
+    def warning(self, t):
+        print "Illegal character '%s'" % t.value[0]
+        t.lexer.skip(1)
+
+    def reset_lineno(self):
+        self.lexer.lineno = 1
+
+    def get_lineno(self):
+        return self.lexer.lineno
+
+    def input(self, text):
+        self.lexer.input(text)
+
+    def token(self):
+        t = self.lexer.token()
+        return t
+
+    def find_tok_column(self, token):
+        last_cr = self.lexer.lexdata.rfind('\n', 0, token.lexpos)
+        return token.lexpos - last_cr
+
+    def build(self, **kwargs):
+        self.lexer = lex.lex(module=self, **kwargs)
+
+
+if __name__ == '__main__':
+    lexer = Lexer()
+    lexer.build()
+    lexer.input('''
+.code (
+    .fields ()
+    .instrs (
+        ADD reg0 16
+        LD reg0 16'd-4
+        LBL "LBL_0"
+        BR reg0 Eq 16'd0 "LBL_HLT"
+        OP reg0 reg0 Sub 'h1
+        JMP "LBL_0"
+        LBL "LBL_HLT"
+        LD outport_bitmap reg0
+        HLT
+    )
+)
+    ''')
+
+    while True:
+        t = lexer.token()
+        if not t: break
+        print t
diff --git a/netasm/front_ends/netasm_dsl/netasm_dsl.bnf b/netasm/front_ends/netasm_dsl/netasm_dsl.bnf
new file mode 100644
index 0000000..9ec8a8e
--- /dev/null
+++ b/netasm/front_ends/netasm_dsl/netasm_dsl.bnf
@@ -0,0 +1,155 @@
+(*#############################################################################
+#
+#  https://github.com/NetASM/NetASM-python
+#
+#  File:
+#        netasm_dsl.bnf
+#
+#  Project:
+#        NetASM: A Network Assembly Language for Programmable Dataplanes
+#
+#  Author:
+#        Muhammad Shahbaz
+#
+#  Copyright notice:
+#        Copyright (C) 2014 Princeton University
+#      Network Operations and Internet Security Lab
+#
+#  Licence:
+#        This file is a part of the NetASM development base package.
+#
+#        This file is free code: you can redistribute it and/or modify it under
+#        the terms of the GNU Lesser General Public License version 2.1 as
+#        published by the Free Software Foundation.
+#
+#        This package is distributed in the hope that it will be useful, but
+#        WITHOUT ANY WARRANTY; without even the implied warranty of
+#        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#        Lesser General Public License for more details.
+#
+#        You should have received a copy of the GNU Lesser General Public
+#        License along with the NetASM source package.  If not, see
+#        http://www.gnu.org/licenses/.
+*)
+
+(* NetASM Domain-Specific Language *)
+
+<number> ::= [0-9]+
+
+<decimal_number> ::= '[dD][-+]?[0-9]+
+
+<hexadecimal_number> ::= '[hH][0-9a-fA-F]+
+
+<value_number> ::= <decimal_number>
+               ||= <hexadecimal_number>
+
+<value> ::= <number> <value_number>
+
+<identifier> ::= [a-zA-Z_][0-9a-zA-Z_]*
+
+<string> = "[^"]*"
+
+<size> ::= <value>
+
+<field> ::= <identifier>
+
+<fields> ::= <field>*
+
+<mask> ::= <value>
+
+<label> ::= <string>
+
+<reason> ::= <string> <string>
+
+<operator> ::= "Add"
+           ||= "Sub"
+           ||= "Mul"
+           ||= "Div"
+           ||= "And"
+           ||= "Or"
+           ||= "Xor"
+
+<comparator> ::= "Eq"
+             ||= "Neq"
+             ||= "Lt"
+             ||= "Gt"
+             ||= "Le"
+             ||= "Ge"
+
+<operand__> ::= <field>
+
+<operands__> ::= <operand__>+
+
+<operand_> ::= <operand__>
+           ||= <value>
+
+<operands_> ::= <operand_>+
+
+<operand_mask_> ::= "(" <operand_> <mask> ")"
+
+<operands_masks_> ::= <operand_mask_>+
+
+<operand> ::= <operand_>
+          ||= <location> "::"[lL]
+
+<location> ::= <operand_>
+
+<table_id> ::= <identifier>
+
+<match_type> ::= "Binary"
+             ||= "Ternary"
+
+<match_field> ::= "(" <field> <size> <match_type> ")"
+
+<simple_field> ::= "(" <field> <size> ")"
+
+<table_fields> ::= (<match_field>+
+               ||= <simple_field>+)
+
+<table_type> ::= "CAM"
+             ||= "RAM"
+             ||= "HASH"
+
+<table> ::= "(" "[" <table_fields> "]" <size> <table_type> ")"
+
+<table_decl> ::= <table_id> "=" <table>
+
+<table_decls> ::= <table_decl>*
+
+<decls> ::= ".decls" "(" <table_decls> ")"
+
+<instruction> ::= "ID"
+              ||= "DRP" <reason>?
+              ||= "CTR" <reason>?
+              ||= "ADD" <operand__> <size>
+              ||= "RMV" <operand__>
+              ||= "LD" <operand__> <operand>
+              ||= "ST" <location> <operand_>
+              ||= "OP" <operand__> <operand_> <operator> <operand_>
+              ||= "PUSH" <location> <operand_>
+              ||= "POP" <operand__> <location>
+              ||= "BR" <operand_> <comparator> <operand_> <label>
+              ||= "JMP" <label>
+              ||= "LBL" <label>
+              ||= "LDt" "[" <operands__> "]" <table_id> <operand_>
+              ||= "STt" <table_id> <operand_> "[" (<operands_> | <operands_masks_>) "]"
+              ||= "INCt" <table_id> <operand_>
+              ||= "LKt" <operand__> <table_id> "[" <operands_> "]"
+              ||= "CRC" <operand__> "[" <operands_> "]"
+              ||= "HSH" <operand__> "[" <operands_> "]"
+              ||= "HLT"
+              ||= "CNC" "(" <codes> ")"
+              ||= "ATM" "(" <code> ")"
+              ||= "SEQ" "(" <code> ")"
+
+<instructions> ::= <instruction>+
+
+<code_fields> ::= ".fields" "(" <fields> ")"
+
+<code_instructions> ::= ".instructions" "(" <instructions> ")"
+
+<code> ::= ".code" "(" <code_fields>? <code_instructions> ")"
+
+<codes> ::= <code>+
+
+<policy> :: <decls>? <code>
diff --git a/netasm/front_ends/netasm_dsl/parser.py b/netasm/front_ends/netasm_dsl/parser.py
new file mode 100644
index 0000000..9712f00
--- /dev/null
+++ b/netasm/front_ends/netasm_dsl/parser.py
@@ -0,0 +1,507 @@
+# ################################################################################
+# ##
+# ##  https://github.com/NetASM/NetASM-python
+# ##
+# ##  File:
+# ##        parser.py
+# ##
+# ##  Project:
+# ##        NetASM: A Network Assembly Language for Programmable Dataplanes
+# ##
+# ##  Author:
+# ##        Muhammad Shahbaz
+# ##
+# ##  Copyright notice:
+# ##        Copyright (C) 2014 Princeton University
+# ##      Network Operations and Internet Security Lab
+# ##
+# ##  Licence:
+# ##        This file is a part of the NetASM development base package.
+# ##
+# ##        This file is free code: you can redistribute it and/or modify it under
+# ##        the terms of the GNU Lesser General Public License version 2.1 as
+# ##        published by the Free Software Foundation.
+# ##
+# ##        This package is distributed in the hope that it will be useful, but
+# ##        WITHOUT ANY WARRANTY; without even the implied warranty of
+# ##        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# ##        Lesser General Public License for more details.
+# ##
+# ##        You should have received a copy of the GNU Lesser General Public
+# ##        License along with the NetASM source package.  If not, see
+# ##        http://www.gnu.org/licenses/.
+
+__author__ = 'shahbaz'
+
+from ply import yacc
+from lexer import Lexer
+from netasm.netasm.core import *
+
+
+class Parser:
+    def __init__(self):
+        self.lexer = Lexer()
+        self.lexer.build()
+
+        self.tokens = self.lexer.tokens
+
+        self.parser = yacc.yacc(module=self, start='policy',
+                                write_tables=0, debug=False)
+
+        self.errors_cnt = 0
+
+    def parse(self, input):
+        self.lexer.reset_lineno()
+        policy = self.parser.parse(input=input,
+                                   lexer=self.lexer)
+        return policy, self.errors_cnt
+
+    def print_error(self, lineno, msg):
+        self.errors_cnt += 1
+        print "parse error at line", lineno, ":", msg
+
+    def p_empty(self, p):
+        ''' empty :
+        '''
+        pass
+
+    def get_value(self, x):
+        if "'d" in x.lower():
+            return int(x[2:], 10)
+        elif "'h" in x.lower():
+            return int(x[2:], 16)
+
+    def p_value_number(self, p):
+        ''' value_number : DEC
+                         | HEX
+        '''
+        p[0] = p[1]
+
+    def p_value(self, p):  # TODO: remove the Size class, it's actually Value class
+        ''' value : NUM value_number
+        '''
+        p[0] = Value(self.get_value(p[2]), Size(int(p[1])))
+
+    def p_size(self, p):
+        ''' size : value
+        '''
+        p[0] = Size(p[1].value)
+
+    def p_field(self, p):
+        ''' field : IDN
+        '''
+        p[0] = Field(p[1])
+
+    def p_fields(self, p):
+        ''' fields : empty
+                   | field
+                   | fields field
+        '''
+        if len(p) == 2:
+            if not p[1]:
+                p[0] = Fields()
+            else:
+                p[0] = Fields(p[1])
+        else:
+            p[1].append(p[2])
+            p[0] = p[1]
+
+    def p_mask(self, p):
+        ''' mask : value
+        '''
+        p[0] = Mask(p[1].value)
+
+    def p_label(self, p):
+        ''' label : STR
+        '''
+        p[0] = Label(p[1])
+
+    def p_reason(self, p):
+        ''' reason : STR STR
+        '''
+        p[0] = Reason(p[1], p[2])
+
+    def p_operator(self, p):
+        ''' operator : Add
+                     | Sub
+                     | Mul
+                     | Div
+                     | And
+                     | Or
+                     | Xor
+        '''
+        if p[1] == 'Add':
+            p[0] = OperatorCollection.Add
+        elif p[1] == 'Sub':
+            p[0] = OperatorCollection.Sub
+        elif p[1] == 'Mul':
+            p[0] = OperatorCollection.Mul
+        elif p[1] == 'Div':
+            p[0] = OperatorCollection.Div
+        elif p[1] == 'And':
+            p[0] = OperatorCollection.And
+        elif p[1] == 'Or':
+            p[0] = OperatorCollection.Or
+        elif p[1] == 'Xor':
+            p[0] = OperatorCollection.Xor
+
+    def p_comparator(self, p):
+        ''' comparator : Eq
+                       | Neq
+                       | Lt
+                       | Gt
+                       | Le
+                       | Ge
+        '''
+        if p[1] == 'Eq':
+            p[0] = OperatorCollection.Eq
+        elif p[1] == 'Neq':
+            p[0] = OperatorCollection.Neq
+        elif p[1] == 'Lt':
+            p[0] = OperatorCollection.Lt
+        elif p[1] == 'Gt':
+            p[0] = OperatorCollection.Gt
+        elif p[1] == 'Le':
+            p[0] = OperatorCollection.Le
+        elif p[1] == 'Ge':
+            p[0] = OperatorCollection.Ge
+
+    def p_operand__(self, p):
+        ''' operand__ : field
+        '''
+        p[0] = OperandCollection.Field(p[1])
+
+    def p_operands__(self, p):
+        ''' operands__ : operand__
+                       | operands__ operand__
+        '''
+        if len(p) == 2:
+            if p[1]:
+                p[0] = OperandCollection.Operands__(p[1])
+        else:
+            p[1].append(p[2])
+            p[0] = p[1]
+
+    def p_operand_(self, p):
+        ''' operand_ : operand__
+                     | value
+        '''
+        if isinstance(p[1], Value):
+            p[0] = OperandCollection.Value(p[1])
+        else:
+            p[0] = p[1]
+
+    def p_operands_(self, p):
+        ''' operands_ : operand_
+                      | operands_ operand_
+        '''
+        if len(p) == 2:
+            if p[1]:
+                p[0] = OperandCollection.Operands_(p[1])
+        else:
+            p[1].append(p[2])
+            p[0] = p[1]
+
+    def p_operand_mask_(self, p):
+        ''' operand_mask_ : LPAREN operand_ mask RPAREN
+        '''
+        p[0] = (p[2], p[3])
+
+    def p_operands_masks_(self, p):
+        ''' operands_masks_ : operand_mask_
+                            | operands_masks_ operand_mask_
+        '''
+        if len(p) == 2:
+            if p[1]:
+                p[0] = OperandCollection.OperandsMasks_(p[1])
+        else:
+            p[1].append(p[2])
+            p[0] = p[1]
+
+    def p_operand(self, p):
+        ''' operand : operand_
+                    | location
+        '''
+        if isinstance(p[1], Location):
+            p[0] = OperandCollection.Location(p[1])
+        else:
+            p[0] = p[1]
+
+    def p_location(self, p):
+        ''' location : operand_ LOC
+        '''
+        p[0] = Location(p[1])
+
+    def p_table_id(self, p):
+        ''' table_id : IDN
+        '''
+        p[0] = TableId(p[1])
+
+    def p_match_type(self, p):
+        ''' match_type : Binary
+                       | Ternary
+        '''
+        if p[1] == 'Binary':
+            p[0] = MatchTypeCollection.Binary
+        elif p[1] == 'Ternary':
+            p[0] = MatchTypeCollection.Ternary
+
+    def p_match_field(self, p):
+        ''' match_field : LPAREN field size match_type RPAREN
+        '''
+        p[0] = p[2], (p[3], p[4])
+
+    def p_match_fields(self, p):
+        ''' match_fields : match_field
+                         | match_fields match_field
+        '''
+        if len(p) == 2:
+            if p[1]:
+                field, (size, match_type) = p[1]
+
+                p[0] = TableFieldsCollection.MatchFields()
+                p[0][field] = (size, match_type)
+        else:
+            field, (size, match_type) = p[2]
+
+            p[1][field] = (size, match_type)
+            p[0] = p[1]
+
+    def p_simple_field(self, p):
+        ''' simple_field : LPAREN field size RPAREN
+        '''
+        p[0] = p[2], p[3]
+
+    def p_simple_fields(self, p):
+        ''' simple_fields : simple_field
+                          | simple_fields simple_field
+        '''
+        if len(p) == 2:
+            if p[1]:
+                field, size = p[1]
+
+                p[0] = TableFieldsCollection.SimpleFields()
+                p[0][field] = size
+        else:
+            field, size = p[2]
+
+            p[1][field] = size
+            p[0] = p[1]
+
+    def p_table_fields(self, p):
+        ''' table_fields : match_fields
+                         | simple_fields
+        '''
+        p[0] = p[1]
+
+    def p_table_type(self, p):
+        ''' table_type : CAM
+                       | RAM
+                       | HASH
+        '''
+        if p[1] == 'CAM':
+            p[0] = TableTypeCollection.CAM
+        elif p[1] == 'RAM':
+            p[0] = TableTypeCollection.RAM
+        elif p[1] == 'HASH':
+            p[0] = TableTypeCollection.HSH
+
+    def p_table(self, p):
+        ''' table : LPAREN LBRACKET table_fields RBRACKET size table_type RPAREN
+        '''
+        p[0] = Table(p[3], p[5], p[6])
+
+    def p_table_decl(self, p):
+        ''' table_decl : table_id EQUAL table
+        '''
+        p[0] = p[1], p[3]
+
+    def p_table_decls(self, p):
+        ''' table_decls : empty
+                        | table_decl
+                        | table_decls table_decl
+        '''
+        if len(p) == 2:
+            if not p[1]:
+                p[0] = TableDecls()
+            else:
+                table_id, table = p[1]
+
+                p[0] = TableDecls()
+                p[0][table_id] = table
+        else:
+            table_id, table = p[2]
+
+            p[1][table_id] = table
+            p[0] = p[1]
+
+    def p_decls(self, p):
+        ''' decls : S_DECLS LPAREN table_decls RPAREN
+        '''
+        p[0] = Decls(p[3])
+
+    def p_instruction(self, p):
+        ''' instruction : ID
+                        | DRP
+                        | DRP reason
+                        | CTR
+                        | CTR reason
+                        | ADD operand__ size
+                        | RMV operand__
+                        | LD operand__ operand
+                        | ST location operand_
+                        | OP operand__ operand_ operator operand_
+                        | PUSH location operand_
+                        | POP operand__ location
+                        | BR operand_ comparator operand_ label
+                        | JMP label
+                        | LBL label
+                        | LDt LBRACKET operands__ RBRACKET table_id operand_
+                        | STt table_id operand_ LBRACKET operands_ RBRACKET
+                        | STt table_id operand_ LBRACKET operands_masks_ RBRACKET
+                        | INCt table_id operand_
+                        | LKt operand__ table_id LBRACKET operands_ RBRACKET
+                        | CRC operand__ LBRACKET operands_ RBRACKET
+                        | HSH operand__ LBRACKET operands_ RBRACKET
+                        | HLT
+                        | CNC LPAREN codes RPAREN
+                        | ATM LPAREN code RPAREN
+                        | SEQ LPAREN code RPAREN
+        '''
+        if p[1] == 'ID':
+            p[0] = InstructionCollection.ID()
+        elif p[1] == 'DRP':
+            if len(p) == 2:
+                p[0] = InstructionCollection.DRP()
+            else:
+                p[0] = InstructionCollection.DRP(p[2])
+        elif p[1] == 'CTR':
+            if len(p) == 2:
+                p[0] = InstructionCollection.DRP()
+            else:
+                p[0] = InstructionCollection.DRP(p[2])
+        elif p[1] == 'ADD':
+            p[0] = InstructionCollection.ADD(p[2], p[3])
+        elif p[1] == 'RMV':
+            p[0] = InstructionCollection.RMV(p[2])
+        elif p[1] == 'LD':
+            p[0] = InstructionCollection.LD(p[2], p[3])
+        elif p[1] == 'ST':
+            p[0] = InstructionCollection.ST(OperandCollection.Location(p[2]), p[3])
+        elif p[1] == 'OP':
+            p[0] = InstructionCollection.OP(p[2], p[3], p[4], p[5])
+        elif p[1] == 'PUSH':
+            p[0] = InstructionCollection.PUSH(p[2], p[3])
+        elif p[1] == 'POP':
+            p[0] = InstructionCollection.POP(p[2], p[3])
+        elif p[1] == 'BR':
+            p[0] = InstructionCollection.BR(p[2], p[3], p[4], p[5])
+        elif p[1] == 'JMP':
+            p[0] = InstructionCollection.JMP(p[2])
+        elif p[1] == 'LBL':
+            p[0] = InstructionCollection.LBL(p[2])
+        elif p[1] == 'LDt':
+            p[0] = InstructionCollection.LDt(p[3], p[5], p[6])
+        elif p[1] == 'STt':
+            p[0] = InstructionCollection.STt(p[2], p[3], p[5])
+        elif p[1] == 'INCt':
+            p[0] = InstructionCollection.INCt(p[2], p[3])
+        elif p[1] == 'LKt':
+            p[0] = InstructionCollection.LKt(p[2], p[3], p[5])
+        elif p[1] == 'CRC':
+            p[0] = InstructionCollection.CRC(p[2], p[4])
+        elif p[1] == 'HSH':
+            p[0] = InstructionCollection.HSH(p[2], p[4])
+        elif p[1] == 'HLT':
+            p[0] = InstructionCollection.HLT()
+        elif p[1] == 'CNC':
+            p[0] = InstructionCollection.CNC(p[3])
+        elif p[1] == 'ATM':
+            p[0] = InstructionCollection.ATM(p[3])
+        elif p[1] == 'SEQ':
+            p[0] = InstructionCollection.SEQ(p[3])
+        else:
+            # raise TypeError()
+            pass
+
+    def p_instructions(self, p):
+        ''' instructions : instruction
+                         | instructions instruction
+        '''
+        if len(p) == 2:
+            if p[1]:
+                p[0] = InstructionCollection.Instructions(p[1])
+        else:
+            p[1].append(p[2])
+            p[0] = p[1]
+
+    def p_code_fields(self, p):
+        ''' code_fields : S_FIELDS LPAREN fields RPAREN
+        '''
+        p[0] = p[3]
+
+    def p_code_instructions(self, p):
+        ''' code_instructions : S_INSTRS LPAREN instructions RPAREN
+        '''
+        p[0] = p[3]
+
+    def p_code(self, p):
+        ''' code : S_CODE LPAREN code_fields code_instructions RPAREN
+                 | S_CODE LPAREN code_instructions RPAREN
+        '''
+        if len(p) == 6:
+            p[0] = InstructionCollection.Code(p[3], p[4])
+        else:
+            p[0] = InstructionCollection.Code(Fields(), p[3])
+
+    def p_codes(self, p):
+        ''' codes : code
+                  | codes code
+        '''
+        if len(p) == 2:
+            if p[1]:
+                p[0] = InstructionCollection.Codes(p[1])
+        else:
+            p[1].append(p[2])
+            p[0] = p[1]
+
+    def p_policy(self, p):
+        ''' policy : decls code
+                   | code
+        '''
+        if len(p) == 3:
+            p[0] = Policy(p[1], p[2])
+        else:
+            p[0] = Policy(Decls(), p[1])
+
+    def p_error(self, p):
+        if p is None:
+            self.print_error(self.lexer.get_lineno(),
+                             "Unexpected end-of-file (missing brace?)")
+        else:
+            self.print_error(
+                p.lineno,
+                "Syntax error while parsing at token %s (%s)" % (p.value, p.type)
+            )
+
+
+if __name__ == '__main__':
+    parser = Parser()
+    policy, errors_cnt = parser.parse('''
+.code (
+    .fields ()
+    .instrs (
+        ADD reg0 8'H16
+        LD reg0 16'd4::l
+        LBL "LBL_0"
+        BR reg0 Eq 16'd0 "LBL_HLT"
+        OP reg0 reg0 Sub 10'd-11
+        JMP "LBL_0"
+        LBL "LBL_HLT"
+        LD outport_bitmap reg0
+        HLT
+    )
+)
+    ''')
+
+    print policy, errors_cnt
diff --git a/netasm/front_ends/netasm_dsl/test.netasm b/netasm/front_ends/netasm_dsl/test.netasm
new file mode 100644
index 0000000..23a0398
--- /dev/null
+++ b/netasm/front_ends/netasm_dsl/test.netasm
@@ -0,0 +1,42 @@
+
+# Declarations
+.decls (
+    acl_match_table =
+        ([(ipv4_src 5'd32 Binary)
+         (ipv4_dst 5'd32 Binary)] 16'd2048 CAM)
+)
+
+# Code
+.code (
+    .fields (
+        outport
+        inport
+        bit_length
+    )
+    .instrs (
+        ADD eth_dst 16'd48
+        ADD eth_src 16'd48
+        ADD eth_type 16'd16
+
+        LD eth_dst 16'h0
+        LD eth_src 16'd48
+        LD eth_type 16'd96
+
+        BR eth_type Eq 16'h0800 "LBL_PARSE_0"
+
+        CTR "PARSER" "UNHANDLED_IP_PAYLOAD"
+
+        CNC (
+            .code (
+                .fields ()
+                .instrs (
+                    LD eth_type 96
+                    HLT))
+            .code (
+                .fields ()
+                .instrs (
+                    HLT)))
+
+        HLT
+    )
+)
\ No newline at end of file
diff --git a/netasm/netasm/core/syntax.py b/netasm/netasm/core/syntax.py
index 0afc217..ec37f30 100644
--- a/netasm/netasm/core/syntax.py
+++ b/netasm/netasm/core/syntax.py
@@ -557,7 +557,7 @@ def __repr__(self):
 
 
 class Decls:
-    def __init__(self, table_decls):
+    def __init__(self, table_decls=TableDecls()):
         if isinstance(table_decls, TableDecls):
             self.table_decls = table_decls
         else:
diff --git a/setup/basic.sh b/setup/basic.sh
index fbd93a3..c3dd05b 100755
--- a/setup/basic.sh
+++ b/setup/basic.sh
@@ -40,7 +40,7 @@ sudo apt-get update
 sudo apt-get install -y ssh git
  
 sudo apt-get install -y build-essential autoconf automake graphviz libtool vim
-sudo apt-get install -y python-all python-qt4 python-dev python-twisted-conch python-pip python-sphinx
+sudo apt-get install -y python-all python-qt4 python-dev python-twisted-conch python-pip python-sphinx python-ply
 sudo apt-get install -y libpcap-dev
 
 sudo pip install alabaster psutil bitstring