launch.tcl

Go to the documentation of this file.

#!/usr/bin/env tclsh
# @file
#   Copyright 2018-2026 The University of Birmingham
#
#   Licensed under the Apache License, Version 2.0 (the "License");
#   you may not use this file except in compliance with the License.
#   You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0
#
#   Unless required by applicable law or agreed to in writing, software
#   distributed under the License is distributed on an "AS IS" BASIS,
#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#   See the License for the specific language governing permissions and
#   limitations under the License.
 
 
# Launch Xilinx Vivado or ISE implementation and possibly write bitstream in text mode
 
# Developers Tip for new commands
# Add a hashtag sign # after the curly brake (e.g. \^C(REATE)?$ {# ...}) if the command requires a project name as an argument
 
set default_commands {
 
  \^L(IST)?$ {
    Msg Status "\n** The projects in this repository are:"
    ListProjects $repo_path $list_all
    Msg Status "\n"
    exit 0
  # NAME*: LIST or L
  # DESCRIPTION: List the projects in the repository. To show hidden projects use the -all option
  # OPTIONS: all, verbose
  }
 
  \^H(ELP)?$ {
    puts "$usage"
    exit 0
  # NAME: HELP or H
  # DESCRIPTION: Display this help message or specific help for each directive
  # OPTIONS:
  }
 
  \^C(REATE)?$ {#
    set do_create 1
    set recreate 1
  # NAME*: CREATE or C
  # DESCRIPTION: Create the project, replace it if already existing.
  # OPTIONS: ext_path.arg, lib.arg, vivado_only, verbose
  }
 
  \^I(MPL(EMENT(ATION)?)?)?$ {#
    set do_implementation 1
    set do_bitstream 1
    set do_compile 1
  # NAME: IMPLEMENTATION or I
  # DESCRIPTION: Runs only the implementation, the project must already exist and be synthesised.
  # OPTIONS: check_syntax, ext_path.arg, njobs.arg, no_bitstream, no_reset, recreate, verbose
  }
 
  \^SYNT(H(ESIS(E)?)?)? {#
    set do_synthesis 1
    set do_compile 1
  # NAME: SYNTH
  # DESCRIPTION: Run synthesis only, create the project if not existing.
  # OPTIONS: check_syntax, ext_path.arg, njobs.arg, recreate, verbose
  }
 
  \^S(IM(ULAT(ION|E)?)?)?$ {#
    set do_simulation 1
    set do_create 1
  # NAME*: SIMULATION or S
  # DESCRIPTION: Simulate the project, creating it if not existing, unless it is a GHDL simulation.
  # OPTIONS: check_syntax, compile_only, ext_path.arg, lib.arg, recreate, scripts_only, simset.arg, verbose
  }
 
  \^W(ORK(FLOW)?)?$ {#
    set do_implementation 1
    set do_synthesis 1
    set do_bitstream 1
    set do_compile 1
    set do_vitis_build 0
  # NAME*: WORKFLOW or W
  # DESCRIPTION: Runs the full workflow, creates the project if not existing.
  # OPTIONS: bitstream_only, check_syntax, ext_path.arg, impl_only, njobs.arg, no_bitstream, recreate, synth_only, verbose, vitis_only, xsa.arg
  }
 
  \^(CREATEWORKFLOW|CW)?$ {#
    set do_implementation 1
    set do_synthesis 1
    set do_bitstream 1
    set do_compile 1
    set recreate 1
    set do_vitis_build 0
  # NAME: CREATEWORKFLOW or CW
  # DESCRIPTION: Creates the project -even if existing- and launches the complete workflow.
  # OPTIONS: check_syntax, ext_path.arg, njobs.arg, no_bitstream, synth_only, verbose, vivado_only, vitis_only, xsa.arg
  }
 
  \^(CHECKSYNTAX|CS)?$ {#proj
    set do_check_syntax 1
  # NAME: CHECKSYNTAX or CS
  # DESCRIPTION: Check the syntax of the project. Only for Vivado, Quartus and Libero projects.
  # OPTIONS: ext_path.arg, recreate, verbose
  }
 
  ^(IPB(US)?)|(X(ML)?)$ {#proj
    set do_ipbus_xml 1
  # NAME: IPBUS or IPB
  # DESCRIPTION: Copy, check or create the IPbus XMLs for the project.
  # OPTIONS: dst_dir.arg, generate, verbose
  }
 
  \^V(IEW)?$ {#proj
    set do_list_file_parse 1
  # NAME*: VIEW or V
  # DESCRIPTION: Print Hog list file contents in a tree-like fashon.
  # OPTIONS: verbose
  }
 
  \^(CHECKYAML|YML)?$ {
    set min_n_of_args -1
    set max_n_of_args 1
    set do_check_yaml_ref 1
  # NAME: CHECKYML or YML
  # DESCRIPTION: Check that the ref to Hog repository in the .gitlab-ci.yml file, matches the one in Hog submodule.
  # OPTIONS: verbose
  }
 
  \^B(UTTONS)?$ {
    set min_n_of_args -1
    set max_n_of_args 1
    set do_buttons 1
  # NAME: BUTTONS or B
  # DESCRIPTION: Add Hog buttons to the Vivado GUI, to check and recreate Hog list and configuration files.
  # OPTIONS: verbose
  }
 
  \^(CHECKLIST|CL)?$ {#proj
    set do_check_list_files 1
  # NAME: CHECKLIST or CL
  # DESCRIPTION: Check that list and configuration files on disk match what is on the project.
  # OPTIONS: ext_path.arg, verbose
  }
 
  \^COMPSIM(LIB)?$ {
    set do_compile_lib 1
    set argument_is_no_project 1
  # NAME: COMPSIMLIB or COMPSIM
  # DESCRIPTION: Compiles the simulation library for the chosen simulator with Vivado.
  # OPTIONS: dst_dir.arg, verbose
  }
 
  \^RTL(ANALYSIS)?$ {#
    set do_rtl 1
  # NAME: RTL or RTLANALYSIS
  # DESCRIPTION: Elaborate the RTL analysis report for the chosen project.
  # OPTIONS: check_syntax, recreate, verbose
  }
 
  \^SIG(ASI)?$ {#
    set do_sigasi 1
  # NAME: SIGASI or SIG
  # DESCRIPTION: Create a .csv file to be used in Sigasi.
  # OPTIONS: verbose
  }
 
  \^T(REE)?$ {#
    set do_hierarchy 1
  # NAME: TREE or T
  # DESCRIPTION: Print the design hierarchy for the chosen project.
  # OPTIONS: compile_order, ext_path.arg, ignore.arg, include_gen_prods, include_ieee, light, output.arg, top.arg, verbose
  }
 
  default {
    if {$directive != ""} {
      set NO_DIRECTIVE_FOUND 1
    } else {
      puts "$usage"
      exit 0
    }
  }
}
 
