handling do-while, started work on list comprehensions, fixed some bugs

Author: mbdevpl

open_fortran_parser/ast_transformer.py

@@ -282,8 +282,8 @@ def _declaration_include(self, node: ET.Element):
     def _loop(self, node: ET.Element):
         if node.attrib['type'] == 'do':
             return self._loop_do(node)
-        #elif node.attrib['type'] == 'do-while':
-        #    return self._loop_do_while(node)
+        elif node.attrib['type'] == 'do-while':
+            return self._loop_do_while(node)
         elif node.attrib['type'] == 'forall':
             return self._loop_forall(node)
         else:
@@ -297,7 +297,12 @@ def _loop_do(self, node: ET.Element) -> typed_ast3.For:
         return typed_ast3.For(target=target, iter=iter_, body=body, orelse=[])
 
     def _loop_do_while(self, node: ET.Element) -> typed_ast3.While:
-        pass
+        header_node = node.find('./header')
+        header = self.transform_all_subnodes(header_node, warn=False)
+        assert len(header) == 1
+        condition = header[0]
+        body = self.transform_all_subnodes(node.find('./body'), ignored={'block'})
+        return typed_ast3.While(test=condition, body=body, orelse=[])
 
     def _loop_forall(self, node: ET.Element) -> typed_ast3.For:
         index_variables = node.find('./header/index-variables')
@@ -508,7 +513,7 @@ def _operation_multiary(
         operators_and_operands = self.transform_all_subnodes(
             node, skip_empty=True, ignored={
                 'add-operand__add-op', 'add-operand', 'mult-operand__mult-op', 'mult-operand',
-                'primary'})
+                'primary', 'level-3-expr'})
         assert isinstance(operators_and_operands, list), operators_and_operands
         assert len(operators_and_operands) % 2 == 1, operators_and_operands
 
@@ -653,42 +658,76 @@ def _operator(
             }[node.attrib['operator'].lower()]
 
     def _array_constructor(self, node: ET.Element) -> typed_ast3.ListComp:
-        values = node.findall('./value')
-        if len(values) != 2:
-            raise NotImplementedError('not implemented handling of:\n{}'.format(ET.tostring(node).decode().rstrip()))
-        value = values[0]
-        sub_values = value.find('./array-constructor-values')
-        header_node = value.find('./header')
-        header = self.transform_all_subnodes(header_node, warn=False)
+        value_nodes = node.findall('./value')
+        values = []
+        for value_node in value_nodes:
+            value = self.transform_all_subnodes(value_node, warn=False)
+            if not value:
+                continue
+            assert len(value) == 1
+            values.append(value[0])
+
+        if len(values) != 1:
+            raise NotImplementedError(
+                'not implemented handling of {} in:\n{}'
+                .format(values, ET.tostring(node).decode().rstrip()))
+
+        header_node = node.find('./header')
+        header = self.transform_all_subnodes(header_node, warn=False, ignored={'ac-implied-do-control'})
         assert len(header) == 1
         comp_target, comp_iter = header[0]
         return typed_ast3.ListComp(
-            elt=typed_ast3.Call(
-                func=typed_ast3.Name(id='do_nothing', ctx=typed_ast3.Load()),
-                args=[], keywords=[], starargs=None, kwargs=None),
+            elt=values[0],
             generators=[
                 typed_ast3.comprehension(target=comp_target, iter=comp_iter, ifs=[], is_async=0)])
 
-        # "[ord(c) for line in file for c in line]"
-        #_(elt=Call(func=Name(id='ord', ctx=Load()), args=[
-        #  Name(id='c', ctx=Load()),
-        #], keywords=[], starargs=None, kwargs=None), generators=[
-        #  comprehension(target=Name(id='line', ctx=Store()), iter=Name(id='file', ctx=Load()), ifs=[], is_async=0),
-        #  comprehension(target=Name(id='c', ctx=Store()), iter=Name(id='line', ctx=Load()), ifs=[], is_async=0),
-        #])
+    def _array_constructor_values(self, node: ET.Element) -> typed_ast3.List:
+        value_nodes = node.findall('./value')
+        values = []
+        for value_node in value_nodes:
+            value = self.transform_all_subnodes(value_node, warn=False)
+            if not value:
+                continue
+            assert len(value) == 1
+            values.append(value[0])
+
+        return typed_ast3.List(elts=values, ctx=typed_ast3.Load())
 
-    def _dimension(self, node: ET.Element) -> t.Union[typed_ast3.Num, typed_ast3.Index]:
+    def _dimension(self, node: ET.Element) -> t.Union[typed_ast3.Index, typed_ast3.Slice]:
         dim_type = node.attrib['type']
         if dim_type == 'simple':
             values = self.transform_all_subnodes(node, ignored={'array-spec-element'})
             if len(values) != 1:
                 _LOG.error('simple dimension should have exactly one value, but it has %i', len(values))
             return typed_ast3.Index(value=values[0])
