func fetchInnerStatements(lines []string, factory *StatementFactory, lineNum int) ([]Statement, parser.SyntaxError) {
scanner := parser.NewScanPeekerStr(parser.FromLines(lines), lineNum)
statements := make([]Statement, 0)
next := func() (Statement, parser.SyntaxError) {
return factory.Read(scanner)
}
return subFetchInnerStatements(next, statements)
}
func generateInnerFunc(typeDef expressionParsing.TypeDefinition, tabCount int, innerStatements []string) string {
tabs := ""
for i := 0; i <= tabCount; i++ {
tabs += "\t"
}
tabs2 := string(tabs[:len(tabs)-1])
if _, ok := typeDef.(expressionParsing.FuncTypeDefinition); !ok {
lenInner := len(innerStatements) - 1
innerCode := parser.FromLines(innerStatements[:lenInner])
return fmt.Sprintf("%s\n%sreturn %s", innerCode, tabs2, innerStatements[lenInner])
}
return fmt.Sprintf("return %s {\n%s%s\n%s}", generateTypeDef(false, typeDef), tabs, generateInnerFunc(getReturnType(typeDef), tabCount+1, innerStatements), tabs2)
}
func (ds LetStatement) Parse(block string, lineNum int, nextBlockScanner *parser.ScanPeeker, factory *StatementFactory) (Statement, parser.SyntaxError) {
lines := parser.Lines(block)
ok, varName, restOfLine := splitEquals(lines[0])
if ok {
if ds.packageLevel {
factory = adjustFactory(varName, factory)
}
combinedLine := parser.FromLines(append([]string{restOfLine}, lines[1:]...))
peeker := parser.NewScanPeekerStr(combinedLine, lineNum)
st, err := factory.Read(peeker)
if err != nil {
return nil, err
}
return newLetStatement(varName, combinedLine, lineNum, st), nil
}
if ds.packageLevel {
return nil, parser.NewSyntaxError(fmt.Sprintf("Unknown statement: %s", lines[0]), lineNum, 0)
} else {
return nil, nil
}
}