# Add this bit above!
#  \^NEW_DIRECTIVE?$ {
#    set do_new_directive 1
#  }
 
 
#parsing command options
set parameters {
  {no_bitstream    "If set, the bitstream file will not be produced."}
  {recreate        "If set, the project will be re-created if it already exists."}
  {no_reset        "If set, runs (synthesis and implementation) won't be reset before launching them."}
  {check_syntax    "If set, the HDL syntax will be checked at the beginning of the workflow."}
  {njobs.arg 4     "Number of jobs. Default: 4"}
  {ext_path.arg "" "Sets the absolute path for the external libraries."}
  {lib.arg      "" "Simulation library path, compiled or to be compiled"}
  {synth_only      "If set, only the synthesis will be performed."}
  {impl_only       "If set, only the implementation will be performed. This assumes synthesis was already done."}
  {scripts_only    "If set, the simulation scripts will be generated, but the simulation will not be run."}
  {compile_only    "If set, the simulation libraries will be compiled, but not run."}
  {bitstream_only  "If set, only the bitstream will be produced. This assumes implementation was already done. For a Vivado-Vitis\
                    project this command can be used to generate the boot artifacts including the ELF file(s) without running the\
                    full Vivado workflow."}
  {vivado_only     "If set, and project is vivado-vitis, vitis project will not be created."}
  {vitis_only      "If set, and project is vivado-vitis create only vitis project. If an xsa is not given, a pre-synth xsa will be created."}
  {xsa.arg      "" "If set, and project is vivado-vitis, use this xsa for creating platforms without a defined hw."}
  {simset.arg   "" "Simulation sets, separated by commas, to be run."}
  {all             "List all projects, including test projects. Test projects have #test on the second line of hog.conf."}
  {generate        "For IPbus XMLs, it will re create the VHDL address decode files."}
  {dst_dir.arg  "" "For reports, IPbus XMLs, set the destination folder (default is in the ./bin folder)."}
  {output.arg   "" "For tree hierarchy mode, set the output file (default is console)."}
  {top.arg      "" "For tree hierarchy mode, set the top module (default is the top module defined in hog.conf)."}
  {ignore.arg   "" "For tree hierarchy mode, filter's the printed hierarchy to exclude modules that match the given string."}
  {include_ieee "" "For tree hierarchy mode, include IEEE/STD libraries in the printed hierarchy. (Default 0)"}
  {include_gen_prods "" "For tree hierarchy mode, include IP generated products in the printed hierarchy. (Default 0)"}
  {compile_order "" "For tree hierarchy mode, prints compile order instead of hierarchy."}
  {verbose         "If set, launch the script in verbose mode"}
  {light         "For tree hierarchy mode, print a light version of the hierarchy (without file paths)."}
}
 