+        elif dim_type == 'range':
+            lower_bound = node.find('./lower-bound')
+            upper_bound = node.find('./upper-bound')
+            step = node.find('./step')
+            #range_args = []
+            if lower_bound is not None:
+                args = self.transform_all_subnodes(lower_bound)
+                assert len(args) == 1, args
+                #range_args.append(args[0])
+                lower_bound = args[0]
+            if upper_bound is not None:
+                args = self.transform_all_subnodes(upper_bound)
+                assert len(args) == 1, args
+                #range_args.append(typed_ast3.BinOp(
+                #    left=args[0], op=typed_ast3.Add(), right=typed_ast3.Num(n=1)))
+                upper_bound = args[0]
+            if step is not None:
+                args = self.transform_all_subnodes(step)
+                assert len(args) == 1, args
+                #range_args.append(args[0])
+                step = args[0]
+            return typed_ast3.Slice(lower=lower_bound, upper=upper_bound, step=step)
         elif dim_type == 'assumed-shape':
             return typed_ast3.Slice(lower=None, upper=None, step=None)
         else:
-            _LOG.warning('%s', ET.tostring(node).decode().rstrip())
-            raise NotImplementedError('dimension type "{}" not supported'.format(dim_type))
+            raise NotImplementedError(
+                'dimension type "{}" not supported in:\n{}'
+                .format(dim_type, ET.tostring(node).decode().rstrip()))
 
     _basic_types = {
         ('logical', None): 'bool',

src/fortran/ofp/XMLPrinter.java

@@ -534,7 +534,6 @@ public void array_constructor() {
 		context = contextNode(-1); // temporarily reopen previously-closed context
 		if (verbosity >= 100)
 			super.array_constructor();
-		contextRename("array-constructor-values", "array-constructor");
 		contextClose(); // re-close previously closed context
 	}
 
@@ -561,11 +560,30 @@ public void ac_value_list__begin() {
 
 	public void ac_value_list(int count) {
 		contextClose("value");
-		contextCloseAllInner("array-constructor-values");
+		contextCloseAllInner("array-constructor-values", "array-constructor");
 		setAttribute("count", count);
 		if (verbosity >= 100)
 			super.ac_value_list(count);
-		contextClose("array-constructor-values");
+		contextClose("array-constructor-values", "array-constructor");
+	}
+
+	public void ac_implied_do() {
+		Element value = context;
+		contextClose();
+		Element innerContext = context;
+		contextClose("value");
+		innerContext.removeChild(value);
+		context.appendChild(value);
+		super.ac_implied_do();
+		contextRename("array-constructor-values", "array-constructor");
+		contextOpen("value");
+		// System.err.println("well...");
+		// cleanUpAfterError();
+	}
+
+	public void ac_implied_do_control(boolean hasStride) {
+		contextClose("index-variable");
+		super.ac_implied_do_control(hasStride);
 	}
 
 	public void type_declaration_stmt(Token label, int numAttributes, Token eos) {
@@ -1395,8 +1413,16 @@ public void and_operand__not_op(boolean hasNotOp) {
 	}
 
 	public void or_operand(int numOrOps) {
-		if (numOrOps > 0)
+		if (numOrOps > 0) {
+			if (!context.getTagName().equals("operand")) {
+				Element previousContext = contextNode(-1);
+				Element outerContext = context;
+				contextOpen("operand");
+				outerContext.removeChild(previousContext);
+				context.appendChild(previousContext);
+			}
 			contextClose("operand");
+		}
 		if (verbosity >= 100)
 			super.or_operand(numOrOps);
 		if (numOrOps > 0)
@@ -1737,8 +1763,9 @@ public void block_do_construct() {
 	}
 
 	public void do_stmt(Token label, Token id, Token doKeyword, Token digitString, Token eos, boolean hasLoopControl) {
-		if (context.getTagName() != "header") {
-			contextOpen("loop");
+		if (!context.getTagName().equals("header")) {
+			if (!context.getTagName().equals("loop"))
+				contextOpen("loop");
 			contextOpen("header");
 		}
 		contextClose("header");
@@ -1761,11 +1788,8 @@ public void label_do_stmt(Token label, Token id, Token doKeyword, Token digitStr
 	public void loop_control(Token whileKeyword, int doConstructType, boolean hasOptExpr) {
 		if (!context.getTagName().equals("statement"))
 			contextClose("index-variable");
-		else {
+		else
 			contextRename("statement", "loop");
-			// setAttribute("type", "do");
-		}
-		super.loop_control(whileKeyword, doConstructType, hasOptExpr);
 		String loopType = "";
 		switch (doConstructType) {
 		case 1700:
@@ -1775,11 +1799,18 @@ public void loop_control(Token whileKeyword, int doConstructType, boolean hasOpt
 			loopType = "do";
 			break;
 		case 1702:
+			Element outerContext = context;
+			Element node = contextNode(-1);
+			contextOpen("header");
+			outerContext.removeChild(node);
+			context.appendChild(node);
+			contextClose("header");
 			loopType = "do-while";
 			break;
 		default:
 			throw new IllegalArgumentException(Integer.toString(doConstructType));
 		}
+		super.loop_control(whileKeyword, doConstructType, hasOptExpr);
 		setAttribute("type", loopType, "loop");
 	}
 

test/examples/empty.f

@@ -0,0 +1,6 @@
+
+      program empty
+
+      implicit none
+
+      end program empty

test/test_ofc.py

@@ -10,7 +10,7 @@
 
 _HERE = pathlib.Path(__file__).resolve().parent
 
-INPUT_PATHS = list(_HERE.joinpath('examples').glob('**/*.*'))
+INPUT_PATHS = [_HERE.joinpath('examples', _) for _ in ['empty.f']]
 OUTPUT_PATHS = [None] # [pathlib.Path('/tmp/out.f'), None]
 INDENTS = (4,) # (0, 4, 8)
 FORMS = (None,) # (CodeForm.Fixed, CodeForm.Free, None)