File parser.go has 2252 lines of code (exceeds 1000 allowed). Consider refactoring.

Confirmed

package fortran

import (
    "bytes"
    "fmt"

Method parser.parseData has a Cognitive Complexity of 129 (exceeds 20 allowed). Consider refactoring.

Open

func (p *parser) parseData() (stmts []goast.Stmt) {
    p.expect(ftData)
    p.ident++

    // parse names and values

• Read up
  Read up

Method parser.parseStmt has a Cognitive Complexity of 103 (exceeds 20 allowed). Consider refactoring.

Open

func (p *parser) parseStmt() (stmts []goast.Stmt) {
    onlyForRecover := p.ident

    pos := p.ns[p.ident].pos

• Read up
  Read up

parser has 34 methods (exceeds 20 allowed). Consider refactoring.

Confirmed

func (p parser) getSize(name string, col int) (size int, ok bool) {
    v, ok := p.initVars.get(name)
    if !ok {
        panic("Cannot find variable : " + name)
    }

Method parser.initializeVars has a Cognitive Complexity of 42 (exceeds 20 allowed). Consider refactoring.

Open

func (p *parser) initializeVars() (vars []goast.Stmt) {
    defer func() {
        if r := recover(); r != nil {
            err := fmt.Sprintf("Recover initializeVars : %v", r)
            Debugf("%s", err)

• Read up
  Read up

Method parser.parseCommon has a Cognitive Complexity of 42 (exceeds 20 allowed). Consider refactoring.

Open

func (p *parser) parseCommon() (stmts []goast.Stmt) {
    p.expect(ftCommon)
    p.ident++

    var blockName string = "ALL"

• Read up
  Read up

Method parser.parseNodes has a Cognitive Complexity of 36 (exceeds 20 allowed). Consider refactoring.

Open

func (p *parser) parseNodes() (decls []goast.Decl) {
    Debugf("Parse nodes")

    if p.ident < 0 || p.ident >= len(p.ns) {
        p.errs = append(p.errs,

• Read up
  Read up

Function explodeFor has a Cognitive Complexity of 36 (exceeds 20 allowed). Consider refactoring.

Open

func explodeFor(name []node) (out [][]node, ok bool) {
    // have loop
    if len(name) == 0 {
        return
    }

• Read up
  Read up

Method parser.parseSubroutine has a Cognitive Complexity of 35 (exceeds 20 allowed). Consider refactoring.

Open

func (p *parser) parseSubroutine() (decl goast.Decl) {
    Debugf("Parse subroutine")

    defer func() {
        p.init()

• Read up
  Read up

Method parser.parseStmt has 287 lines of code (exceeds 250 allowed). Consider refactoring.

Open

func (p *parser) parseStmt() (stmts []goast.Stmt) {
    onlyForRecover := p.ident

    pos := p.ns[p.ident].pos

Method parser.parseParameter has a Cognitive Complexity of 30 (exceeds 20 allowed). Consider refactoring.

Open

func (p *parser) parseParameter() (stmts []goast.Stmt) {
    start := p.ident
    p.expect(ftParameter)
    p.ident++
    p.expect(token.LPAREN)

• Read up
  Read up

Method parser.parseData has 266 lines of code (exceeds 250 allowed). Consider refactoring.

Open

func (p *parser) parseData() (stmts []goast.Stmt) {
    p.expect(ftData)
    p.ident++

    // parse names and values

Function Parse has a Cognitive Complexity of 28 (exceeds 20 allowed). Consider refactoring.

Open

func Parse(b []byte, packageName string) (_ goast.File, errs []error) {

    if packageName == "" {
        packageName = "main"
    }

• Read up
  Read up

Method parser.parseCall has a Cognitive Complexity of 28 (exceeds 20 allowed). Consider refactoring.

Open

func (p *parser) parseCall() goast.Stmt {
    {
        begin := p.ident
        p.expect(ftCall)
        p.ident++

• Read up
  Read up

Method parser.parseDo has a Cognitive Complexity of 27 (exceeds 20 allowed). Consider refactoring.

Open

func (p *parser) parseDo() (sDo goast.ForStmt) {
    p.expect(ftDo)
    p.ident++
    if p.ns[p.ident].tok == ftWhile {
        p.ident--

• Read up
  Read up

Method parser.parseInit has a Cognitive Complexity of 25 (exceeds 20 allowed). Consider refactoring.

Open

func (p *parser) parseInit() (stmts []goast.Stmt) {

    // parse base type
    var baseType []node
    for ; p.ns[p.ident].tok != token.IDENT; p.ident++ {

• Read up
  Read up

Function explodeFor has 8 return statements (exceeds 4 allowed).

Open

func explodeFor(name []node) (out [][]node, ok bool) {
    // have loop
    if len(name) == 0 {
        return
    }

Avoid deeply nested control flow statements.

Open

                    if counter == 0 {
                        break
                    }

Avoid deeply nested control flow statements.

Open

                    switch p.ns[pos].tok {
                    case token.LPAREN:
                        counter++
                    case token.RPAREN:
                        counter--

Avoid deeply nested control flow statements.

Open

                    switch p.ns[p.ident].tok {
                    case token.LPAREN:
                        counter++
                    case token.RPAREN:
                        counter--

Avoid deeply nested control flow statements.

Open

                    if counter == 0 {
                        break
                    }

Avoid deeply nested control flow statements.

Open

                    if ok {
                        // add init
                        var inject []node
                        inject = append(inject, typ...)
                        for i := start; i < pos; i++ {

Method parser.parseStmt has 6 return statements (exceeds 4 allowed).

Open

func (p *parser) parseStmt() (stmts []goast.Stmt) {
    onlyForRecover := p.ident

    pos := p.ns[p.ident].pos

Method strChanger.Visit has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (s strChanger) Visit(node goast.Node) (w goast.Visitor) {
    if call, ok := node.(*goast.CallExpr); ok {
        if sel, ok := call.Fun.(*goast.SelectorExpr); ok {
            if id, ok := sel.X.(*goast.Ident); ok {
                if id.Name == "fmt" || id.Name == "math" {

• Read up
  Read up