set tcl_path [file normalize "[file dirname [info script]]"]
source $tcl_path/hog.tcl
source $tcl_path/create_project.tcl
 
# Quartus needs extra packages and treats the argv in a different way
if {[IsQuartus]} {
  load_package report
  set argv $quartus(args)
}
 
# Msg Debug "s: $::argv0 a: $argv"
 
### CUSTOM COMMANDS ###
set commands_path [file normalize "$tcl_path/../../hog-commands/"]
set custom_commands [GetCustomCommands $parameters $commands_path ]
 
lassign [InitLauncher $::argv0 $tcl_path $parameters $default_commands $argv $custom_commands] \
directive project project_name group_name repo_path old_path bin_dir top_path usage short_usage cmd ide list_of_options
 
array set options $list_of_options
 
if {$options(verbose) == 1} {
  setDebugMode 1
}
Msg Debug "Returned by InitLauncher: \n\
  - project: $project \n\
  - project_name $project_name \n\
  - group_name $group_name \n\
  - repo_path $repo_path \n\
  - old_path $old_path \n\
  - bin_dir $bin_dir \n\
  - top_path $top_path \n\
  - cmd $cmd"
 
set ext_path ""
if {$options(ext_path) != ""} {
  set ext_path $options(ext_path)
}
set simlib_path ""
 
 
 
# printDebugMode
# Msg Info "Number of jobs set to $options(njobs)."
set output_path ""
if {$options(output) != ""} {
  set output_path $options(output)
}
 
set light_hierarchy $options(light)
set ignored_hierarchy $options(ignore)
set top_module $options(top)
set compile_order $options(compile_order)
set include_ieee $options(include_ieee)
set include_gen_prods $options(include_gen_prods)
 
######## DEFAULTS #########
set do_rtl 0
set do_implementation 0; set do_synthesis 0; set do_bitstream 0
set do_create 0; set do_compile 0; set do_simulation 0; set recreate 0
set do_reset 1; set do_list_all 2; set do_check_syntax 0; set do_vitis_build 0;
set scripts_only 0; set compile_only 0
### Hog stand-alone directives ###
# The following directives are used WITHOUT ever calling the IDE, they are run in tclsh
# A place holder called new_directive can be followed to add new commands
 
