From be7377d9e183935c6684c30df9d559ba6b6442a5 Mon Sep 17 00:00:00 2001 From: Ivan Akulinchev Date: Thu, 26 Sep 2024 12:24:42 +0200 Subject: [PATCH] Escape HTML in the messages and code snippets (#19) * Escape HTML in the messages and code snippets * Add a 20.10 report to increase test coverage --- .../com/absint/astree/AstreeReportParser.java | 20 +- .../astree/AstreeSimpleReportParser.java | 26 +- .../absint/astree/AstreeReportParserTest.java | 115 +- .../com/absint/astree/report-20.10.xml | 2097 +++++++++++++++++ 4 files changed, 2233 insertions(+), 25 deletions(-) create mode 100644 src/test/resources/com/absint/astree/report-20.10.xml diff --git a/src/main/java/com/absint/astree/AstreeReportParser.java b/src/main/java/com/absint/astree/AstreeReportParser.java index 1f03334..9240c55 100644 --- a/src/main/java/com/absint/astree/AstreeReportParser.java +++ b/src/main/java/com/absint/astree/AstreeReportParser.java @@ -70,16 +70,20 @@ public Report parse(final ReaderFactory readerFactory) throws ParsingException { String locationID = message.getLocationID(); // build description out of code snippet - String description = ""; - String code = parser.getCodeSnippets().get(locationID); - if (null != code && !code.isEmpty()) { - description += "

Code:
" + code.replaceAll(" ", " ") + "

"; + final StringBuilder description = new StringBuilder(); + final String code = parser.getCodeSnippet(locationID); + if (code != null && !code.isEmpty()) { + description.append("

Code:

");
+                description.append(code);
+                description.append("
"); } // build description out of context - String context = message.getContext(); - if (null != context && !context.isEmpty()) { - description += "

Context:
" + context.replaceAll(" ", " ") + "

"; + final String context = message.getContext(); + if (context != null && !context.isEmpty()) { + description.append("

Context:

");
+                description.append(context);
+                description.append("
"); } // build category out of message type and category @@ -126,7 +130,7 @@ public Report parse(final ReaderFactory readerFactory) throws ParsingException { .setColumnStart(location.getColStart()) .setColumnEnd(location.getColEnd()) .setCategory(categoryBuilder.toString()) - .setDescription(description) + .setDescription(description.toString()) .setSeverity(severity); // add issue to report diff --git a/src/main/java/com/absint/astree/AstreeSimpleReportParser.java b/src/main/java/com/absint/astree/AstreeSimpleReportParser.java index eb14fb3..0e9ae79 100644 --- a/src/main/java/com/absint/astree/AstreeSimpleReportParser.java +++ b/src/main/java/com/absint/astree/AstreeSimpleReportParser.java @@ -1,19 +1,17 @@ package com.absint.astree; +import org.apache.commons.text.StringEscapeUtils; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.NodeList; import edu.hm.hafner.analysis.ParsingException; -import org.w3c.dom.Node; - import java.util.Map; import java.util.HashMap; import java.util.List; import java.util.ArrayList; - /** * Parser which simply parses Astree XML reports into data structures whithout * interconnecting the elements @@ -109,12 +107,12 @@ public String getFile(String id) { } /** - * get parsed code snippets + * get parsed code snippet * - * @return parsed files + * @return parsed code snippet */ - public Map getCodeSnippets() { - return m_codeSnippets; + public String getCodeSnippet(String locationId) { + return m_codeSnippets.get(locationId); } /** @@ -146,7 +144,7 @@ private void parseMessages(Document doc, Message.MessageType type) { for (int i = 0; i < messages.getLength(); i++) { Element messageElement = (Element)messages.item(i); Message message = new Message(); - + // message text NodeList lines = messageElement.getElementsByTagName("textline"); StringBuilder messageText = new StringBuilder(); @@ -155,9 +153,9 @@ private void parseMessages(Document doc, Message.MessageType type) { if (0 < messageText.length()) { messageText.append("
"); } - messageText.append(line.getTextContent()); + messageText.append(StringEscapeUtils.escapeHtml4(line.getTextContent())); } - + message.setLocationID(messageElement.getAttribute("location_id")) .setTypeID(messageElement.getAttribute("type")) .setType(type) @@ -179,9 +177,9 @@ private void parseFindings(Document doc) { final Element line = (Element) lines.item(y); if (0 < stringBuilder.length()) stringBuilder.append("
"); - stringBuilder.append(line.getTextContent()); + stringBuilder.append(StringEscapeUtils.escapeHtml4(line.getTextContent())); } - + message.setLocationID(element.getAttribute("location_id")) .setTypeID(element.getAttribute("key")) .setContext(element.getAttribute("context")) @@ -262,9 +260,9 @@ private void parseCodeSnippets(Document doc) { for (int y = 0; y < lines.getLength(); y++) { Element line = (Element)lines.item(y); if (0 < code.length()) { - code.append("
"); + code.append("\n"); } - code.append(line.getTextContent()); + code.append(StringEscapeUtils.escapeHtml4(line.getTextContent())); } m_codeSnippets.put(snippet.getAttribute("location_id"), code.toString()); diff --git a/src/test/java/com/absint/astree/AstreeReportParserTest.java b/src/test/java/com/absint/astree/AstreeReportParserTest.java index 1548ef1..c098dd0 100644 --- a/src/test/java/com/absint/astree/AstreeReportParserTest.java +++ b/src/test/java/com/absint/astree/AstreeReportParserTest.java @@ -66,7 +66,7 @@ private void testReport(Report report) { assertTrue(fileName, categories.contains("Integer division by zero [Division or modulo by zero]")); assertTrue(fileName, categories.contains("Use of uninitialized variables [Uninitialized variables]")); assertTrue(fileName, categories.contains("Overflow in conversion (with unpredictable result) [Invalid ranges and overflows]")); - if (fileName.compareTo("report-20.04.xml") <= 0) { + if (fileName.compareTo("report-20.10.xml") <= 0) { assertTrue(fileName, categories.contains("Definite runtime error [Errors]")); } else { assertTrue(fileName, categories.contains("Analysis stopped [Errors]")); @@ -113,6 +113,13 @@ private void testReport(Report report) { assertEquals(fileName, 23, alarm1.getColumnStart()); assertEquals(fileName, 20, alarm1.getLineEnd()); assertEquals(fileName, 26, alarm1.getColumnEnd()); + assertEquals(fileName, "ALARM (R): check parameter-name failed (violates M2012.8.2-required)", alarm1.getMessage()); + if (fileName.equals("report-18.04.xml")) { + assertEquals(fileName, "n/a", alarm1.getReference()); + } else { + assertEquals(fileName, "n/A", alarm1.getReference()); + } + assertEquals(fileName, "", alarm1.getDescription()); final Issue alarm2 = report.get(33); assertEquals(fileName, Severity.WARNING_HIGH, alarm2.getSeverity()); @@ -126,6 +133,13 @@ private void testReport(Report report) { assertEquals(fileName, 4, alarm2.getColumnStart()); assertEquals(fileName, 134, alarm2.getLineEnd()); assertEquals(fileName, 13, alarm2.getColumnEnd()); + assertEquals(fileName, "ALARM (R): check unreachable-code failed (violates M2012.2.1-required)", alarm2.getMessage()); + if (fileName.equals("report-18.04.xml")) { + assertEquals(fileName, "n/a", alarm2.getReference()); + } else { + assertEquals(fileName, "n/A", alarm2.getReference()); + } + assertEquals(fileName, "", alarm2.getDescription()); final Issue error1 = report.get(34); assertEquals(fileName, Severity.ERROR, error1.getSeverity()); @@ -135,6 +149,13 @@ private void testReport(Report report) { assertEquals(fileName, 8, error1.getColumnStart()); assertEquals(fileName, 73, error1.getLineEnd()); assertEquals(fileName, 25, error1.getColumnEnd()); + assertEquals(fileName, "ERROR: Definite runtime error during assignment in this context. Analysis stopped for this context.", error1.getMessage()); + if (fileName.equals("report-18.04.xml")) { + assertEquals(fileName, "n/a", error1.getReference()); + } else { + assertEquals(fileName, "n/A", error1.getReference()); + } + assertEquals(fileName, "

Context:

l32#call#main@48,l34#loop@72=11/12
", error1.getDescription()); final Issue error2 = report.get(35); assertEquals(fileName, Severity.ERROR, error2.getSeverity()); @@ -144,6 +165,13 @@ private void testReport(Report report) { assertEquals(fileName, 8, error2.getColumnStart()); assertEquals(fileName, 78, error2.getLineEnd()); assertEquals(fileName, 16, error2.getColumnEnd()); + assertEquals(fileName, "ERROR: Definite runtime error during assignment in this context. Analysis stopped for this context.", error2.getMessage()); + if (fileName.equals("report-18.04.xml")) { + assertEquals(fileName, "n/a", error2.getReference()); + } else { + assertEquals(fileName, "n/A", error2.getReference()); + } + assertEquals(fileName, "

Context:

l32#call#main@48,l37#loop@77=11/12
", error2.getDescription()); final Issue note1 = report.get(36); assertEquals(fileName, Severity.WARNING_LOW, note1.getSeverity()); @@ -153,6 +181,13 @@ private void testReport(Report report) { assertEquals(fileName, 1, note1.getColumnStart()); assertEquals(fileName, 135, note1.getLineEnd()); assertEquals(fileName, 1, note1.getColumnEnd()); + assertEquals(fileName, "NOTE: Analyzed entry-point main never returns.", note1.getMessage()); + if (fileName.equals("report-18.04.xml")) { + assertEquals(fileName, "n/a", note1.getReference()); + } else { + assertEquals(fileName, "n/A", note1.getReference()); + } + assertEquals(fileName, "", note1.getDescription()); final Issue note2 = report.get(37); assertEquals(fileName, Severity.WARNING_LOW, note2.getSeverity()); @@ -162,6 +197,13 @@ private void testReport(Report report) { assertEquals(fileName, 3, note2.getColumnStart()); assertEquals(fileName, 126, note2.getLineEnd()); assertEquals(fileName, 5, note2.getColumnEnd()); + assertEquals(fileName, "NOTE: Loop may be unbounded", note2.getMessage()); + if (fileName.equals("report-18.04.xml")) { + assertEquals(fileName, "n/a", note2.getReference()); + } else { + assertEquals(fileName, "n/A", note2.getReference()); + } + assertEquals(fileName, "", note2.getDescription()); } else if (fileName.compareTo("report-21.04i2.xml") <= 0) { assertEquals(fileName, 125, report.size()); @@ -173,6 +215,21 @@ private void testReport(Report report) { assertEquals(fileName, 44, alarm1.getColumnStart()); assertEquals(fileName, 77, alarm1.getLineEnd()); assertEquals(fileName, 54, alarm1.getColumnEnd()); + if (fileName.compareTo("report-19.10.xml") <= 0) { + assertEquals(fileName, "[ conversion between two incompatible pointer types: from <RecordType*> (aka <struct Record*>) to <char*>
ALARM (R): check incompatible-object-pointer-conversion failed (violates A.1.11)", alarm1.getMessage()); + } else if (fileName.compareTo("report-20.04.xml") <= 0) { + assertEquals(fileName, "conversion between two incompatible pointer types: from <RecordType*> (aka <struct Record*>) to <char*>
ALARM (R): check incompatible-object-pointer-conversion failed (violates A.1.11)", alarm1.getMessage()); + } else if (fileName.compareTo("report-21.04.xml") <= 0) { + assertEquals(fileName, "conversion between two incompatible pointer types: from <RecordType*> (aka <struct Record*>) to <char*>
ALARM (R) check_incompatible_object_pointer_conversion: check failed (violates A.1.11)", alarm1.getMessage()); + } else { + assertEquals(fileName, "conversion between two incompatible pointer types: from <RecordType *> (aka <struct Record *>) to <char *>
ALARM (R) check_incompatible_object_pointer_conversion: check failed (violates A.1.11)", alarm1.getMessage()); + } + assertEquals(fileName, "n/A", alarm1.getReference()); + assertEquals(fileName, + "

Code:

" +
+                "memcpy_x(&((*(PtrParIn->PtrComp))), &(*PtrGlb), sizeof((*(PtrParIn->PtrComp))));\n" +
+                "                                    ~~~~~~~~~~
", + alarm1.getDescription()); final Issue alarm2 = report.get(119); assertEquals(fileName, Severity.WARNING_HIGH, alarm2.getSeverity()); @@ -182,16 +239,29 @@ private void testReport(Report report) { assertEquals(fileName, 12, alarm2.getColumnStart()); assertEquals(fileName, 78, alarm2.getLineEnd()); assertEquals(fileName, 22, alarm2.getColumnEnd()); + if (fileName.compareTo("report-20.04.xml") <= 0) { + assertEquals(fileName, "ALARM (A): integer division by zero {0}", alarm2.getMessage()); + } else { + assertEquals(fileName, "ALARM (A) int_division_by_zero: divisor in {0}", alarm2.getMessage()); + } + assertEquals(fileName, "n/A", alarm2.getReference()); + assertTrue(fileName, alarm2.getDescription().startsWith("

Code:

IntLoc = IntParI1/0;\n         ~~~~~~~~~~

Context:

l"));
+            assertTrue(fileName, alarm2.getDescription().endsWith("#call#Proc7
")); final Issue error1 = report.get(120); assertEquals(fileName, Severity.ERROR, error1.getSeverity()); - if (fileName.compareTo("report-20.04.xml") <= 0) { + if (fileName.compareTo("report-20.10.xml") <= 0) { assertEquals(fileName, "Definite runtime error [Errors]", error1.getCategory()); assertEquals(fileName, "preprocessed/src/scenarios.c", error1.getFileName()); assertEquals(fileName, 73, error1.getLineStart()); assertEquals(fileName, 8, error1.getColumnStart()); assertEquals(fileName, 73, error1.getLineEnd()); assertEquals(fileName, 25, error1.getColumnEnd()); + if (fileName.compareTo("report-20.04.xml") <= 0) { + assertEquals(fileName, "ERROR: Definite runtime error during assignment in this context. Analysis stopped for this context.", error1.getMessage()); + } else { + assertEquals(fileName, "ERROR: Definite runtime error during assignment in this context. Analysis stopped for this context", error1.getMessage()); + } } else { assertEquals(fileName, "Analysis stopped [Errors]", error1.getCategory()); assertEquals(fileName, "preprocessed/src/dhry/Proc7.c", error1.getFileName()); @@ -199,11 +269,21 @@ private void testReport(Report report) { assertEquals(fileName, 3, error1.getColumnStart()); assertEquals(fileName, 78, error1.getLineEnd()); assertEquals(fileName, 22, error1.getColumnEnd()); + assertEquals(fileName, "ERROR analysis_stopped: Definite runtime error during assignment in this context. Analysis stopped for this context", error1.getMessage()); } + assertEquals(fileName, "n/A", error1.getReference()); + if (fileName.compareTo("report-20.04.xml") <= 0) { + assertTrue(fileName, error1.getDescription().startsWith("

Context:

l"));
+            } else if (fileName.compareTo("report-20.10.xml") <= 0) {
+                assertTrue(fileName, error1.getDescription().startsWith("
Code:
ArrayBlock[i] = i;\n~~~~~~~~~~~~~~~~~
Context:
l"));
+            } else {
+                assertTrue(fileName, error1.getDescription().startsWith("
Code:
IntLoc = IntParI1/0;\n~~~~~~~~~~~~~~~~~~~
Context:
l"));
+            }
+            assertTrue(fileName, error1.getDescription().endsWith("
"));
 
             final Issue error2 = report.get(124);
             assertEquals(fileName, Severity.ERROR, error2.getSeverity());
-            if (fileName.compareTo("report-20.04.xml") <= 0) {
+            if (fileName.compareTo("report-20.10.xml") <= 0) {
                 assertEquals(fileName, "Definite runtime error [Errors]", error2.getCategory());
             } else {
                 assertEquals(fileName, "Analysis stopped [Errors]", error2.getCategory());
@@ -213,6 +293,20 @@ private void testReport(Report report) {
             assertEquals(fileName, 3, error2.getColumnStart());
             assertEquals(fileName, 78, error2.getLineEnd());
             assertEquals(fileName, 22, error2.getColumnEnd());
+            if (fileName.compareTo("report-20.04.xml") <= 0) {
+                assertEquals(fileName, "ERROR: Definite runtime error during assignment in this context. Analysis stopped for this context.", error2.getMessage());
+            } else if (fileName.compareTo("report-20.10.xml") <= 0) {
+                assertEquals(fileName, "ERROR: Definite runtime error during assignment in this context. Analysis stopped for this context", error2.getMessage());
+            } else {
+                assertEquals(fileName, "ERROR analysis_stopped: Definite runtime error during assignment in this context. Analysis stopped for this context", error2.getMessage());
+            }
+            assertEquals(fileName, "n/A", error2.getReference());
+            if (fileName.compareTo("report-20.04.xml") <= 0) {
+                assertTrue(fileName, error2.getDescription().startsWith("
Context:
l"));
+            } else {
+                assertTrue(fileName, error2.getDescription().startsWith("
Code:
IntLoc = IntParI1/0;\n~~~~~~~~~~~~~~~~~~~
Context:
l"));
+            }
+            assertTrue(fileName, error2.getDescription().endsWith("
"));
         } else {
             assertEquals(fileName, 127, report.size());
 
@@ -224,6 +318,13 @@ private void testReport(Report report) {
             assertEquals(fileName, 44, alarm1.getColumnStart());
             assertEquals(fileName, 77, alarm1.getLineEnd());
             assertEquals(fileName, 54, alarm1.getColumnEnd());
+            assertEquals(fileName, "conversion between two incompatible pointer types: from <RecordType *> (aka <struct Record *>) to <char *>
ALARM (R) check_incompatible_object_pointer_conversion: check failed (violates A.1.11)", alarm1.getMessage());
+            assertEquals(fileName, "n/A", alarm1.getReference());
+            assertEquals(fileName,
+                "
Code:
" +
+                "memcpy_x(&((*(PtrParIn->PtrComp))), &(*PtrGlb), sizeof((*(PtrParIn->PtrComp))));\n" +
+                "                                    ~~~~~~~~~~
",
+                alarm1.getDescription());
 
             final Issue error1 = report.get(120);
             assertEquals(fileName, Severity.ERROR, error1.getSeverity());
@@ -233,6 +334,10 @@ private void testReport(Report report) {
             assertEquals(fileName, 3, error1.getColumnStart());
             assertEquals(fileName, 78, error1.getLineEnd());
             assertEquals(fileName, 22, error1.getColumnEnd());
+            assertEquals(fileName, "ERROR analysis_stopped: Definite runtime error during assignment in this context. Analysis stopped for this context", error1.getMessage());
+            assertEquals(fileName, "n/A", error1.getReference());
+            assertTrue(fileName, error1.getDescription().startsWith("
Code:
IntLoc = IntParI1/0;\n~~~~~~~~~~~~~~~~~~~
Context:
l"));
+            assertTrue(fileName, error1.getDescription().endsWith("#call#Proc7
"));
 
             final Issue error2 = report.get(124);
             assertEquals(fileName, Severity.ERROR, error2.getSeverity());
@@ -242,6 +347,10 @@ private void testReport(Report report) {
             assertEquals(fileName, 3, error2.getColumnStart());
             assertEquals(fileName, 78, error2.getLineEnd());
             assertEquals(fileName, 22, error2.getColumnEnd());
+            assertEquals(fileName, "ERROR analysis_stopped: Definite runtime error during assignment in this context. Analysis stopped for this context", error2.getMessage());
+            assertEquals(fileName, "n/A", error2.getReference());
+            assertTrue(fileName, error2.getDescription().startsWith("
Code:
IntLoc = IntParI1/0;\n~~~~~~~~~~~~~~~~~~~
Context:
l"));
+            assertTrue(fileName, error2.getDescription().endsWith("#call#Proc7
"));
         }
     }
 }
diff --git a/src/test/resources/com/absint/astree/report-20.10.xml b/src/test/resources/com/absint/astree/report-20.10.xml
new file mode 100644
index 0000000..2605587
--- /dev/null
+++ b/src/test/resources/com/absint/astree/report-20.10.xml
@@ -0,0 +1,2097 @@
+
+
+    
+        
+        
+        
+        
+    
+    
+    
+    
+    
+        2024/09/25 at 17:24:19
+        2024/09/25 at 17:24:22
+        
+        
+            Analyzer default
+            4
+            4
+            4
+            1
+            1
+            8
+            4
+            4
+            4
+            4
+            8
+            8
+            4
+            2
+            no
+            no
+            no
+            no
+            no
+            no
+            no
+            no
+            no
+            no
+            no
+            no
+            no
+            no
+            signed
+            8
+            8
+            unsigned short
+            unsigned int
+            unsigned
+            big
+            signed
+            int
+            long long int
+            long int
+            0
+            
+            
+            
+            long int
+            all
+            int
+            long unsigned int
+            4
+            4
+            4
+            1
+            8
+            4
+            4
+            4
+            4
+            8
+            8
+            4
+            2
+            error
+            int
+            int
+        
+        
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+        
+        
+            
+                
+                    
+                
+                
+                    
+                        
+                        
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                        
+                    
+                    
+                        
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                        
+                    
+                    
+                        
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                        
+                    
+                    
+                        
+                        
+                    
+                    
+                        
+                    
+                    
+                        
+                        
+                    
+                    
+                        
+                    
+                
+            
+        
+        
+            __ASTREE_volatile_input((SPEED_SENSOR; [0,40000]));
+            __ASTREE_volatile_input((vx; [-1,1]));
+            __ASTREE_volatile_input((vy; [-1,1]));
+            __ASTREE_assert((0 <= msgId && msgId <= 99));
+            __ASTREE_assert((0 <= msgId && msgId <= 99));
+            __ASTREE_assert((-2 <= z && z <= 2));
+            __ASTREE_volatile_input((select; [4,5]));
+            __ASTREE_assert((seconds == 600));
+            __ASTREE_volatile_input((rand));
+            __ASTREE_modify((table2[]; [-1000,1000]));
+            __ASTREE_modify((input; [-10000,10000]));
+            __ASTREE_import((types, functions, variables; ));
+            __ASTREE_log_vars((result; inter));
+            __ASTREE_log_vars((result; inter));
+            __ASTREE_log_vars((result; inter));
+            __ASTREE_unroll((6000))
+            __ASTREE_log_vars((seconds; inter));
+        
+        
+            
+                conversion between two incompatible pointer types: from <RecordType*> (aka <struct Record*>) to <char*>
+                ALARM (R) check_incompatible_object_pointer_conversion: check failed (violates A.1.11)
+            
+            
+                conversion between two incompatible pointer types: from <struct Record*> to <char*>
+                ALARM (R) check_incompatible_object_pointer_conversion: check failed (violates A.1.11)
+            
+            
+                conversion between two incompatible pointer types: from <struct Record*> to <RecordPtr*> (aka <struct Record**>)
+                ALARM (R) check_incompatible_object_pointer_conversion: check failed (violates A.1.11)
+            
+            
+                conversion between two incompatible pointer types: from <struct Record*> to <char*>
+                ALARM (R) check_incompatible_object_pointer_conversion: check failed (violates A.1.11)
+            
+            
+                conversion between two incompatible pointer types: from <RecordType*> (aka <struct Record*>) to <char*>
+                ALARM (R) check_incompatible_object_pointer_conversion: check failed (violates A.1.11)
+            
+            
+                ALARM (A) conversion_overflow_unpredictable: [0, 40000] not included in double->signed short conversion range [-32768, 32767]
+            
+            
+                ALARM (A) uninitialized_variable_use: reading 4 byte(s) at offset(s) 0 in variable uninitialized_1
+            
+            
+                ALARM (A) array_out_of_bounds: {10} not included in array index range [0, 9]
+            
+            
+                ERROR: Definite runtime error during assignment in this context. Analysis stopped for this context
+            
+            
+                ALARM (A) uninitialized_variable_use: reading 4 byte(s) at offset(s) 0 in variable uninitialized_2
+            
+            
+                ALARM (A) overflow_upon_dereference: dereferencing 1 byte(s) at offset(s) 10 may overflow the variable ArrayBlock of byte-size 10
+            
+            
+                ERROR: Definite runtime error during assignment in this context. Analysis stopped for this context
+            
+            
+                ALARM (A) assert_failure: assertion failed
+            
+            
+                ALARM (A) uninitialized_variable_use: reading 4 byte(s) at offset(s) 0 in variable i
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (C) arithmetic_overflow: [-2147483647, 2147483648] not included in signed int arithmetic range [-2147483648, 2147483647]
+            
+            
+                ALARM (D) infinite_loop: loop never terminates for this context
+            
+            
+                ALARM (D) control_flow_anomaly: call to basic_examples never returns in this context
+            
+            
+                ALARM (D) infinite_loop: loop never terminates for this context
+            
+            
+                ALARM (D) control_flow_anomaly: call to loop_with_filter never returns in this context
+            
+            
+                ALARM (A) int_division_by_zero: divisor in {0}
+            
+            
+                ERROR: Definite runtime error during assignment in this context. Analysis stopped for this context
+            
+            
+                ALARM (A) int_division_by_zero: divisor in {0}
+            
+            
+                ERROR: Definite runtime error during assignment in this context. Analysis stopped for this context
+            
+            
+                ALARM (A) int_division_by_zero: divisor in {0}
+            
+            
+                ERROR: Definite runtime error during assignment in this context. Analysis stopped for this context
+            
+        
+        
+            
+                
+                    
+                    
+                
+            
+            
+                
+                
+            
+            
+                
+                    
+                    
+                
+            
+            
+                
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                
+            
+            
+                
+                    
+                    
+                
+            
+            
+                
+                
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                
+            
+            
+                
+            
+            
+                
+            
+            
+                
+            
+            
+                
+                    
+                
+            
+            
+                
+                    
+                
+            
+            
+                
+            
+            
+                
+                    
+                    
+                
+            
+            
+                
+            
+            
+                
+            
+            
+                
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                
+            
+            
+                
+            
+            
+                
+            
+            
+                
+                
+                
+                
+                
+            
+            
+                
+            
+            
+                
+                    
+                
+            
+            
+                
+            
+        
+        
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+        
+        
+            
+                memcpy_x(&((*(PtrParIn->PtrComp))), &(*PtrGlb), sizeof((*(PtrParIn->PtrComp))));
+                                                    ~~~~~~~~~~
+            
+            
+                memcpy_x(&((*(PtrParIn->PtrComp))), &(*PtrGlb), sizeof((*(PtrParIn->PtrComp))));
+                         ~~~~~~~~~~~~~~~~~~~~~~~~~
+            
+            
+                Proc3((*(PtrParIn->PtrComp)).PtrComp);
+                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+            
+            
+                memcpy_x(&(*PtrParIn), &((*(PtrParIn->PtrComp))), sizeof(*PtrParIn));
+                                       ~~~~~~~~~~~~~~~~~~~~~~~~~
+            
+            
+                memcpy_x(&(*PtrParIn), &((*(PtrParIn->PtrComp))), sizeof(*PtrParIn));
+                         ~~~~~~~~~~~~
+            
+            
+                __ASTREE_assert(( seconds == 600 ));
+                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+            
+            
+                basic_examples();
+                ~~~~~~~~~~~~~~~~
+            
+            
+                s = SPEED_SENSOR;
+                ~~~~~~~~~~~~~~~~
+            
+            
+                if (uninitialized_1) {
+                    ~~~~~~~~~~~~~~~
+            
+            
+                ArrayBlock[i] = i;
+                           ~
+            
+            
+                ArrayBlock[i] = i;
+                ~~~~~~~~~~~~~~~~~
+            
+            
+                if (uninitialized_2) {
+                    ~~~~~~~~~~~~~~~
+            
+            
+                *ptr++=i;
+                ~~~~~~
+            
+            
+                *ptr++=i;
+                ~~~~~~~~
+            
+            
+                i++;
+                ~
+            
+            
+                i++;
+                ~~~
+            
+            
+                while (i++) {
+                ~~~~~
+            
+            
+                loop_with_filter();
+                ~~~~~~~~~~~~~~~~~~
+            
+            
+                while (1) {
+                ~~~~~
+            
+            
+                IntLoc = IntParI1/0;
+                         ~~~~~~~~~~
+            
+            
+                IntLoc = IntParI1/0;
+                ~~~~~~~~~~~~~~~~~~~
+            
+        
+        
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+        
+        
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+        
+        
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+        
+    
+    
+        Failed coding rule checks
+        Invalid usage of pointers and arrays
+        Invalid shift argument
+        Invalid ranges and overflows
+        Division or modulo by zero
+        Failed or invalid directives
+        Invalid function calls
+        Uninitialized variables
+        Data and control flow alarms
+        Invalid concurrent behavior
+        Errors
+    
+    
+        Assignment
+        Backjump
+        Bitfield signed size
+        Bitop recast
+        Bitop type
+        Boolean invariant expression
+        Case clause
+        Cast pointer void
+        Comma operator
+        Compound ifelse
+        Compound loop
+        Compound switch
+        Dangling elsegroup
+        Defined generation
+        Define in block
+        Definition duplicate
+        Enum definition
+        External file spreading
+        Extra tokens
+        Error information unused
+        Float bits from pointer
+        Float comparison
+        Floating point loop counter
+        Function ellipsis
+        Function local declarator
+        Function name usage
+        Function pointer cast
+        Function return unused
+        Goto nesting
+        Hash macro multiple
+        Hash macro
+        Identifier unique tag
+        Identifier unique typedef
+        Include characters
+        Include characters backslash
+        Include characters sline
+        Include errno
+        Include position
+        Include setjmp
+        Include signal
+        Include stdio
+        Include syntax
+        Include time
+        Initializer complete strict
+        Initializer shape
+        Integer suffix
+        Integral type name
+        Keyword override
+        Logop side effect
+        Long suffix
+        Loop termination
+        Macro function like
+        Macro parameter parentheses
+        Macro undefined
+        Missing else
+        Mmline comment
+        Multi declaration
+        Non directive
+        Non standard escape sequence
+        Null statement
+        Numeric char usage
+        Octal constant
+        Octal escape sequence
+        Offsetof
+        Parameter name match
+        Plain char operator
+        Plain char usage
+        Pointer arithmetic
+        Pointer depth
+        Pointer qualifier cast const
+        Pointer qualifier cast volatile
+        Pragma usage
+        Precedence
+        Reserved identifier
+        Return implicit
+        Return position
+        Return reference local
+        Shift width constant
+        Sizeof
+        Stdlib use
+        Stdlib use alloc
+        Stdlib use ato
+        Stdlib use getenv
+        Stdlib use system
+        Switch clause break
+        Switch skipped code
+        Switch label
+        Static function declaration
+        Trigraph
+        Type compatibility
+        Unary assign separation
+        Unclosed ifgroup
+        Undef
+        Undefined extern
+        Underlying minus
+        Union
+        Union assignment
+        Union object
+        Unused label
+        Unused parameter
+        Alignof side effect
+        Alloc without cast
+        Alloc without sizeof
+        Alignof void
+        Analysis run
+        Array index range constant
+        Array index range
+        Array index
+        Incompatible function pointer conversion
+        Incompatible object pointer conversion
+        Array initialization
+        Array parameter static size
+        Array size designator
+        Array size external
+        Array size global
+        Array size
+        Assembler
+        Assignment boolean
+        Assignment conditional
+        Assignment overlapping
+        Assignment to non modifiable lvalue
+        At location
+        Attribute
+        Bad function
+        Binary constant
+        Bitfield name max length
+        Bitfield name min length
+        Bitfield name
+        Bitfield type
+        Bitfield typing
+        Bitfield
+        Boolean control
+        Boolean invariant
+        Boolean operation
+        Boolean switch
+        Break in loop
+        Breaks in loop
+        Cast float implicit
+        Cast float
+        Cast implicit
+        Cast integer implicit
+        Cast integer
+        Cast pointer incomplete
+        Cast pointer void arithmetic implicit
+        Cast pointer void arithmetic
+        Chained comparison
+        Char sign conversion
+        Character set
+        Composite assign
+        Composite cast
+        Composite type width
+        Compound alignment
+        Compound brace alignment
+        Compound indentation
+        Conditional macro
+        Conditional
+        Const parameter
+        Constant expression extended
+        Constant expression wrap around
+        Continue
+        Controlling invariant expression
+        Controlling invariant
+        Counter manipulation
+        Ctype limits
+        Defined usage
+        Defined
+        Digraph
+        Directive syntax
+        Distinct extern
+        Distinct identifier hidden
+        Distinct identifiers macros
+        Distinct label
+        Distinct macro parameter
+        Distinct macro
+        Distinct member
+        Distinct ordinary
+        Distinct tags
+        Double dereference
+        Double lvalue assignment
+        Else if
+        Empty body
+        Empty line before block comment
+        Encoding mismatch
+        Empty parameter list
+        Enum implicit value
+        Enum tag max length
+        Enum tag min length
+        Enum tag spelling
+        Enum
+        Enumeration constant name max length
+        Enumeration constant name min length
+        Enumeration constant name
+        Errno reset
+        Error information unused computed
+        Escape termination
+        Essential arithmetic conversion
+        Essential shift width constant
+        Essential shift width
+        Essential type assign
+        Essentially boolean switch
+        Evaluation order initializer
+        Evaluation order
+        Excessive interval
+        Expanded hash parameter
+        Explicit cast overflow
+        Expression statement dead
+        Extern function declaration
+        Extern object declaration
+        Extern
+        External redeclaration
+        Field overflow upon dereference
+        File dereference
+        Filename
+        Flexible array member assignment
+        Flexible array member declaration
+        Float division by zero
+        For loop condition sideeffect
+        For loop control
+        For loop expression type
+        For loop float
+        Forward declared enum
+        Function body order
+        Function body size
+        Function like macro name max length
+        Function like macro name min length
+        Function like macro name
+        Function name length
+        Function parameter name max length
+        Function parameter name min length
+        Function parameter name
+        Function pointer typedef
+        Function name constant comparison
+        Function pointer integer cast implicit
+        Function pointer integer cast
+        Function pointer
+        Function pointer undereferenced call
+        Function prototype
+        Function return type
+        Function type mismatch
+        Future library use
+        Generic selection side effect
+        Global function name max length
+        Global function name min length
+        Global function name
+        Global object name max length
+        Global object name min length
+        Global object name
+        Global object name const
+        Global object scope
+        Global variable
+        Goto
+        Has include
+        Has include next
+        Hash macro order
+        Header definition
+        Hexadecimal escape sequence
+        Identifier hidden
+        Identifier significance
+        Identifier unique extern
+        Identifier unique extern relaxed
+        Identifier unique macro
+        Identifier unique
+        Identifier unique relaxed
+        If condition lvalue
+        If value
+        Ifgroup
+        Implicit designation
+        Implicit function declaration
+        Implicit zero comparison
+        Inappropriate bool
+        Inappropriate cast
+        Inappropriate char usage
+        Inappropriate char
+        Inappropriate enum
+        Inappropriate int
+        Inappropriate pointer cast implicit
+        Inappropriate pointer cast
+        Include assert
+        Include file extension
+        Include malloc
+        Include next
+        Include relative
+        Include stdarg
+        Include tgmath
+        Incompatible argument type
+        Indentation level
+        Infinite loop
+        Initializer complete
+        Initializer excess
+        Initializer exists
+        Initializer multiple
+        Inline static
+        Inline
+        Int division by zero
+        Int modulo by zero
+        Integer overflow
+        Integral type name extended
+        Invalid array size
+        Invalid directive
+        Invalid free
+        Invalid pointer init
+        Invalid pointer return
+        Invalid usage of os service
+        Jump in switch
+        Label in switch
+        Label reuse
+        Language override c99
+        Language override
+        Language undefine c99
+        Language undefine
+        Line comment
+        Literal assignment
+        Local object name max length
+        Local object name min length
+        Local object name
+        Local object name const
+        Local object scope
+        Local static
+        Logical expression align
+        Logical expression alignment
+        Logical operators
+        Logop primary operand
+        Lvalue cast
+        Macro argument hash
+        Macro expansion
+        Macro final semicolon
+        Macro identifier length
+        Macro identifier reuse
+        Macro parameter match
+        Macro parameter multiplied
+        Macro parameter unparenthesized expression
+        Macro parameter unused
+        Macro unparenthesized
+        Malloc size insufficient
+        Max arguments macro
+        Max case labels
+        Max condition nesting
+        Maximum control nesting depth
+        Maximum control nesting depth ('else if' is one level)
+        Maximum cyclomatic complexity
+        Max declarator depth
+        Max declarator nesting
+        Max enums
+        Max expression nesting
+        Max externals
+        Maximum number of goto statements
+        Max include nesting
+        Maximum number of instructions
+        Maximum language scope
+        Max locals
+        Maximum number of local variables
+        Max logical line length
+        Max macros defined
+        Maximum number of maintainable code lines
+        Max members
+        Maximum number of called functions
+        Maximum number of functions calling a function
+        Maximum number of execution paths
+        Maximum number of recursive paths in the call graph
+        Max parameters macro
+        Maximum number of parameters
+        Max pointer per file
+        Max pointer per function
+        Maximum number of return statements
+        Maximum size of statement
+        Max statement nesting
+        Max string length
+        Max struct nesting
+        Member name reuse
+        Memcmp argument types
+        Memcmp on string
+        Memcmp with float
+        Memcmp with padding
+        Memcpy overlapping
+        Memory function compatible
+        Minimum Comment Density - HIS Definition
+        Minimum comment density
+        Minimum cyclomatic complexity
+        Minimum number of instructions
+        Minimum number of functions calling a function
+        Missing else strict
+        Multi character constant
+        Multiple atomic accesses
+        Multiple include
+        Multiple volatile accesses
+        Multiple writes in full expr
+        Named declaration parameter
+        Namespace overlap
+        No whitespace after prefix
+        No whitespace before postfix
+        Non standard identifier
+        Non standard keyword
+        Null dereferencing
+        Null pointer constant
+        Null statement strict
+        Object like macro name max length
+        Object like macro name min length
+        Object like macro name
+        Object pointer cast
+        Object pointer diff cast implicit
+        Object pointer diff cast strict implicit
+        Object pointer diff cast strict
+        Object pointer diff cast
+        Object type mismatch
+        Overflow upon dereference
+        Overlong line
+        Overlong src line
+        Parameter assignment
+        Parameter match computed
+        Parameter match type
+        Parameter match
+        Parameter missing const
+        Parameter name
+        Parameters
+        Pointer attribute
+        Pointer cast alignment
+        Pointer cast
+        Pointer comparison
+        Pointer counting
+        Pointer integral cast implicit
+        Pointer integral cast
+        Pointer qualifier cast const implicit
+        Pointer qualifier cast volatile implicit
+        Pointer subscript
+        Pointer subtraction
+        Pointer to pointer
+        Pointer typedef
+        Pointered deallocation
+        Pragma
+        Precision shift width constant
+        Precision shift width
+        Preprocessor wrap around
+        Promoted bitop type
+        Read data race
+        Recursion
+        Redeclaration
+        Reserved declaration c99
+        Reserved declaration
+        Restrict
+        Return empty
+        Return value
+        Scaled pointer arithmetic
+        Shift width
+        Side effect in initializer list
+        Side effect in logical exp
+        Signal handler shared access
+        Signal handler signal call
+        Signal handler unsafe call
+        Simple escape sequence
+        Sizeof array parameter
+        Sizeof non object
+        Sizeof parenthesized
+        Sizeof void
+        Sline comment
+        Sline splicing
+        Smline comment
+        Statement expression
+        Statement line
+        Statement sideeffect
+        Statement whitespace
+        Static assert
+        Static function name max length
+        Static function name min length
+        Static function name
+        Static identifier reuse
+        Static object declaration
+        Static object name max length
+        Static object name min length
+        Static object name
+        Static object name const
+        Stdlib const pointer assign
+        Stdlib limits
+        Stdlib macro alloc
+        Stdlib macro ato
+        Stdlib macro atoll
+        Stdlib macro compar
+        Stdlib macro getenv
+        Stdlib macro stdio
+        Stdlib macro wchar
+        Stdlib macro
+        Stdlib use atoll
+        Stdlib use compar
+        Stdlib use fenv
+        Stdlib use rand
+        Stdlib use signal
+        Stdlib use wchar
+        Stream argument with side effects
+        String literal modification
+        Struct member name max length
+        Struct member name min length
+        Struct member name
+        Struct tag max length
+        Struct tag min length
+        Struct tag spelling
+        Struct type incomplete
+        Struct typedef name max length
+        Struct typedef name min length
+        Struct typedef name
+        Switch clause count
+        Switch clause empty compound
+        Switch clause empty
+        Switch clause syntax
+        Switch clauses
+        Switch default position
+        Switch default
+        Switch enum default
+        Switch final default
+        Switch in switch
+        Switch multiple default
+        Tabulator
+        Type compatibility link
+        Type specifier
+        Typedef name max length
+        Typedef name min length
+        Typedef name
+        Unary assign detachment
+        Unary minus
+        Undeclared parameter
+        Uninitialized local read
+        Uninitialized variable use
+        Union member name max length
+        Union member name min length
+        Union member name
+        Union tag max length
+        Union tag min length
+        Union tag spelling
+        Union typedef name max length
+        Union typedef name min length
+        Union typedef name
+        Universal character name
+        Universal character name concatenation
+        Unnamed constant
+        Unreachable code
+        Unsupported language feature
+        Unsupported language feature fatal
+        Unused macro
+        Unused tag
+        Unused typedef
+        Variable array length
+        Variable name length
+        Wcsftime
+        Whitespace after comma
+        Whitespace after statement keyword
+        Whitespaces around array brackets
+        Whitespaces around binary
+        Whitespaces around function call
+        Whitespaces around member access
+        Wide narrow string cast implicit
+        Wide narrow string cast
+        Write data race
+        Write to constant memory
+        Write to string literal
+        Literal assignment type
+        Bad macro expansion
+        Bad include
+        Block indentation
+        Local static object name
+        Local static object name const
+        Whitespaces around pointer declarator
+        Macro parameter unparenthesized expression strict
+        Non constant static assert
+        Composite cast width
+        Switch clause break continue
+        Switch clause break return
+        Clang warning
+        Annotation insertion failed
+        Conflicting absolute addresses
+        Missing rulechecking phases
+        Unused suppress directives
+        Ignored volatile
+        Empty struct
+        Return non empty
+        Pointer arithmetic void
+        Expression statement pure
+        Flexible array member
+        Module abbreviation min length
+        Module abbreviation max length
+        Enumerator value
+        Builtin sel
+        Builtin constant p
+        Alignas extended
+        Packed specifier
+        Unnamed parameter
+        Generic selection
+        Noreturn
+        Atomic specifier
+        Atomic qualifier
+        Thread local
+        Alignas
+        Alignof
+        Side effect in conditional
+        Comma in constant expression
+        Local function storage class
+        Non empty identifier list
+        Parameter missing declarator
+        Tentative type incomplete
+        Hash operator
+        Double hash placement
+        Undef syntax
+        Local object incomplete
+        Unsigned bitfield promotion
+        Address of void
+        Pointer arithmetic function
+        Sizeof incomplete type
+        Invalid lvalue
+        Pointer arithmetic incomplete
+        Invalid pointer comparison
+        Function definition storage class
+        Zero sized bitfield with declarator
+        Element type incomplete
+        Initialized local variable with linkage
+        Function declaration with initializer
+        Label without statement
+        Constant expression extended pp
+        Escape sequence out of range pp
+        Define syntax
+        Non standard escape sequence pp
+        Unreachable code after jump
+        Local function typedef
+        Long long c90
+        Invalid pointer comparison
+        Subtraction of invalid pointers
+        Arithmetics on invalid pointers
+        Dereference of null or invalid pointer
+        Possible overflow upon dereference
+        Incorrect field dereference
+        Dereference of mis-aligned pointer
+        Pointer to invalid or null function
+        Out-of-bound array access
+        Use of dangling pointer
+        Attempt to write to a constant
+        Invalid argument in dynamic memory allocation, free or resize
+        Wrong range of second shift argument
+        Wrong range of first shift argument
+        Float argument can be NaN or infinity
+        Offset range overflow
+        Overflow in arithmetic
+        Overflow in conversion
+        Overflow in conversion (with unpredictable result)
+        Constant out of range
+        Global assertion failure
+        Integer division by zero
+        Integer modulo by zero
+        Undefined integer modulo
+        Float division by zero
+        Invalid memcpy/bzero/access/trash
+        Assertion failure
+        Check failure
+        Square root of negative number
+        Invalid interval
+        User defined alarm
+        Ignored recursive call
+        Function call with wrong number of arguments
+        Incompatible parameter type in a function call
+        Incompatible function return type
+        Stub invocation
+        Reinterpreting incompatible parameter type in a function call
+        Reinterpreting incompatible function return type
+        Stopped separate context
+        Use of uninitialized variables
+        Control flow anomaly
+        Reading global/static variable without explicit initializer or prior assignment
+        Write after write
+        Infinite loop
+        Taint sink
+        Spectre vulnerability
+        Unbounded loop
+        Invalid usage of concurrency intrinsic
+        Invalid usage of OS service
+        Read/write data race
+        Write/write data race
+        Deadlock
+        Other
+        Definite runtime error
+        Analysis stopped unexpectedly
+        Ignored directive
+        Invalid conversion
+        Parsing
+        Preprocessing
+        Deprecated syntax
+        Unsupported switch
+        Clang error
+    
+    
+        Analyzer configuration.
+        Language features not supported by Astree should be avoided.
+        Language features not supported by Astree that are discarded by the frontend should be avoided.
+        Directives are required to follow the syntax and constraints specified in the manual.
+        The result of the evaluation of an initializer list expression shall not depend on the order of evaluation of elements and subexpressions. (ISO/IEC 9899:1999 6.7.8)
+        The result of the evaluation of an expression shall not depend on the order of evaluation of subexpressions. (ISO/IEC 9899:1999 6.5)
+        A bit-field shall have a type _Bool, signed int, unsigned int, or some other implementation-defined type. (ISO/IEC 9899:1999 6.7.2.1)
+        The value of an integer character constant containing more than one character is implementation-defined. (ISO/IEC 9899:1999 6.4.4.4p10)
+        No cast shall be performed between pointer types and integer types. (ISO/IEC 9899:1999 6.3.2.3p5+6)
+        The signed or unsigned integer type long long shall not be used with language version C90.
+        The compiler-specific __packed__ type specifier shall not be used. (ISO/IEC 9899:1999 4p5)
+        Compiler-specific builtin functions shall not be used. (ISO/IEC 9899:1999 4p5)
+        Enumerators shall have a value representable as an int. (ISO/IEC 9899:2011 6.7.2.2p2+3)
+        Pointer arithmetic shall not be applied to pointer to incomplete type. (ISO/IEC 9899:2011 6.5.6p2+3)
+        A struct type shall have at least one member. (ISO/IEC 9899:1999 6.7.2.1)
+        __attribute__((...)) and __attribute((...)) shall not be used. (ISO/IEC 9899:1999 4p5)
+        The include file checking macros __has_include and __has_include_next shall not be used. (ISO/IEC 9899:1999 4p5)
+        GCC's #include_next directive shall not be used. (ISO/IEC 9899:1999 4p5)
+        The sizeof and _Alignof operator shall not be applied to type void. (ISO/IEC 9899:2011 6.5.3.4p1)
+        Identifiers containing characters not provided for by the C standard shall not be used. (ISO/IEC 9899:1999 6.4.2.1)
+        Non-standard escape sequences shall not be used. (ISO/IEC 9899:1999 6.4.4.4)
+        GCC's binary constants shall not be used. (ISO/IEC 9899:1999 4p5)
+        GCC's statement expressions shall not be used. (ISO/IEC 9899:1999 4p5)
+        Pointer attributes shall be avoided. (ISO/IEC 9899:1999 4p5)
+        Non-standard keywords shall not be used. (ISO/IEC 9899:1999 4p5)
+        Lvalue casts shall be avoided. (ISO/IEC 9899:1999 4p5)
+        Enums shall not be forward-declared, i.e. used as complete type before being defined. (ISO/IEC 9899:1999 4p5)
+        Only integer constant expressions stricly conforming to the C standard shall be used. (ISO/IEC 9899:1999 6.6p10)
+        Data placement at an absolute location shall be avoided. (ISO/IEC 9899:1999 4p5)
+        Assembler code shall be avoided. (ISO/IEC 9899:1999 4p5)
+        Implicit function declaration shall not be used. (ISO/IEC 9899:1999 6.5.1p2)
+        The declaration of each parameter in a function definition shall include an identifier. (ISO/IEC 9899:2011 6.9.1p5)
+        The alignment specifier _Alignas shall only be used as specified by the C standard. (ISO/IEC 9899:2011 6.7.5)
+        A return statement shall only define a return value if and only if the containing function has non-void return type. (ISO/IEC 9899:2011 6.8.6.4p1)
+        A pointer type shall not be implicitly converted into an incompatible pointer type. (ISO/IEC 9899:1999 6.5.16.1p1)
+        Every parameter identifier in a function definition with identifier-list shall be declared. (ISO/IEC 9899:1999 6.9.1p6)
+        If an identifier has no linkage, there shall be no more than one declaration of the identifier with the same scope and in the same name space, except for tags. (ISO/IEC 9899:1999 6.7p3)
+        No initializer shall attempt to provide a value for an object not contained within the entity being initialized. (ISO/IEC 9899:1999 6.7.8p2)
+        The lvalue of a unary or binary assignment operator shall be a modifiable lvalue. (ISO/IEC 9899:1999 6.5.16p2)
+        The constant expression of a static assert shall compare unequal to zero. (ISO/IEC 9899:2011 6.7.10p2)
+        The number of arguments shall agree with the number of parameters. (ISO/IEC 9899:1999 6.5.2.2p2)
+        No implicit conversion shall be performed between pointer types and integer types. (ISO/IEC 9899:1999 6.5.4p3)
+        At least one type specifier shall be given in a declaration. (ISO/IEC 9899:1999 6.7.2p2)
+        If the size expression of an array declarator is constant, it shall have a value greater than zero. (ISO/IEC 9899:1999 6.7.5.2p1)
+        Two declarations that declare the same entity must be of compatible type. (ISO/IEC 9899:1999 6.2.7p2)
+        Clang warnings.
+    
+    
+        AAL annotations shall address valid source locations.
+        Memory areas declared with absolute addresses shall not partially overlap.
+        Rule checks which depend on an analysis phase which is not active cannot be executed.
+        Language features that are not supported by the analyzer shall not be used.
+        #pragma directives shall only be used in the specified manner.
+        Unsupported language features shall not be used.
+        Intervals specified in directives shall not exceed the range of values of the affected type.
+        Directives that do not comply with the constraints are dropped by the frontend.
+        The values of initializer lists shall not depend on the order of evaluation of its elements and their subexpressions.
+        The value of an expression and its persistent side effects shall be the same under all evaluation orders.
+        Bitfields shall be of signed or unsigned integer type.
+        Character constant containing more than one c-char.
+        Conversions shall not be performed between a pointer to a function and an integer type.
+        A cast shall not be performed between a pointer to object type and an integral type.
+        The type (unsigned) long long shall not be used in C90.
+        The compiler-specific type specifier __packed__ shall not be used.
+        The compiler-specific builtin function __builtin_constant_p() shall not be used.
+        The compiler-specific builtin function __builtin_sel() shall not be used.
+        The value of an enumerator shall be representable as a signed int.
+        Poitner arithmetic shall not be used with pointers to void.
+        A struct type shall have at least one member.
+        __attribute__((...)) and __attribute((...)) shall not be used.
+        The include file checking macro __has_include shall not be used.
+        The include file checking macro __has_include_next shall not be used.
+        #include_next directives shall be avoided.
+        The _Alignof operator shall not be applied to type void.
+        The sizeof operator shall not be applied to type void.
+        Identifiers containing characters not provided for by the C standard shall not be used.
+        Non-standard escape sequences shall not be used.
+        Non-standard escape sequences shall not be used in preprocessor directives.
+        GCC's binary constants shall be avoided.
+        GCC's statement expressions shall be avoided.
+        Pointer attributes shall be avoided.
+        Non-standard keywords shall not be used.
+        Lvalue casts shall be avoided.
+        Enums shall not be forward-declared.
+        Only stricly conforming constant expressions shall be used.
+        Only stricly conforming constant expressions shall be used in preprocessor directives.
+        Data placement at an absolute address using @ notation shall be avoided.
+        Assembler code shall be avoided.
+        Functions shall not be declared implicitly.
+        There shall be no unnamed parameters in function definitions.
+        The alignment specifier _Alignas shall only be used as specified by the C standard.
+        In functions with non-void return type, a return statement shall define a return value.
+        In functions with void return type, a return statement shall not define a return value.
+        A (function) pointer type shall not be implicitly converted into an incompatible (function) pointer type.
+        An object pointer type shall not be implicitly converted into an incompatible object pointer type.
+        Every parameter identifier in a function definition with identifier-list shall be declared.
+        Entities with no linkage shall not be redeclared in the same scope.
+        An array initializer shall not exceed the size of the object initialized.
+        The lvalue to which an assignment is applied to shall be a modifiable lvalue.
+        The condition of _Static_assert shall be a constant expression.
+        The constant expression of a static assert (_Static_assert) shall compare unequal to zero.
+        The number of arguments at a function call shall match the number of parameters according to the type of the function designator.
+        Conversions shall not be performed between a pointer to a function and an integer type.
+        An Implicit cast shall not be performed between a pointer to object type and an integral type.
+        A function definition shall comprise the return type.
+        Every variable declaration statement shall comprise the data type.
+        If the size expression of an array declarator is constant, it shall have a value greater than zero.
+        If objects or functions are declared more than once their types shall be compatible.
+        If objects or functions are declared more than once their types shall be compatible.
+        Warning issued by the clang frontend
+    
+    
+        Number of files
+        Number of function definitions
+        Number of source lines
+        Number of physical lines of code
+        Number of recursive paths in the call graph
+        Comment density
+        Number of function definitions
+        Number of source lines
+        Number of physical lines of code
+        Number of functions calling a function
+        Maximum number of distinct subfunctions called
+        Comment density (HIS)
+        Cyclomatic complexity
+        Number of goto statements
+        Maximum nesting of control structures
+        Number of local variables
+        Language scope
+        Number of maintainable code lines
+        Number of parameters
+        Maximum number of execution paths
+        Number of return statements
+        Number of instructions
+    
+