OSDN Git Service

optimise equity commandline (#36)
[bytom/equity.git] / equity / main.go
index 367e8bc..62d2734 100644 (file)
@@ -52,95 +52,100 @@ var equityCmd = &cobra.Command{
        Run: func(cmd *cobra.Command, args []string) {
                if version {
                        version := compiler.VersionWithCommit(compiler.GitCommit)
+                       fmt.Println("equity, the equity compiler commandline interface")
                        fmt.Println("Version:", version)
                        os.Exit(0)
                }
 
                if len(args) < 1 {
                        cmd.Usage()
-               }
-
-               contractFile, err := os.Open(args[0])
-               if err != nil {
-                       fmt.Printf("An error [%v] occurred on opening the file, please check whether the file exists or can be accessed.\n", err)
                        os.Exit(0)
                }
-               defer contractFile.Close()
 
-               reader := bufio.NewReader(contractFile)
-               contracts, err := compiler.Compile(reader)
-               if err != nil {
-                       fmt.Println("Compile contract failed:", err)
-                       os.Exit(0)
+               if err := handleCompiled(args); err != nil {
+                       os.Exit(-1)
                }
+       },
+}
 
-               if len(contracts) == 0 {
-                       fmt.Println("The contract is empty!")
-                       os.Exit(0)
+func handleCompiled(args []string) error {
+       contractFile, err := os.Open(args[0])
+       if err != nil {
+               fmt.Printf("An error [%v] occurred on opening the file, please check whether the file exists or can be accessed.\n", err)
+               return err
+       }
+       defer contractFile.Close()
+
+       reader := bufio.NewReader(contractFile)
+       contracts, err := compiler.Compile(reader)
+       if err != nil {
+               fmt.Println("Compile contract failed:", err)
+               return err
+       }
+
+       // Print the result for all contracts
+       for i, contract := range contracts {
+               fmt.Printf("======= %v =======\n", contract.Name)
+               if bin {
+                       fmt.Println("Binary:")
+                       fmt.Printf("%v\n\n", hex.EncodeToString(contract.Body))
                }
 
-               // Print the result for all contracts
-               for i, contract := range contracts {
-                       fmt.Printf("======= %v =======\n", contract.Name)
-                       if bin {
-                               fmt.Println("Binary:")
-                               fmt.Printf("%v\n\n", hex.EncodeToString(contract.Body))
+               if shift {
+                       fmt.Println("Clause shift:")
+                       clauseMap, err := equ.Shift(contract)
+                       if err != nil {
+                               fmt.Println("Statistics contract clause shift error:", err)
+                               return err
                        }
 
-                       if shift {
-                               fmt.Println("Clause shift:")
-                               clauseMap, err := equ.Shift(contract)
-                               if err != nil {
-                                       fmt.Println("Statistics contract clause shift error:", err)
-                                       os.Exit(0)
-                               }
-
-                               for clause, shift := range clauseMap {
-                                       fmt.Printf("    %s:  %v\n", clause, shift)
-                               }
-                               fmt.Printf("\nNOTE: \n    If the contract contains only one clause, Users don't need clause selector when unlock contract." +
-                                       "\n    Furthermore, there is no signification for ending clause shift except for display.\n\n")
+                       for clause, shift := range clauseMap {
+                               fmt.Printf("    %s:  %v\n", clause, shift)
                        }
+                       fmt.Printf("\nNOTE: \n    If the contract contains only one clause, Users don't need clause selector when unlock contract." +
+                               "\n    Furthermore, there is no signification for ending clause shift except for display.\n\n")
+               }
 
-                       if instance {
-                               if i != len(contracts)-1 {
-                                       continue
-                               }
+               if instance {
+                       if i != len(contracts)-1 {
+                               continue
+                       }
 
-                               fmt.Println("Instantiated program:")
-                               if len(args)-1 < len(contract.Params) {
-                                       fmt.Printf("Error: The number of input arguments %d is less than the number of contract parameters %d\n", len(args)-1, len(contract.Params))
-                                       usage := fmt.Sprintf("Usage:\n  equity %s", args[0])
-                                       for _, param := range contract.Params {
-                                               usage = usage + " <" + param.Name + ">"
-                                       }
-                                       fmt.Printf("%s\n\n", usage)
-                                       os.Exit(0)
+                       fmt.Println("Instantiated program:")
+                       if len(args)-1 < len(contract.Params) {
+                               fmt.Printf("Error: The number of input arguments %d is less than the number of contract parameters %d\n", len(args)-1, len(contract.Params))
+                               usage := fmt.Sprintf("Usage:\n  equity %s", args[0])
+                               for _, param := range contract.Params {
+                                       usage = usage + " <" + param.Name + ">"
                                }
+                               fmt.Printf("%s\n\n", usage)
+                               return err
+                       }
 
-                               contractArgs, err := equ.ConvertArguments(contract, args[1:len(contract.Params)+1])
-                               if err != nil {
-                                       fmt.Println("Convert arguments into contract parameters error:", err)
-                                       os.Exit(0)
-                               }
+                       contractArgs, err := equ.ConvertArguments(contract, args[1:len(contract.Params)+1])
+                       if err != nil {
+                               fmt.Println("Convert arguments into contract parameters error:", err)
+                               return err
+                       }
 
-                               instantProg, err := equ.InstantiateContract(contract, contractArgs)
-                               if err != nil {
-                                       fmt.Println("Instantiate contract error:", err)
-                                       os.Exit(0)
-                               }
-                               fmt.Printf("%v\n\n", hex.EncodeToString(instantProg))
+                       instantProg, err := equ.InstantiateContract(contract, contractArgs)
+                       if err != nil {
+                               fmt.Println("Instantiate contract error:", err)
+                               return err
                        }
+                       fmt.Printf("%v\n\n", hex.EncodeToString(instantProg))
+               }
 
-                       if ast {
-                               fmt.Println("Ast:")
-                               rawData, err := equ.JSONMarshal(contract, true)
-                               if err != nil {
-                                       fmt.Println("Marshal the struct of contract to json error:", err)
-                                       os.Exit(0)
-                               }
-                               fmt.Println(string(rawData))
+               if ast {
+                       fmt.Println("Ast:")
+                       rawData, err := equ.JSONMarshal(contract, true)
+                       if err != nil {
+                               fmt.Println("Marshal the struct of contract to json error:", err)
+                               return err
                        }
+                       fmt.Println(string(rawData))
                }
-       },
+       }
+
+       return nil
 }