set do_ipbus_xml 0
set do_list_file_parse 0
set do_check_yaml_ref 0
set do_buttons 0
set do_check_list_files 0
set do_compile_lib 0
set do_sigasi 0
set do_hierarchy 0
 
set NO_DIRECTIVE_FOUND 0
Msg Debug "Looking for a $directive in : $default_commands"
switch -regexp -- $directive $default_commands
 
if {$NO_DIRECTIVE_FOUND == 1} {
  Msg Debug "No directive found in default commands, looking in custom commands..."
  if {[string length $custom_commands] > 0 && [dict exists $custom_commands $directive]} {
    Msg Debug "Directive $directive found in custom commands."
    if {$cmd == "custom_tcl"} {
      eval [dict get $custom_commands $directive SCRIPT]
      exit
    } else {
      if {[IsTclsh]} {
        Msg Info "Launching command: $cmd..."
 
        # Check if the IDE is actually in the path...
        set ret [catch {exec which $ide}]
        if {$ret != 0} {
          Msg Error "$ide not found in your system. Make sure to add $ide to your PATH enviromental variable."
          exit $ret
        }
 
        if {[string first libero $cmd] >= 0} {
          # The SCRIPT_ARGS: flag of libero makes tcl crazy...
          # Let's pipe the command into a shell script and remove it later
          set libero_script [open "launch-libero-hog.sh" w]
          puts $libero_script "#!/bin/sh"
          puts $libero_script $cmd
          close $libero_script
          set cmd "sh launch-libero-hog.sh"
        }
 
        set ret [catch {exec -ignorestderr {*}$cmd >@ stdout} result]
 
        if {$ret != 0} {
          Msg Error "IDE returned an error state."
        } else {
          Msg Info "All done."
          exit 0
        }
 
        if {[string first libero $cmd] >= 0} {
          file delete "launch-libero-hog.sh"
        }
 
        exit $ret
      }
 
      eval [dict get $custom_commands $directive SCRIPT]
 
      set no_exit [dict get $custom_commands $directive NO_EXIT]
      if {$no_exit == 0} {
        exit
      }
    }
  } else {
      Msg Info "No directive found, pre ide exiting..."
      Msg Status "ERROR: Unknown directive $directive.\n\n"
      puts $usage
      exit
  }
}
 
if {$options(all) == 1} {
  set do_list_all 1
} else {
  set do_list_all 2
}
 
if {$options(dst_dir) == "" && ($do_ipbus_xml == 1 || $do_check_list_files == 1) && $project != ""} {
  # Getting all the versions and SHAs of the repository
  lassign [GetRepoVersions [file normalize $repo_path/Top/$group_name/$project] \
    $repo_path $ext_path] commit version hog_hash hog_ver top_hash top_ver libs hashes vers \
    cons_ver cons_hash ext_names ext_hashes xml_hash xml_ver user_ip_repos \
    user_ip_hashes user_ip_vers
  cd $repo_path
 
  set describe [GetHogDescribe $commit $repo_path]
  set dst_dir [file normalize "$repo_path/bin/$group_name/$project\-$describe"]
}
 
if {$cmd == -1} {
  #This is if the project was not found
  Msg Status "\n\nPossible projects are:"
  ListProjects $repo_path $do_list_all
  Msg Status "\n"
  exit 1
} elseif {$cmd == -2} {
  # Project not given but needed
  Msg Status "ERROR: You must specify a project with directive $directive."
  # \n\n[cmdline::usage $parameters $usage]"
  Msg Status "Possible projects are:"
  ListProjects $repo_path $do_list_all
  exit 1
} elseif {$cmd == 0} {
  #This script was launched within the IDE,: Vivado, Quartus, etc
  Msg Info "$::argv0 was launched from the IDE."
} else {
  # This script was launched with Tclsh, we need to check the arguments
  # and if everything is right launch the IDE on this script and return
 
 
 
 
  #### Directives to be handled in tclsh should be here ###
  ### IMPORTANT: Each if block should either end with "exit 0" or
  ### set both $ide and $cmd to be executed when this script is run again
 
  if {$do_ipbus_xml == 1} {
    Msg Info "Handling IPbus XMLs for $project_name..."
 
    set proj_dir $repo_path/Top/$project_name
 
    if {$options(generate) == 1} {
      set xml_gen 1
    } else {
      set xml_gen 0
    }
 
    if {$options(dst_dir) != ""} {
      set dst_dir $options(dst_dir)
    }
    set xml_dst "$dst_dir/xml"
 
 
    if {[llength [glob -nocomplain $proj_dir/list/*.ipb]] > 0} {
      if {![file exists $xml_dst]} {
        Msg Info "$xml_dst directory not found, creating it..."
        file mkdir $xml_dst
      }
    } else {
      Msg Error "No .ipb files found in $proj_dir/list/"
      exit
    }
 
    set ret [GetRepoVersions $proj_dir $repo_path ""]
    set sha [lindex $ret 13]
    set hex_ver [lindex $ret 14]
 
    set ver [HexVersionToString $hex_ver]
    CopyIPbusXMLs $proj_dir $repo_path $xml_dst $ver $sha 1 $xml_gen
 
    exit 0
  }
 
  if {$do_list_file_parse == 1} {
    set proj_dir $repo_path/Top/$project_name
    set proj_list_dir $repo_path/Top/$project_name/list
    GetHogFiles -print_log -list_files {.src,.con,.sim,.ext,.ipb} $proj_list_dir $repo_path
    Msg Status "  "
    Msg Info "All Done."
    exit 0
  }
 
  if {$do_hierarchy == 1} {
    source $tcl_path/utils/hierarchy.tcl
    set proj_dir $repo_path/Top/$project_name
    set proj_list_dir $repo_path/Top/$project_name/list
    lassign [GetHogFiles -ext_path $ext_path \
        -list_files ".src,.ext" $proj_list_dir $repo_path]\
        listLibraries listProperties listSrcSets
    Hierarchy $listProperties $listLibraries $repo_path $output_path $compile_order \
    $light_hierarchy $top_module $ignored_hierarchy $include_ieee $include_gen_prods
    exit 0
  }
  if {$do_sigasi == 1} {
    cd $repo_path
    Msg Info "Creating Sigasi CSV files for project $project_name..."
    set proj_dir $repo_path/Top/$project_name
    set proj_list_dir $repo_path/Top/$project_name/list
    set project [file tail $project_name]
    lassign [GetHogFiles -list_files {.src} $proj_list_dir $repo_path] libraries
    set csv_file [open "sigasi_$project.csv" w]
    foreach lib $libraries {
      set source_files [DictGet $libraries $lib]
      foreach source_file $source_files {
        if {[file extension $source_file] == ".vhd" ||
            [file extension $source_file] == ".vhdl" ||
            [file extension $source_file] == ".sv" ||
            [file extension $source_file] == ".v" } {
          puts $csv_file [ concat  [file rootname $lib] "," $source_file ]
        }
      }
    }
    close $csv_file
    Msg Info "Sigasi CSV file created: sigasi_$project.csv"
    Msg Info "You can use the python script provided by Sigasi to convert the generated csv file into a Sigasi project."
    Msg Info "More info at: https://www.sigasi.com/knowledge/how_tos/generating-sigasi-project-vivado-project/#2-generate-the-sigasi-project-files-from-the-csv-file"
    exit 0
  }
 
  if {$do_check_yaml_ref == 1} {
    Msg Info "Checking if \"ref\" in .gitlab-ci.yml actually matches the included yml file in Hog submodule"
    CheckYmlRef $repo_path false
    exit 0
  }
 
  if {$do_buttons == 1} {
    Msg Info "Adding Hog buttons to Vivado bar (will use the vivado currently in PATH)..."
    set ide vivado
    set cmd "vivado -mode batch -notrace -source $repo_path/Hog/Tcl/utils/add_hog_custom_button.tcl"
  }
 
  if {$do_compile_lib == 1} {
    if {$project eq ""} {
      Msg Error "You need to specify a simulator as first argument."
      exit 1
    } else {
      set simulator $project
      Msg Info "Selecting $simulator simulator..."
    }
    if {$options(dst_dir) != ""} {
      set output_dir $options(dst_dir)
    } else {
      Msg Info "No destination directory defined. Using default: SimulationLib/"
      set output_dir "SimulationLib"
    }
 
    set ide vivado
    set cmd "vivado -mode batch -notrace -source $repo_path/Hog/Tcl/utils/compile_simlib.tcl  -tclargs -simulator $simulator -output_dir $output_dir"
  }
 
  set simsets ""
  if {$do_simulation == 1} {
    # Get all simsets in the project that run with GHDL
    set ghdl_simsets [GetSimSets $project_name $repo_path "$options(simset)" 1]
    set ghdl_import 0
    dict for {simset_name simset_dict} $ghdl_simsets {
      if {$ghdl_import == 0} {
        ImportGHDL $project_name $repo_path $simset_name $simset_dict $ext_path
        set ghdl_import 1
      }
      LaunchGHDL $project_name $repo_path $simset_name $simset_dict $ext_path
      # dict unset simsets_dict $simset_name
    }
    set ide_simsets [GetSimSets $project_name $repo_path $options(simset) 0 1]
 
    if {[dict size $ide_simsets] == 0} {
      # All simulations have been run, exiting
      Msg Info "All simulations have been run, exiting..."
      exit 0
    }
  }
 
  # if {$do_new_directive ==1 } {
  #
  # # Do things here
  #
  # exit 0
  #}
 
  #### END of tclsh commands ####
  Msg Info "Launching command: $cmd..."
 
  # Check if the IDE is actually in the path...
  set ret [catch {exec which $ide}]
  if {$ret != 0} {
    Msg Error "$ide not found in your system. Make sure to add $ide to your PATH enviromental variable."
    exit $ret
  }
 
  if {[string first libero $cmd] >= 0} {
    # The SCRIPT_ARGS: flag of libero makes tcl crazy...
    # Let's pipe the command into a shell script and remove it later
    set libero_script [open "launch-libero-hog.sh" w]
    puts $libero_script "#!/bin/sh"
    puts $libero_script $cmd
    close $libero_script
    set cmd "sh launch-libero-hog.sh"
  }
 
  set ret [catch {exec -ignorestderr {*}$cmd >@ stdout} result]
 
  if {$ret != 0} {
    Msg Error "IDE returned an error state."
  } else {
    Msg Info "All done."
    exit 0
  }
 
  if {[string first libero $cmd] >= 0} {
    file delete "launch-libero-hog.sh"
  }
 
  exit $ret
}
 
#After this line, we are in the IDE
##################################################################################
 
 
# We need to Import tcllib if we are using Libero
if {[IsLibero] || [IsDiamond]} {
  if {[info exists env(HOG_TCLLIB_PATH)]} {
    lappend auto_path $env(HOG_TCLLIB_PATH)
  } else {
    puts "ERROR: To run Hog with Microsemi Libero SoC or Lattice Diamond,\
    you need to define the HOG_TCLLIB_PATH variable."
    return
  }
}
 
if {[catch {package require cmdline} ERROR] || [catch {package require struct::matrix} ERROR]} {
  puts "$ERROR\n Tcllib not found. If you are running this script on tclsh for debuggin purpose ONLY, you can fix this by installing 'tcllib'"
  exit 1
}
 
set run_folder [file normalize "$repo_path/Projects/$project_name/$project.runs/"]
if {[IsLibero]} {
  set run_folder [file normalize "$repo_path/Projects/$project_name/"]
}
 
# Only for quartus, not used otherwise
set project_path [file normalize "$repo_path/Projects/$project_name/"]
 
# Get IDE name from project config file
set proj_conf [ProjectExists $project_name $repo_path]
set ide_name_and_ver [string tolower [GetIDEFromConf $proj_conf]]
set ide_name [lindex [regexp -all -inline {\S+} $ide_name_and_ver] 0]
 
if {$options(no_bitstream) == 1} {
  set do_bitstream 0
  set do_compile 0
}
 
if {$options(recreate) == 1} {
  set recreate 1
}
 
if {$options(synth_only) == 1} {
  set do_implementation 0
  set do_synthesis 1
  set do_bitstream 0
  set do_create 1
  set do_compile 1
}
 
if {$options(impl_only) == 1} {
  set do_implementation 1
  set do_synthesis 0
  set do_bitstream 0
  set do_create 0
  set do_compile 1
}
 
 
if {$options(vitis_only) == 1 || $ide_name eq "vitis_classic"} {
  set do_vitis_build 1
  set do_implementation 0
  set do_synthesis 0
  set do_bitstream 0
  set do_create 0
  set do_compile 0
}
 
if {$options(bitstream_only) == 1} {
  set do_bitstream_only 1
  set do_bitstream 0
  set do_implementation 0
  set do_synthesis 0
  set do_create 0
  set do_compile 0
} else {
  set do_bitstream_only 0
}
 
if {$options(vivado_only) == 1} {
  set do_vitis_build 0
}
 
if {$options(no_reset) == 1} {
  set do_reset 0
}
 
if {$options(check_syntax) == 1} {
  set do_check_syntax 1
}
 
if {$options(scripts_only) == 1} {
  set scripts_only 1
}
 
if {$options(compile_only) == 1} {
  set compile_only 1
}
 
 
 
if {$options(lib) != ""} {
  set lib_path [file normalize $options(lib)]
} else {
  if {[info exists env(HOG_SIMULATION_LIB_PATH)]} {
    set lib_path $env(HOG_SIMULATION_LIB_PATH)
  } else {
    if {[file exists "$repo_path/SimulationLib"]} {
      set lib_path [file normalize "$repo_path/SimulationLib"]
    } else {
      set lib_path ""
    }
  }
}
 
 
Msg Info "Number of jobs set to $options(njobs)."
 
############## Quartus ########################
set argv ""
 
############# CREATE or OPEN project ############
if {[IsISE]} {
  cd $tcl_path
  set project_file [file normalize $repo_path/Projects/$project_name/$project.ppr]
} elseif {[IsVivado]} {
  cd $tcl_path
  set project_file [file normalize $repo_path/Projects/$project_name/$project.xpr]
} elseif {[IsVitisClassic]} {
  cd $tcl_path
  set project_file [file normalize $repo_path/Projects/$project_name/vitis_classic/.metadata/]
  Msg Info "Setting project file for Vitis Classic project $project_name to $project_file"
} elseif {[IsQuartus]} {
  if {[catch {package require ::quartus::project} ERROR]} {
    Msg Error "$ERROR\n Can not find package ::quartus::project"
    cd $old_path
    return 1
  } else {
    Msg Info "Loaded package ::quartus::project"
    load_package flow
  }
  set project_file "$project_path/$project.qpf"
} elseif {[IsLibero]} {
  set project_file [file normalize $repo_path/Projects/$project_name/$project.prjx]
} elseif {[IsDiamond]} {
  sys_install version
  set project_file [file normalize $repo_path/Projects/$project_name/$project.ldf]
}
 
if {[file exists $project_file]} {
  Msg Info "Found project file $project_file for $project_name."
  set proj_found 1
} else {
  Msg Info "Project file not found for $project_name."
  set proj_found 0
}
 
if {($proj_found == 0 || $recreate == 1)} {
  Msg Info "Creating (possibly replacing) the project $project_name..."
  Msg Debug "launch.tcl: calling GetConfFiles with $repo_path/Top/$project_name"
  lassign [GetConfFiles $repo_path/Top/$project_name] conf sim pre post
 
  if {[file exists $conf]} {
    # Still not sure of the difference between project and project_name
    if {$options(vivado_only) == 1} {
      CreateProject -simlib_path $lib_path -xsa $options(xsa) -vivado_only $project_name $repo_path
    } else {
      CreateProject -simlib_path $lib_path -xsa $options(xsa) $project_name $repo_path
    }
    Msg Info "Done creating project $project_name."
  } else {
    Msg Error "Project $project_name is incomplete: no hog.conf file found, please create one..."
  }
} else {
  Msg Info "Opening existing project file $project_file..."
  if {[IsXilinx]} {
    file mkdir "$repo_path/Projects/$project_name/$project.gen/sources_1"
  }
 
  if {[IsVitisClassic]} {
    set vitis_workspace [file normalize $repo_path/Projects/$project_name/vitis_classic/]
    Msg Info "Setting workspace to $vitis_workspace"
    setws $vitis_workspace
 
  } else {
    OpenProject $project_file $repo_path
  }
}
 
 
########## CHECK SYNTAX ###########
if {$do_check_syntax == 1} {
  Msg Info "Checking syntax for project $project_name..."
  CheckSyntax $project_name $repo_path $project_file
}
 
 
######### RTL ANALYSIS ########
if {$do_rtl == 1} {
  LaunchRTLAnalysis
}
 
if {$do_vitis_build == 1} {
  if {[IsVitisClassic]} {
    LaunchVitisBuild $project_name $repo_path
  } else {
    set xsct_cmd "xsct $tcl_path/launch.tcl W -vitis_only $project_name"
    set ret [catch {exec -ignorestderr {*}$xsct_cmd >@ stdout} result]
    if {$ret != 0} {
      Msg Error "xsct (vitis classic) returned an error state."
    }
  }
}
 
######### LaunchSynthesis ########
if {$do_synthesis == 1} {
  LaunchSynthesis $do_reset $do_create $run_folder $project_name $repo_path $ext_path $options(njobs)
}
 
if {$do_implementation == 1} {
  LaunchImplementation $do_reset $do_create $run_folder $project_name $repo_path $options(njobs) $do_bitstream
}
 
if {$do_bitstream_only == 1 && [IsXilinx]} {
  GenerateBitstreamOnly $project_name $repo_path
} elseif {$do_bitstream_only == 1 && ![IsXilinx]} {
  Msg Error "Bitstream only option is not supported for this IDE."
}
 
if {$do_bitstream == 1 && ![IsXilinx]} {
  GenerateBitstream $run_folder $repo_path $options(njobs)
}
 
if {$do_simulation == 1} {
  # set simsets $options(simset)
  set simsets [GetSimSets $project_name $repo_path $options(simset)]
  LaunchSimulation $project_name $lib_path $simsets $repo_path $scripts_only $compile_only
}
 
 
if {$do_check_list_files} {
  Msg Info "Running list file checker..."
 
  #if {![file exists $dst_dir]} {
  #   Msg Info "$dst_dir directory not found, creating it..."
  #   file mkdir $dst_dir
  # }
 
 
  set argv0 check_list_files
  if {$ext_path ne ""} {
    set argv [list "-ext_path" "$ext_path" "-outDir" "$dst_dir" "-pedantic"]
  } else {
    set argv [list "-outDir" "$dst_dir" "-pedantic"]
  }
 
  source $tcl_path/utils/check_list_files.tcl
}
## CLOSE Project
CloseProject
 
Msg Info "All done."
cd $old_path