#---------------------------------------------------------
#
# CMT module
#
# Parsing of a tree of requirements files
# - construct CMTPATH from the project graph (starts from CMTPROJECTPATH)
# - interprets & follows the use statements to reach used packages
# - parses CMT statements in requirements files
# - translate 'library' & 'application' statements into 'add_library' & 'add_executable' calls
# - translate 'macro' statements into global properties
#
# Build policy:
# - binary files are constructed into the 'installarea' directory of each project
# - thus build actions are restricted to packages of a single project
# - libraries of used projects are used pre-built from the respective installareas 
#
# System properties to hold the CMT database:
#
#   CMTPROJECTPATH
#   CMTPATH
#
#   CMT_CURRENT_PROJECT
#   CMT_CURRENT_PATH
#   CMT_PROJECTS
#   _CMT_<project>_PROJECT_PROPERTIES
#   CMT_STRUCTURE_STRATEGY
#
#   CMT_USES
#   _CMT_<name>_USE_PROPERTIES
#   _CMT_<name>_USE_CLIENTS
#
#   CMT_SYMBOLS
#   CMT_MACROS
#   CMT_SETS
#   CMT_ALIAS
#   CMT_PATHS
#   CMT_ACTIONS
#   _CMT_<name>
#   _CMT_<name>[<tag>]
#   _CMT_<name>_SYMBOL_PROPERTIES
#   _CMT_<name>_TAGGED_VALUES
#   _CMT_<m>_<name>                     m=A(append)|P(prepend)|R(remove)
#   _CMT_<m>_<name>[<tag>]
#   _CMT_<m>_<name>_SYMBOL_PROPERTIES
#   _CMT_<m>_<name>_TAGGED_VALUES
#
#   CMT_PATTERNS
#   CMT_GLOBAL_PATTERNS
#   CMT_CMTPATH_PATTERNS
#   _CMT_<name>_PATTERN_DEFINITION
#
#   CMT_TAGS
#   CMT_ACTIVE_TAGS
#   _CMT_<tag>_TAG_PARENTS
#   _CMT_<tag>_TAG_CLIENTS
#
#   CMT_CMAKE_MODULES
#
#---------------------------------------------------------

#---------------------------------------------------------
# Utility to print a list
#
macro(dumplist)
  foreach(w IN LISTS words)
    message("DL> ${w}")
  endforeach()
endmacro()

macro(getword item var)
  list(GET words ${item} ${var})
endmacro()

macro(nwords var)
  list(LENGTH words ${var})
  math(EXPR ${var} "${${var}} - 1")
endmacro()

#---------------------------------------------------------
# Utility to print the result of a parsing of a CMT statement
# Each word of a line has been stored into a set of variables named w_<k> k=1..n
# Words are either simple words separated by spaces or groups of words enclosed in quotes
#
macro(show_cmt_line text)
  if(${n} GREATER 0)
    foreach(k RANGE 1 ${n})
      set(x "w_${k}")
      message("${text}> w_${k}: [${${x}}]")
    endforeach()
  endif()
endmacro()

#---------------------------------------------------------
function(cmt_append_unique_property property_name value)
  get_property(property GLOBAL PROPERTY "${property_name}")
  list(FIND property "${value}" index)
  #message("cmt_append_unique_property> property_name=${property_name} value=${value} index=${index}")
  if("${index}" EQUAL "-1")
    set_property(GLOBAL APPEND PROPERTY "${property_name}" "${value}")
  endif()
endfunction()

#---------------------------------------------------------
function(cmt_find_project_from_path path result)
  string(REGEX REPLACE "/[ ]*$" "" path "${path}")
  string(REGEX REPLACE "[^/]*[/]" "" project "${path}")
  set(${result} "${project}" PARENT_SCOPE)
endfunction()

#---------------------------------------------------------
function(cmt_modify_symbol_value type name value modifier result)
  get_property(old_value GLOBAL PROPERTY "${name}")

  string(REGEX REPLACE "^['][']$" "" value "${value}")
  string(REGEX REPLACE "^[\"][\"]$" "" value "${value}")

  set(arg "${value}")

  set(path_mode FALSE)

  set(separator "")

  if(("${type}" STREQUAL "${path}") AND (NOT("${value}" STREQUAL "")))
    set(path_mode TRUE)
    set(separator ":")
  endif()


  if("${modifier}" STREQUAL "D")
  elseif("${modifier}" STREQUAL "A")
    set(value "${old_value}${separator}${value}")
  elseif("${modifier}" STREQUAL "P")
    set(value "${value}${separator}${old_value}")
  elseif("${modifier}" STREQUAL "R")
    if(${path_mode})
      string(REGEX REPLACE "^[^${separator}]*${arg}[^${separator}]*$" "" value "${old_value}")
      string(REGEX REPLACE "^[^${separator}]*${arg}[^${separator}]*${separator}" "" value "${value}")
      string(REGEX REPLACE "${separator}[^${separator}]*${arg}[^${separator}]*$" "" value "${value}")
      string(REGEX REPLACE "${separator}[^${separator}]*${arg}[^${separator}]*${separator}" "${separator}" value "${value}")
    else()
      string(REPLACE "${value}" "" value "${old_value}")
    endif()
  endif()

  set_property(GLOBAL PROPERTY "${name}" "${value}")

  get_property(tab GLOBAL PROPERTY TAB)
  #message("${tab}cmt_modify_symbol_value> name=${name} [${old_value}] ${modifier} [${arg}] => [${value}]")
 
  set(${result} "${value}" PARENT_SCOPE)
endfunction()

#-------------------------------------------
# Interprets any 'symbol' statement
# Translate the symbol into a global property
#
function(cmt_symbol type project path package version prefix line modifier)
  get_property(tab GLOBAL PROPERTY TAB)
  message("${tab}cmt_symbol> ${line}")
  #show_cmt_line("a")

  nwords(n)

  if(${n} LESS 2)
    return()
  endif()

  getword(1 name)

  message("${tab}cmt_symbol> ${type} ${name} ${n}")

  if(${n} LESS 2)
    return()
  endif()

  getword(2 default_value)

  cmt_append_unique_property(CMT_SYMBOLS "${name}")

  if("${type}" STREQUAL "macro")
    cmt_append_unique_property("CMT_MACROS" "${name}")
  elseif("${type}" STREQUAL "set")
    cmt_append_unique_property("CMT_SETS" "${name}")
  elseif("${type}" STREQUAL "path")
    cmt_append_unique_property("CMT_PATHS" "${name}")
  elseif("${type}" STREQUAL "action")
    cmt_append_unique_property("CMT_ACTIONS" "${name}")
  elseif("${type}" STREQUAL "alias")
    cmt_append_unique_property("CMT_ALIAS" "${name}")
  endif()

  cmt_modify_symbol_value("${type}" "_CMT_${name}" "${default_value}" "${modifier}" new_value)

  message("${tab}cmt_symbol> [${modifier}] Default value=[${default_value}] -> [${new_value}]")

  set_property(GLOBAL PROPERTY "_CMT_${name}_SYMBOL_PROPERTIES" "${path};${package}")

  if(${n} LESS 5)
    return()
  endif()

  math(EXPR tagged_values "(${n} - 2) / 2")

  foreach(k RANGE 1 ${tagged_values})
    math(EXPR itag "${k}*2 + 1")
    math(EXPR ivalue "${k}*2 + 2")
    if(${n} GREATER ${itag})
      getword(itag tag)
      getword(ivalue value)
      cmt_append_unique_property("_CMT_${name}_TAGGED_VALUES" "${tag}")

      cmt_modify_symbol_value("${type}" "_CMT_${name}[${tag}]" "${value}" "${modifier}" new_value)

      #message("${tab}cmt_symbol> [${modifier}] Tagged value for ${tag}=[${value}] -> [${new_value}]")

    endif()
  endforeach()

endfunction()

#-------------------------------------------
# Expand a macro by recursively expand macro references
#
function(cmt_get_macro_value name value)
  set(v "$ENV{${name}}")
  #message("cmt_get_macro_value> name=${name} env=${v}")

  if("${v}" STREQUAL "")
    # This is not an environment variable
    cmt_select_macro_value("${name}" v)
    #get_property(v GLOBAL PROPERTY "_CMT_${name}")
    #message("cmt_get_macro_value> name=${name} v=${v}")
    # Loop over occurrences of macro references inside ${v}
    while(TRUE)
      if("${v}" MATCHES "[$][(][^]]*[)]")
        string(REGEX REPLACE "[^$]*[$][(]([^)]*)[)].*" "\\1" ref "${v}")
        #message("macro=${name} v=${v} has a reference to ${ref}")

        cmt_get_macro_value(${ref} refvalue)

        string(REGEX REPLACE "[$][(]${ref}[)]" "${refvalue}" v "${v}")
      else()
        break()
      endif()
    endwhile()
  endif()

  if("${v}" MATCHES "^[\"].*[\"]$")
    string(REGEX REPLACE "^[\"](.*)[\"]$" "\\1" v "${v}")
  elseif("${v}" MATCHES "^['].*[']$")
    string(REGEX REPLACE "^['](.*)[']$" "\\1" v "${v}")
  endif()

  set(${value} "${v}" PARENT_SCOPE)

endfunction()

#-------------------------------------------
# Interprets a 'library' statement
# Translate the library statement into a 'add_library' statement
# differentiate the behaviour whether the project of this package is same as CMT_CURRENT_PROJECT
#
function(cmt_library project path package version prefix words)
  #message("cmt_library> cmt(${package})> ${words}")
  nwords(n)

  get_property(current_project GLOBAL PROPERTY CMT_CURRENT_PROJECT)
  message("cmt_library> current_project=${current_project} project=${project} path=${path} package=${package} ${words}")

  if("${project}" STREQUAL "${current_project}")
    #message("cmt_library> in current project")

    include_directories(${path}/${prefix}${package}${version}/src)

    foreach(k RANGE 2 ${n})
      getword(${k} word)
      #message("cmt_library> sources=[${path}]/${prefix}${package}${version}/src/${word}")

      unset(fs)
      file(GLOB fs "${path}/${prefix}${package}${version}/src/${word}")

      foreach(f IN LISTS fs)
        message("cmt_library> source=${f}")
        list(APPEND sources ${f})
      endforeach()
    endforeach()

    getword(1 name)

    message(">>>>>add_library(${name} SHARED ${sources})")
    add_library(${name} SHARED ${sources})
  else()
    #message("cmt_library> out of current project")
  endif()

  cmt_has_macro("${name}_linkopts" ok)
  if(ok)
    cmt_select_macro_value("${name}_linkopts" value)
    string(REPLACE " " ";" values "${value}")
    message(">>>>>target_link_libraries(${name} ${values})")
    target_link_libraries(${name} ${values})
  else()
    #message("cmt_application> no linkopts")
  endif()

endfunction()

#-------------------------------------------
# Interprets a 'application' statement
# Translate the 'application' statement into a 'add_executable' statement
#
function(cmt_application project path package version prefix words)
  message("cmt_application> cmt(${package})> ${words}")
  nwords(n)

  message(">>>>>include_directories(${path}/${prefix}${package}${version}/src)")
  include_directories(${path}/${prefix}${package}${version}/src)

  unset(sources)

  foreach(k RANGE 2 ${n})
    getword(${k} word)
    #message("cmt_application> sources=${path}/${prefix}${package}${version}/src/${word}")

    unset(fs)
    file(GLOB fs "${path}/${prefix}${package}${version}/src/${word}")

    foreach(f IN LISTS fs)
      #message("cmt_application> source=${f}")
      list(APPEND sources ${f})
    endforeach()
  endforeach()

  if("${sources}" STREQUAL "")
    #message("Sources not yet available")
    return()
  endif()

  getword(1 name)

  message(">>>>>add_executable(${name} ${sources})")
  add_executable(${name} ${sources})

  cmt_has_macro("${name}_linkopts" ok)
  if(ok)
    cmt_select_macro_value("${name}_linkopts" value)
    string(REPLACE " " ";" values "${value}")
    message(">>>>>target_link_libraries(${name} ${values})")
    target_link_libraries(${name} ${values})
  else()
    #message("cmt_application> no linkopts")
  endif()

endfunction()

#-------------------------------------------
# Interprets a 'document' statement
# Translate the 'document' statement
#
function(cmt_document project path package version prefix words)
  #message("cmt_document> cmt(${package})> ${words}")

  getword(1 module)
  getword(2 target)

  #get_property(command GLOBAL PROPERTY "_CMT_${module}_MODULE_PROPERTIES")

  list(REMOVE_AT words 0 1 2)

  cmt_do("${module}" "${target}" ${words})

endfunction()

function(cmt_custom_build project path package version prefix words)
  message("cmt_custom_build> cmt(${package})> ${words}")

  getword(1 name)

  message("include ${path}/${prefix}/${package}/${version}/cmt/${name}.cmake")
  include("${path}/${prefix}/${package}/${version}/cmt/${name}.cmake")

  cmt_append_unique_property(CMT_MODULES "${name}")
  #set_property(GLOBAL PROPERTY "_CMT_${name}_MODULE_PROPERTIES" "${command}")

endfunction()


#-------------------------------------------
# Interprets a 'tag' statement
# Define a tag and all its parents
#
# the statement
#    tag T t1 t2
#    tag V t1 t3
#
# means that when T is ON, both t1 & t2 are ON, while when V is ON, both t1 & t3
# T & V are parents of t1
# T is parent of t2
# V is parent of t3
# thus, in order to know the state of t1, we interrogate all its parents (recursively)
#
function(cmt_tag project path package version prefix words)
  #message("cmt_tag> ${words}")

  nwords(n)
  foreach(k RANGE 1 ${n})
    getword(${k} p)

    # first defines the tag #k
    cmt_append_unique_property(CMT_TAGS "${p}")

    if(${k} EQUAL 1)
      set(tag ${p}) 
    else()
      # the first tag of the line is parent of all others 
      cmt_append_unique_property("_CMT_${p}_TAG_PARENTS" "${tag}")
      cmt_append_unique_property("_CMT_${tag}_TAG_CLIENTS" "${p}")
    endif()

  endforeach()
endfunction()

#---------------------------------------------------------
function(cmt_apply_tag project path package version prefix words)
  #message("cmt_apply_tag> ${words}")

  getword(1 tag)
  cmt_activate_tag("${tag}")
endfunction()

#----------------------------------------------
# expected syntax:
#
#    pattern|cmtpath_pattern [-global] <name> <words> [ ; <words> ]
#
function(cmt_pattern project path package version prefix words type)

  #message("cmt_pattern> [${words}]")

  getword(1 pattern)

  if("${type}" STREQUAL "cmtpath")
    cmt_append_unique_property(CMT_CMTPATH_PATTERNS "${pattern}")
  endif()

  list(REMOVE_AT words 0)

  if("${pattern}" STREQUAL "-global")
    list(REMOVE_AT words 0)
    getword(0 pattern)

    cmt_append_unique_property(CMT_GLOBAL_PATTERNS "${pattern}")
  endif()

  cmt_append_unique_property(CMT_PATTERNS "${pattern}")

  set_property(GLOBAL PROPERTY "_CMT_${pattern}_PATTERN_DEFINITION" "")

  list(REMOVE_AT words 0)

  nwords(n)

  if(n GREATER 0)
    set(ws)
    foreach(k RANGE 0 ${n})
      #message("cmt_pattern> n=${n} k=${k}")
      getword(${k} word)
      if("${word}" STREQUAL "@eol@")
        set_property(GLOBAL APPEND PROPERTY "_CMT_${pattern}_PATTERN_DEFINITION" "${ws}")
        set(ws)
      else()
        if(word MATCHES " ")
          set(ws "${ws} '${word}'")
        else()
          set(ws "${ws} ${word}")
        endif()
      endif()
    endforeach()

    list(LENGTH ws len)
    if(NOT(len EQUAL 0))
      set_property(GLOBAL APPEND PROPERTY "_CMT_${pattern}_PATTERN_DEFINITION" "${ws}")
    endif()
  else()
    set_property(GLOBAL APPEND PROPERTY "_CMT_${pattern}_PATTERN_DEFINITION" "")
  endif()

endfunction()

#---------------------------------------------------------
function(cmt_apply_pattern project path package version prefix words)
  get_property(tab GLOBAL PROPERTY TAB)
  #message("${tab}cmt_apply_pattern> ${words}")

  getword(1 pattern)
  list(REMOVE_AT words 0 1)

  unset(templates)
  unset(values)

  list(APPEND templates "project")
  list(APPEND values "${project}")

  list(APPEND templates "path")
  list(APPEND values "${path}")

  list(APPEND templates "package")
  list(APPEND values "${package}")

  list(APPEND templates "version")
  list(APPEND values "${version}")

  list(APPEND templates "prefix")
  list(APPEND values "${prefix}")

  nwords(n)

  if(n GREATER 0)
    foreach(k RANGE 0 ${n})
      #message("${tab}cmt_apply_pattern> n=${n} k=${k}")
      getword(${k} arg)

      # all arguments are of the form <template>=<value>
      if("${arg}" MATCHES "[^=]*[=]")
        string(FIND "${arg}" "=" index)
        string(SUBSTRING "${arg}" 0 "${index}" name)
        math(EXPR index "${index} + 1")
        string(SUBSTRING "${arg}" "${index}" "-1" value)
        string(REGEX REPLACE "^[\"](.*)[\"]$" "\\1" value "${value}")
        #message("${tab}cmt_apply_pattern> name=[${name}] value=[${value}]")
        list(APPEND templates "${name}")
        list(APPEND values "${value}")
      endif()
    endforeach()
  endif()

  get_property(lines GLOBAL PROPERTY "_CMT_${pattern}_PATTERN_DEFINITION")
  #message("${tab}cmt_apply_pattern> plines=[${lines}]")

  set(old_tab "${tab}") 
  set(tab "${tab}__")
  set_property(GLOBAL PROPERTY TAB "${tab}")

  foreach(pline IN LISTS lines)

    while(TRUE)
      #message("${tab}look for templates in ${pline}")
      if("${pline}" MATCHES "[<][^>]*[>]")
        string(REGEX REPLACE "^.*[<]([^>]*)[>].*$" "\\1" name "${pline}")
        list(FIND templates "${name}" index)
        #message("${tab}template ${name} found at index=${index}")
        if("${index}" GREATER "-1")
          list(GET values "${index}" value)
          #message("${tab}template value ${value} for ${name}")
          string(REGEX REPLACE "[<]${name}[>]" "${value}" pline "${pline}")
        else()
          string(REGEX REPLACE "[<]${name}[>]" "" pline "${pline}")
        endif()
      else()
        break()
      endif()
    endwhile()

    #message("${tab}pline=[${pline}]")
    cmt_read_line("${project}" "${path}" "${package}" "${version}" "${prefix}" "${pline}")
  endforeach()

  set_property(GLOBAL PROPERTY TAB "${old_tab}")

endfunction()

#---------------------------------------------------------
function(cmt_read_line project path package version prefix words)
  message("cmt_read_line> words=[${words}]")

  getword(0 keyword)

  message("cmt_read_line> keyword=[${keyword}] project=${project} path=${path} package=${package} version=${version} prefix=${prefix}")

  if(${keyword} STREQUAL "use")
    cmt_use("${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}")

  elseif(${keyword} STREQUAL "macro")
    cmt_symbol(macro "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" D)
  elseif(${keyword} STREQUAL "set")
    cmt_symbol(set "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" D)
  elseif(${keyword} STREQUAL "path")
    cmt_symbol(path "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" D)
  elseif(${keyword} STREQUAL "action")
    cmt_symbol(action "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" D)
  elseif(${keyword} STREQUAL "alias")
    cmt_symbol(alias "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" D)

  elseif(${keyword} STREQUAL "macro_append")
    cmt_symbol(macro "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" A)
  elseif(${keyword} STREQUAL "set_append")
    cmt_symbol(set "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" A)
  elseif(${keyword} STREQUAL "path_append")
    cmt_symbol(path "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" A)
  elseif(${keyword} STREQUAL "action_append")
    cmt_symbol(action "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" A)
  elseif(${keyword} STREQUAL "alias_append")
    cmt_symbol(alias "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" A)

  elseif(${keyword} STREQUAL "macro_prepend")
    cmt_symbol(macro "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" P)
  elseif(${keyword} STREQUAL "set_prepend")
    cmt_symbol(set "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" P)
  elseif(${keyword} STREQUAL "path_prepend")
    cmt_symbol(path "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" P)
  elseif(${keyword} STREQUAL "action_prepend")
    cmt_symbol(action "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" P)
  elseif(${keyword} STREQUAL "alias_prepend")
    cmt_symbol(alias "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" P)

  elseif(${keyword} STREQUAL "macro_remove")
    cmt_symbol(macro "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" R)
  elseif(${keyword} STREQUAL "set_remove")
    cmt_symbol(set "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" R)
  elseif(${keyword} STREQUAL "path_remove")
    cmt_symbol(path "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" R)
  elseif(${keyword} STREQUAL "action_remove")
    cmt_symbol(action "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" R)
  elseif(${keyword} STREQUAL "alias_remove")
    cmt_symbol(alias "${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" R)


  elseif(${keyword} STREQUAL "library")
    cmt_library("${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}")
  elseif(${keyword} STREQUAL "application")
    cmt_application("${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}")
  elseif(${keyword} STREQUAL "program")
    cmt_application("${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}")
  elseif(${keyword} STREQUAL "document")
    cmt_document("${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}")
  elseif(${keyword} STREQUAL "tag")
    cmt_tag("${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}")
  elseif(${keyword} STREQUAL "apply_tag")
    cmt_apply_tag("${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}")
  elseif(${keyword} STREQUAL "pattern")
    cmt_pattern("${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" "")
  elseif(${keyword} STREQUAL "cmtpath_pattern")
    cmt_pattern("${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}" "cmtpath")
  elseif(${keyword} STREQUAL "apply_pattern")
    cmt_apply_pattern("${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}")

  elseif(${keyword} STREQUAL "custom_build")
    cmt_custom_build("${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}")

  endif()

endfunction()

#-------------------------------------------
# Read a file using a python script
# to pre-format the lines:
#   - suppress comments
#   - separate words by __CMTWORD__
#      ('words' are single words or groups of words enclosed in quotes)
#
function(cmt_read_file file result)
  message("cmt_read_file> $ENV{PYTHON} ${file}")
  execute_process(COMMAND $ENV{PYTHON} $ENV{CMTROOT}/cmake/cmt_read.py ${file} OUTPUT_VARIABLE lines)
  string(REGEX REPLACE "[\n]" ";" lines "${lines}")
  set(${result} ${lines} PARENT_SCOPE)
  message ("[${lines}]")
endfunction()

#-------------------------------------------
# Read a requirements file
# - Recurse into the graph of used packages
# - Interpret the statements & translate CMT statements into CMake actions
# 
function(cmt_read_requirements project path package version prefix requirements)

  message("cmt_read_requirements> project=${project} requirements=${requirements}")

  cmt_read_file(${requirements} lines)

  # Installation of header files into the installarea
  # (this will eventually relies on the possible 'include_dirs' declaration)
  # temporary implementation: we assume this policy by default
  #    include_dirs ../src

  unset(headers)
  file(GLOB headers "${path}/${prefix}${version}${package}/*/*.h")
  #message("cmt_read_requirements> Headers found in ${headers}")
  foreach(f IN LISTS headers)
    string(REPLACE "${path}/${prefix}${version}${package}/" "" name "${f}")
    #message("cmt_read_requirements> header=${f}")
    configure_file(${f} "${path}/installarea/${name}" COPYONLY)  
  endforeach()
  
  #message("cmt_read_requirements> Before loop on lines path=${path}")

  foreach(line IN LISTS lines)

    #message("cmt_read_requirements> [${line}] package_path=${prefix}/${version}/${package}")
    if(NOT(line STREQUAL ""))
      string(REPLACE "__CMTWORD____CMTWORD__" "__CMTWORD__''__CMTWORD__" line "${line}")
      string(REGEX REPLACE "__CMTWORD__$" "__CMTWORD__''" line "${line}")
      string(REPLACE __CMTWORD__ ";" words "${line}")

      cmt_read_line("${project}" "${path}" "${package}" "${version}" "${prefix}" "${words}")
    endif()

  endforeach()
  #message("-----------")

endfunction()

#-------------------------------------------
# Expand macro references in a text
#
function(cmt_expand text result)

  set(${result} "${text}" PARENT_SCOPE)

  if(${text} MATCHES "[$][{][^}]*[}]$")
    string(REGEX REPLACE "^[$][{]([^}]*)[}]$" "(\\1)" text "${text}")
  endif()

  # Loop over occurrences of macro references inside ${v}
  while(TRUE)
    if("${text}" MATCHES "[$][(][^]]*[)]")
      string(REGEX REPLACE "[^$]*[$][(]([^)]*)[)].*" "\\1" ref "${text}")
      #message("text[${text}] text=${text} has a reference to ${ref}")

      cmt_get_macro_value(${ref} refvalue)

      string(REGEX REPLACE "[$][(]${ref}[)]" "${refvalue}" text "${text}")
    else()
      break()
    endif()
  endwhile()

  set(${result} "${text}" PARENT_SCOPE)

endfunction()


#-------------------------------------------
# Parse an individual line containing a use statements
#
# Find the references packaged from CMTPATH property
# Recurse into used package (remove duplicate calls by storing visited packages in the 'cmtuses' property
# Finally, parse the requirements file
# 
function(cmt_use pproject ppath ppackage pversion pprefix words)

  #message("cmt_use> words=[${words}]")

  # we start by expanding macros
  while(TRUE)
    set(done TRUE)
    nwords(n)
    #message("cmt_use> len=${n}")
    foreach(k RANGE 0 ${n})
      #message("cmt_use> k=${k}")
      getword(${k} word)
      cmt_expand("${word}" result)
      #message("cmt_use> ${word} expanded to ${result}")
      if(NOT("${result}" STREQUAL "${word}"))
        list(REMOVE_AT words ${k})
        if(${k} EQUAL ${len})
          list(APPEND words "${result}")
        else()
          list(INSERT words ${k} "${result}")
        endif()
        #message("cmt_use> after expansion ${words}")
        set(done FALSE)
        break()
      endif()
    endforeach()
    if(${done})
      break()
    endif()
  endwhile()

  #separate_arguments(words)

  nwords(n)
  getword(1 package)
  set(tprefix 1)
  set(nprefix 2)

  # consider the structure strategy so as to construct path with or without version 
  get_property(cmt_structure_strategy GLOBAL PROPERTY "CMT_STRUCTURE_STRATEGY")
  if("${cmt_structure_strategy}" STREQUAL "WITH_VERSION_DIRECTORY")
    if(${n} GREATER 2)
      getword(2 version)
      set(tprefix 2)
      set(nprefix 3)
    else()
      set(version)
    endif()

    if("${version}" STREQUAL "*")
      set(version)
    endif()

    if(NOT("${version}" STREQUAL ""))
      set(version "/${version}")
    endif()
  else()
    set(version)
  endif()

  set(prefix)

  if("${n}" GREATER "${tprefix}")
    getword("${nprefix}" word)
    if(NOT("${word}" STREQUAL "-no_auto_imports"))
      set(prefix "${word}")
    endif()
  endif()

  if(NOT("${prefix}" STREQUAL ""))
    set(prefix "${prefix}/")
  endif()

  message("cmt_use> project=${pproject} package=${package} version=${version} prefix=${prefix}")

  get_property(CMTPATH GLOBAL PROPERTY CMTPATH)

  unset(path)

  # search package using CMTPATH
  foreach(p IN LISTS CMTPATH)
    set(req "req${package}${version}")
 
    unset("${req}")

    find_file("${req}" requirements "${p}/${prefix}${package}${version}/cmt" NO_DEFAULT_PATH)

    set(reqfile "${${req}}")

    #message("cmt_use> Look for requirements file in ${p}/${prefix}${package}${version}/cmt -> req=[${reqfile}]")

    if("${reqfile}" MATCHES "NOTFOUND")
      #message("cmt_use>1 requirements not found in ${p}/${prefix}${package}${version}/cmt")
    elseif("${reqfile}" EQUAL "")
      #message("cmt_use>2 requirements not found in ${p}/${prefix}${package}${version}/cmt")
    else()
      string(REPLACE "/${prefix}${package}${version}/cmt/requirements" "" path ${reqfile})
      #message("REPLACE [/${prefix}${package}${version}/cmt/requirements] from ${reqfile} -> ${path}")
      break()
    endif()

  endforeach()

  if("${path}" STREQUAL "")
    #message("cmt_use> requirements files not found")
    return()
  endif()

  #message("cmt_use> requirements found in ${path}")

  get_property(cmt_uses GLOBAL PROPERTY CMT_USES)
  #message("cmt_use> CMT_USES=${cmt_uses}")
  list(FIND cmt_uses ${package} index)

  # detect if this package has already been analyzed 

  if(${index} GREATER -1)
    #message("cmt_use> ${package} already found")
    return()
  endif()

  # this is a new package

  #message("cmt_use> ${package} added to CMT_USES")

  set_property(GLOBAL APPEND PROPERTY CMT_USES ${package})
  set_property(GLOBAL PROPERTY "CMT_${package}_USE_PROPERTIES" "${path};${version};${prefix}")
  set_property(GLOBAL APPEND PROPERTY "CMT_${ppackage}_USE_CLIENTS" ${package})

  set(project)

  # extract the project where this package is found

  get_property(cmt_projects GLOBAL PROPERTY CMT_PROJECTS)
  foreach(p IN LISTS cmt_projects)
    get_property(project_properties GLOBAL PROPERTY "_CMT_${p}_PROJECT_PROPERTIES")
    list(GET project_properties 0 ppath)
    list(GET project_properties 1 pversion)
    set(ppath "${ppath}/${p}/${pversion}")
    string(REGEX REPLACE "[/]+" "/" ppath "${ppath}")
    string(REGEX REPLACE "[/]$" "" ppath "${ppath}")
    #message("cmt_use> path=${path} p=${p} pp=${project_properties} ppath=${ppath}")
    if("${path}" STREQUAL "${ppath}")
      set(project "${p}")
      break()
    endif()
  endforeach()

  message("cmt_use> line=${line} project=${pproject} path=${path} package=${package} version=${version} prefix=${prefix} req=${reqfile}")

  #cmt_split_line()

  cmt_read_requirements("${pproject}" "${path}" "${package}" "${version}" "${prefix}" "${reqfile}")

endfunction()


#-------------------------------------------
# Parse a 'use' statement from a 'project.cmt' file
#
function(cmt_use_project words)

  list(LENGTH words len)

  #message("cmt_use_project> line=[${words}] len=${len}")

  list(GET words 1 project)

  set(version)
  if("${len}" GREATER 2)
    list(GET words 2 version)
  endif() 
  
  #message("cmt_use_project> project=${project} version=${version}")

  get_property(cmt_projects GLOBAL PROPERTY CMT_PROJECTS)
  #message("cmt_use_project> CMT_PROJECTS=${cmt_projects}")
  list(FIND cmt_projects ${project} index)

  if(${index} GREATER -1)
    message("cmt_use_project> ${project} already found")
    return()
  else()
    message("cmt_use_project> ${project} added")
  endif()

  set_property(GLOBAL APPEND PROPERTY CMT_PROJECTS ${project})

  get_property(cmtprojectpath GLOBAL PROPERTY CMTPROJECTPATH)
  #message("cmt_use_project> cmtprojectpath=${cmtprojectpath}")

  foreach(path IN LISTS cmtprojectpath)

    string(REPLACE "\\" "/" path ${path})
    set(pfile "req${project}")

    unset(${pfile})

    message("cmt_use_project> look for project.cmt in ${path}/${project}/${version}/cmt")

    find_file(${pfile} project.cmt ${path}/${project}/${version}/cmt NO_DEFAULT_PATH)

    if("${pfile}" MATCHES "NOTFOUND")
      #message("cmt_use_project>1 project.cmt not found in ${path}/${project}/${version}/cmt")
    elseif("${pfile}" EQUAL "")
      #message("cmt_use_project>2 project.cmt not found in ${path}/${project}/${version}/cmt")
    else()
      #message("cmt_use_project> project file found in ${path}/${project}/${version}/cmt")
      set(pfile "${path}/${project}/${version}/cmt/project.cmt")
      cmt_read_project_file(${pfile})
      break()
    endif()
  endforeach()

endfunction()

#-------------------------------------------
# Parse a 'has' statement from a 'project.cmt' file
#
function(cmt_has words)

  message("cmt_has> line=[${words}]")

  nwords(n)
  getword(1 package)

  set(tprefix 1)
  set(nprefix 2)

  # consider the structure strategy so as to construct path with or without version 
  get_property(cmt_structure_strategy GLOBAL PROPERTY "CMT_STRUCTURE_STRATEGY")
  if("${cmt_structure_strategy}" STREQUAL "WITH_VERSION_DIRECTORY")
    if(${n} GREATER 2)
      getword(2 version)
      set(tprefix 2)
      set(nprefix 3)
    else()
      set(version)
    endif()

    if("${version}" STREQUAL "*")
      set(version)
    endif()

    if(NOT("${version}" STREQUAL ""))
      set(version "/${version}")
    endif()
  else()
    set(version)
  endif()

  set(prefix)

  message ("nprefix = ${nprefix} n=${n}")

  if("${n}" GREATER "${tprefix}")
    getword("${nprefix}" word)
    message ("word = ${word}")
    if(NOT("${word}" STREQUAL "-no_auto_imports"))
      set(prefix "${word}")
    endif()
  endif()

  if(NOT("${prefix}" STREQUAL ""))
    set(prefix "${prefix}/")
  endif()

  message("cmt_has> project=${project} package=${package} version=${version} prefix=${prefix}")

  get_property(CMTPATH GLOBAL PROPERTY CMTPATH)

  message("cmt_has> CMTPATH=${CMTPATH}")

  unset(path)

  # search package using CMTPATH
  foreach(p IN LISTS CMTPATH)
    set(req "req${package}${version}")
 
    unset("${req}")

    find_file("${req}" requirements "${p}/${prefix}${package}${version}/cmt" NO_DEFAULT_PATH)

    set(reqfile "${${req}}")

    message("cmt_use> Look for requirements file in ${p}/${prefix}${package}${version}/cmt -> req=[${reqfile}]")

    if("${reqfile}" MATCHES "NOTFOUND")
      #message("cmt_use>1 requirements not found in ${p}/${prefix}${package}${version}/cmt")
    elseif("${reqfile}" EQUAL "")
      #message("cmt_use>2 requirements not found in ${p}/${prefix}${package}${version}/cmt")
    else()
      string(REPLACE "/${prefix}${package}${version}/cmt/requirements" "" path ${reqfile})
      #message("REPLACE [/${prefix}${package}${version}/cmt/requirements] from ${reqfile} -> ${path}")
      break()
    endif()

  endforeach()

  if("${path}" STREQUAL "")
    #message("cmt_use> requirements files not found")
    return()
  endif()

  message("cmt_use> requirements found in ${path}")


endfunction()


#-------------------------------------------
function(cmt_get_current_project_file result)
  set(pwd ${CMAKE_CURRENT_SOURCE_DIR})

  message("cmt_get_current_project_file-1> current directory: pwd=${pwd}")

  if("${pwd}" MATCHES ".*cmt$")
    string(REGEX REPLACE "[/]cmt$" "" pwd "${pwd}")
    set_property(GLOBAL PROPERTY CMT_CURRENT_PATH "${pwd}")
  else()
    find_file(cmt cmt ${pwd})
    if("${cmt}" MATCHES "NOTFOUND")
      message("cmt_get_current_project_file-2> current directory is not CMT (no cmt directory)")
      set(${result} "NOTFOUND" PARENT_SCOPE)
      return()
    else()
      message("cmt_get_current_project_file-3> current directory has a cmt directory")
      set_property(GLOBAL PROPERTY CMT_CURRENT_PATH "${pwd}")
    endif()
  endif()

  #set_property(GLOBAL PROPERTY CMT_CURRENT_PATH "${pwd}")

  get_property(cmtprojectpath GLOBAL PROPERTY CMTPROJECTPATH)

  string(REPLACE "\\" "/" cmtprojectpath "${cmtprojectpath}")

  message("cmt_get_current_project_file-3.1> cmtprojectpath=${cmtprojectpath}")

  set(found 0)
  foreach(p IN LISTS cmtprojectpath)
    message("cmt_get_current_project_file-3.2> compare pwd=${pwd} and p=${p}")
    if("${pwd}" MATCHES "${p}")
      message("cmt_get_current_project_file-4> ${pwd} is inside one of the CMTPROJECTPATH=${p}")
      set_property(GLOBAL PROPERTY CMT_CURRENT_PATH "${p}")
      set(found 1)
      break()
    else()
      message("cmt_get_current_project_file-5> ${pwd} is not inside this element ${p} of CMTPROJECTPATH")
    endif()
  endforeach()

  if(NOT(${found}))
    message("cmt_get_current_project_file-5.1> ${pwd} is not inside any element of CMTPROJECTPATH")
    string(REGEX REPLACE "[/][^/]*$" "" project_path "${pwd}")
    set_property(GLOBAL APPEND PROPERTY CMTPROJECTPATH "${project_path}")
  endif()

  string(REGEX REPLACE ".*[/]" "" project_name "${pwd}")

  get_property(cmtprojectpath GLOBAL PROPERTY CMTPROJECTPATH)
  string(REPLACE "\\" "/" cmtprojectpath ${cmtprojectpath})
  message("cmt_get_current_project_file-6> cmtprojectpath=${cmtprojectpath}")

  set(${result} "NOTFOUND" PARENT_SCOPE)

  while(1)
    message("cmt_get_current_project_file-7> look for project.cmt starting from ${pwd}/cmt")
    unset(pfile)
    find_file(pfile project.cmt ${pwd}/cmt ${pwd} NO_DEFAULT_PATH)
    message("cmt_get_current_project_file> pfile=${pfile} found")
    if((pfile MATCHES "NOTFOUND") OR (pfile EQUAL ""))
      message("cmt_get_current_project_file> not found. Move upward")
      string(REGEX REPLACE "[/][^/]*$" "" pwd "${pwd}")
      message("cmt_get_current_project_file> current directory is now pwd=${pwd}")
      break()
    else()
      set(${result} "${pfile}" PARENT_SCOPE)
      message("cmt_get_current_project_file> OK found ${pfile}")
      break()
    endif()
  endwhile()

  set_property(GLOBAL PROPERTY CMT_CURRENT_PROJECT "${project_name}")
  cmt_append_unique_property(CMTPATH ${pwd})

endfunction()

#---------------------------------------------------------
function(cmt_project project project_file)
  #message("cmt_project> project=${project} project_file=${project_file}")
  cmt_append_unique_property(CMT_PROJECTS "${project}")

  if("${project}" STREQUAL "")
    string(REGEX REPLACE "[/]cmt/project.cmt$" "" project "${project_file}")
    string(REGEX REPLACE "([^/])*[/]" "" project "${project}")
    set_property(GLOBAL APPEND PROPERTY CMT_PROJECTS ${project})
  endif()

  get_property(cmt_projects GLOBAL PROPERTY CMT_PROJECTS)
  #message("cmt_project> CMT_PROJECTS=${cmt_projects} project_file=${project_file}")

  string(REGEX REPLACE "[/]cmt/project.cmt$" "" project_path "${project_file}")

  #message("cmt_project> project_path=${project_path}")

  string(REGEX REPLACE "([^/])*[/]" "" version "${project_path}")

  if("${version}" STREQUAL "${project}")
    set(version)
    string(REGEX REPLACE "[/]${project}$" "" project_path "${project_path}")
  else()
    string(REGEX REPLACE "[/]${version}$" "" project_path "${project_path}")
    string(REGEX REPLACE "[/]${project}$" "" project_path "${project_path}")
  endif()

  cmt_append_unique_property(CMTPROJECTPATH "${project_path}")
  #message("cmt_project> project=${project} version=${version} path=${project_path}")

  set_property(GLOBAL PROPERTY "_CMT_${project}_PROJECT_PROPERTIES" "${project_path};${version}")
  cmt_append_unique_property(CMTPROJECTPATH "${project_path}")

  get_property(current_project GLOBAL PROPERTY "CMT_CURRENT_PROJECT")
  if("${current_project}" STREQUAL "")
    set_property(GLOBAL PROPERTY CMT_CURRENT_PROJECT "${project}")
  endif()

endfunction()

#-------------------------------------------
# Read a 'project.cmt' file
#
#
function(cmt_read_project_file project_file)

  #message("cmt_read_project_file> project_file=${project_file}")

  cmt_read_file(${project_file} lines)

  set(project)
  set(nline 1)
  foreach(line IN LISTS lines)

    string(REPLACE __CMTWORD__ ";" words ${line})
    list(LENGTH words len)
    #message("cmt_read_project_file(${project_file})> non empty line: [${words}] nline=${nline}")

    list(GET words 0 keyword)

    #message("cmt_read_project_file> keyword=${keyword}")

    if(keyword MATCHES "use")
      cmt_use_project("${words}")
    elseif(keyword MATCHES "has")
      cmt_use("${project}" "${ppath}" "" "" "" "${words}")
    elseif(keyword MATCHES "structure_strategy")
      set_property(GLOBAL PROPERTY CMT_STRUCTURE_STRATEGY "without_version_directory")
      #message("cmt_read_project_file> set structure_strategy='without_version_directory'")
    elseif(keyword MATCHES "project")
      list(GET words 1 project)
      #message("cmt_read_project_file> project=${project} project_file=${project_file}")
      cmt_project(${project} ${project_file})
    endif()

    #message("cmt_read_project_file> next line")

    math(EXPR nline "${nline} + 1")

  endforeach()

endfunction()

#-------------------------------------------
# Understand where if the current package reached from the command line
#
# Fill caller variables [path package version prefix]
# 
function(cmt_get_current_package rpath rpackage rversion rprefix)
  set(pwd ${CMAKE_CURRENT_SOURCE_DIR})
  message("cmt_get_current_package> CMAKE_CURRENT_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}")

  get_property(cmtpath GLOBAL PROPERTY CMTPATH)
  set(found FALSE)
  unset(path)
  foreach(p IN LISTS cmtpath)
    if(pwd MATCHES ${p})
      set(found TRUE)
      set(project_path ${p})
      break()
    endif()
  endforeach()

  if(found)
    message("cmt_get_current_package> pwd is within ${project_path}")
  else()
    message("cmt_get_current_package> pwd is outside any CMTPROJECTPATH")
    return()
  endif()

  #set_property(GLOBAL PROPERTY CMT_CURRENT_PROJECT ${project_path})

  set(${rpath} "${project_path}" PARENT_SCOPE)

  # We start by removing the project path from pwd to parse 'prefix/package/version'

  string(REPLACE "${project_path}/" "" spec "${pwd}")
  string(REPLACE "/cmt" "" spec "${spec}")
  message("cmt_get_current_package> spec=${spec}")

  get_property(cmt_structure_strategy GLOBAL PROPERTY CMT_STRUCTURE_STRATEGY)

  # if with_version_directory is on, version is the last field of the spec
  if("${cmt_structure_strategy}" STREQUAL "with_version_directory")
    string(REGEX REPLACE "([^/])*[/]" "" version "${spec}")
    string(REGEX REPLACE "/${version}" ""spec "${spec}")
    message("cmt_get_current_package> version=${version}")
  endif()

  # now package is the last field of the spec
  string(REGEX REPLACE "([^/])*[/]" "" package "${spec}")
  message("cmt_get_current_package> package=${package}")

  # prefix is the rest
  unset(prefix)
  if(NOT ("${package}" MATCHES "${spec}"))
    string(REPLACE "/${package}" "" prefix "${spec}")
  endif()

  # formatting 
  if("${version}" STREQUAL "")
  elseif("${version}" MATCHES "[/]$")
  else()
    set(version "${version}/")
  endif()

  if("${prefix}" STREQUAL "")
  elseif("${prefix}" MATCHES "[/]$")
  else()
    set(prefix "${prefix}/")
  endif()

  set(${rpath} "${project_path}" PARENT_SCOPE)
  set(${rpackage} "${package}" PARENT_SCOPE)
  set(${rversion} "${version}" PARENT_SCOPE)
  set(${rprefix} "${prefix}" PARENT_SCOPE)

  set_property(GLOBAL APPEND PROPERTY CMT_USES ${package})
  set_property(GLOBAL PROPERTY "CMT_${package}_USE_PROPERTIES" "${path};${version};${prefix};")

  message("cmt_get_current_package> rpath=${project_path} rpackage=${package} rversion=${version} rprefix=${prefix}")

endfunction()

#-------------------------------------------
# Query function
#
function(cmt_show_use use offset)

  set_property(GLOBAL APPEND PROPERTY done "${use}")

  get_property(clients GLOBAL PROPERTY "CMT_${use}_USE_CLIENTS")
  #message("clients of ${use}=[${clients}]")

  unset(spaces)
  foreach(k RANGE ${offset})
    set(spaces "${spaces}  ")
  endforeach()

  get_property(props GLOBAL PROPERTY "CMT_${use}_USE_PROPERTIES")
  list(GET props 0 path)
  list(GET props 1 version)
  list(GET props 2 prefix)

  message("${spaces}${use} ${version} ${prefix} ${path}")

  foreach(u IN LISTS clients)
    get_property(done GLOBAL PROPERTY done)
    list(FIND done ${u} index)
    #message("cmt show uses> u=${u} done=${done} index=${index}")
    if("${index}" EQUAL -1)
      math(EXPR offset "${offset} + 1")
      cmt_show_use(${u} ${offset})
    endif()
  endforeach()

endfunction()

#-------------------------------------------
# Query function
#
function(cmt_show_uses)

  message("cmt show uses>")

  set_property(GLOBAL PROPERTY done)
  message("cmt show uses>")
  get_property(uses GLOBAL PROPERTY CMT_USES)
  foreach(u IN LISTS uses)
    get_property(done GLOBAL PROPERTY done)
    list(FIND done ${u} index)
    #message("cmt show uses> u=${u} done=${done} index=${index}")
    if("${index}" EQUAL -1)
      cmt_show_use(${u} 0)
    endif()
  endforeach()
  message("----------------")
endfunction()

#-------------------------------------------
# Query function
#
function(cmt_show_symbol s)
  get_property(value GLOBAL PROPERTY "_CMT_${s}")
  get_property(properties GLOBAL PROPERTY "_CMT_${s}_SYMBOL_PROPERTIES")
  list(GET properties 0 path)
  list(GET properties 1 package)
  if("${value}" MATCHES "^[\"].*[\"]$")
  elseif("${value}" MATCHES "^['].*[']$")
  else()
    set(value "${value}")
  endif()
  message("Package ${package} defines ${s}=[${value}] as default value")
  get_property(tagged_values GLOBAL PROPERTY "_CMT_${s}_TAGGED_VALUES")
  if("${tagged_values}" STREQUAL "")
    return()
  endif()
  foreach(t IN LISTS tagged_values)
    get_property(tagged_value GLOBAL PROPERTY "_CMT_${s}[${t}]")
    message("    and value=[${tagged_value}] for tag ${t}")
  endforeach()
endfunction()

#---------------------------------------------------------
function(cmt_show_symbols)
  get_property(symbols GLOBAL PROPERTY CMT_SYMBOLS)
  message("cmt show symbols>")
  foreach(s IN LISTS symbols)
    cmt_show_symbol(${s})
  endforeach()
  message("----------------")
endfunction()

#---------------------------------------------------------
function(cmt_show_macros)
  get_property(macros GLOBAL PROPERTY CMT_MACROS)
  message("cmt show macros> ${macros}")
  foreach(m IN LISTS macros)
    cmt_show_symbol(${m})
  endforeach()
  message("----------------")
endfunction()

#---------------------------------------------------------
function(cmt_show_sets)
  message("cmt show sets>")
  get_property(sets GLOBAL PROPERTY CMT_SETS)
  foreach(m IN LISTS sets)
    cmt_show_symbol(${m})
  endforeach()
  message("----------------")
endfunction()

#-------------------------------------------
# Query function
# 
function(cmt_has_macro name result)
  get_property(macros GLOBAL PROPERTY CMT_SYMBOLS)
  list(FIND macros ${name} index)
  if("${index}" GREATER -1)
    set(${result} TRUE PARENT_SCOPE)
  else()
    set(${result} FALSE PARENT_SCOPE)
  endif()  
endfunction()

#-------------------------------------------
# Query function
# 
function(cmt_select_macro_value name result)
  get_property(macros GLOBAL PROPERTY CMT_SYMBOLS)
  list(FIND macros ${name} index)
  if("${index}" GREATER -1)
    # we search if one of the tagged_values specified for this macro
    # is appropriate ie. the tag associated is active
    # if not, we'll select the default value

    get_property(tagged_values GLOBAL PROPERTY "_CMT_${name}_TAGGED_VALUES")

    if(NOT("${tagged_values}" STREQUAL ""))
      foreach(t IN LISTS tagged_values)
        cmt_get_tag_state(${t} ok)
        if(${ok})
          get_property(value GLOBAL PROPERTY "_CMT_${name}[${t}]")
          string(STRIP "${value}" value)
          set(${result} "${value}" PARENT_SCOPE)
          return()
        endif()

      endforeach()
    endif()

    get_property(value GLOBAL PROPERTY "_CMT_${name}")
    string(STRIP "${value}" value)
    set(${result} "${value}" PARENT_SCOPE)
  else()
    set(${result} "NOT_FOUND" PARENT_SCOPE)
  endif()
endfunction()

#---------------------------------------------------------
function(cmt_get_tag_state tag result)
  get_property(cmt_active_tags GLOBAL PROPERTY CMT_ACTIVE_TAGS)
  #message("all active tags=${cmt_active_tags}")
  list(FIND cmt_active_tags ${tag} index)
  if(${index} GREATER -1)
    set(${result} TRUE PARENT_SCOPE)
    return()
  endif()

  if("${tag}" MATCHES "[&]")
    string(REPLACE "&" ";" tags "${tag}")
    foreach(t IN LISTS tags)
      cmt_get_tag_state(${t} ok)
      if(NOT(${ok}))
        set(${result} FALSE PARENT_SCOPE)
        return()
      endif()
    endforeach()
    set(${result} TRUE PARENT_SCOPE)
    return()
  endif()

  # we interrogate the parents
  get_property(parents GLOBAL PROPERTY "_CMT_${tag}_TAG_PARENTS")
  #message("all parents of ${tag}=${parents}")
  foreach(p IN LISTS parents)
    cmt_get_tag_state(${p} ok)
    if(${ok})
      cmt_activate_tag("${p}")
      set(${result} TRUE PARENT_SCOPE)
      return()
    endif()
  endforeach()
  set(${result} FALSE PARENT_SCOPE)
endfunction()

#---------------------------------------------------------
function(cmt_activate_tag tag)
  if("${tag}" STREQUAL "")
    return()
  endif()
  get_property(cmt_tags GLOBAL PROPERTY CMT_TAGS)
  list(APPEND cmt_tags ${tag})
  list(REMOVE_DUPLICATES cmt_tags)
  set_property(GLOBAL PROPERTY CMT_TAGS ${cmt_tags})

  get_property(cmt_active_tags GLOBAL PROPERTY CMT_ACTIVE_TAGS)
  list(APPEND cmt_active_tags ${tag})
  list(REMOVE_DUPLICATES cmt_active_tags)
  set_property(GLOBAL PROPERTY CMT_ACTIVE_TAGS ${cmt_active_tags})
endfunction()

#---------------------------------------------------------
function(cmt_show_tags)
  message("cmt show tags>")
  get_property(cmt_active_tags GLOBAL PROPERTY CMT_TAGS)
  foreach(t IN LISTS cmt_active_tags)
    cmt_get_tag_state(${t} ok)
    get_property(parents GLOBAL PROPERTY "_CMT_${t}_TAG_PARENTS")
    get_property(clients GLOBAL PROPERTY "_CMT_${t}_TAG_CLIENTS")
    message("tag ${t} [${ok}] P=[${parents}] C=[${clients}]")
  endforeach()
endfunction()

#---------------------------------------------------------
function(cmt_show_pattern pattern)
  get_property(lines GLOBAL PROPERTY "_CMT_${pattern}_PATTERN_DEFINITION")
  foreach(line IN LISTS lines)
    message("  " ${line})
  endforeach()
endfunction()

#---------------------------------------------------------
function(cmt_show_patterns)
  message("cmt show patterns>")
  get_property(cmt_patterns GLOBAL PROPERTY CMT_PATTERNS)
  foreach(p IN LISTS cmt_patterns)
    message("pattern ${p}")
    cmt_show_pattern(${p})
  endforeach()

  get_property(cmt_patterns GLOBAL PROPERTY CMT_GLOBAL_PATTERNS)
  foreach(p IN LISTS cmt_patterns)
    message("pattern ${p}")
    cmt_show_pattern(${p})
  endforeach()

  get_property(cmt_patterns GLOBAL PROPERTY CMT_CMTPATH_PATTERNS)
  foreach(p IN LISTS cmt_patterns)
    message("pattern ${p}")
    cmt_show_pattern(${p})
  endforeach()
endfunction()

#---------------------------------------------------------
function(cmt_show_apply_patterns)
endfunction()

#---------------------------------------------------------
function(cmt_do command target args)
  #message("cmt_do> ${ARGV} ${args}")
  set(temp "${CMAKE_CURRENT_BINARY_DIR}/temp.txt")
  #message("${command}(${target} ${args})")
  FILE( WRITE "${temp}" "# ${command}(${target} ${args})" )
  INCLUDE( ${temp} )
  FILE( REMOVE ${temp} )
endfunction()

#--------------------------------------------------
# Main entry point
#--------------------------------------------------

function(cmt_init)
  if("$ENV{CMTSITE}" STREQUAL "")
    set(ENV{CMTSITE} "${CMTSITE}")
  endif()

  if("$ENV{CMTCONFIG}" STREQUAL "")
    set(ENV{CMTCONFIG} "${CMTCONFIG}")
  endif()

  if("$ENV{CMTPROJECTPATH}" STREQUAL "")
    set(ENV{CMTPROJECTPATH} "${CMTPROJECTPATH}")
  endif()

  set(ENV{PYTHON} "c:/Install/Python27/python.exe")

  message("---------- Set defaults")
  set_property(GLOBAL PROPERTY CMT_STRUCTURE_STRATEGY "without_version_directory")

  message("---------- Set system env. vars")
  # uname (should be picked up from CMake variables)
  execute_process(COMMAND uname OUTPUT_VARIABLE tag)
  string(STRIP "${tag}" tag)
  message("uname=${tag}")
  cmt_activate_tag("${tag}")

  set(tag $ENV{CMTSITE})
  message("CMTSITE=${tag}")
  if(NOT("${tag}" STREQUAL ""))
    cmt_activate_tag("${tag}")
  endif()

  set(tag $ENV{CMTCONFIG})
  message("CMTCONFIG=${tag}")
  if(NOT("${tag}" STREQUAL ""))
    cmt_activate_tag("${tag}")
  endif()


  message("---------- Decoding CMTPROJECTPATH")
  #message("CMTPROJECTPATH=$ENV{CMTPROJECTPATH}")
  #string(REPLACE ":" ";" CMTPROJECTPATH "$ENV{CMTPROJECTPATH}")
  set_property(GLOBAL PROPERTY CMTPROJECTPATH $ENV{CMTPROJECTPATH})

  message("CMTPROJECTPATH=$ENV{CMTPROJECTPATH}")
  foreach(p IN LISTS CMTPROJECTPATH)
    message("Element of CMTPROJECTPATH = ${p}") 
  endforeach()

  #
  # Construct the project graph starting from the current location 
  #
  message("---------- Constructing the project graph starting from the current location")
  cmt_get_current_project_file(project_file)
  if("${project_file}" STREQUAL "NOTFOUND")
    return()
  endif()

  message("after get_project_file project_file=${project_file}")
  cmt_read_project_file(${project_file})

  #
  # Construct CMTPATH from CMTPROJECTPATH
  # We apply a general policy by which:
  #   - header files are installed into the installarea
  #   - libraries are found in installareas
  # eventually this policy should be based on CMT macros & patterns
  #
  message("---------- Construct CMTPATH from CMTPROJECTPATH")

  get_property(cmt_projects GLOBAL PROPERTY CMT_PROJECTS)

  foreach(p IN LISTS cmt_projects)
    get_property(pp GLOBAL PROPERTY "_CMT_${p}_PROJECT_PROPERTIES")
    message("project property ${pp}")
    if("${pp}" STREQUAL "")
      message("Project ${p} not found")
    else()
      list(GET pp 0 path)
      list(GET pp 1 version)
      message("project ${p} properties=[${pp}] path=${path} version=${version}")
      message("Apply implicit policies: add include and link directory ${path}/${p}/${version}/installarea")
      set_property(GLOBAL APPEND PROPERTY CMTPATH "${path}/${p}/${version}")
      message(">>>>>include_directories('${path}/${p}/${version}/installarea')")
      include_directories("${path}/${p}/${version}/installarea")
      message(">>>>>link_directories('${path}/${p}/${version}/installarea')")
      link_directories("${path}/${p}/${version}/installarea")
    endif()
  endforeach()

  get_property(cmtpath GLOBAL PROPERTY CMTPATH)
  message("CMTPATH=${cmtpath}")

  message("---------- Work on current package")

  set(package)
  set(version)
  set(prefix)

  #cmt_get_current_package(path package version prefix)

  message("path=${path} package=${package} version=${version} prefix=${prefix}")

  get_property(project GLOBAL PROPERTY CMT_CURRENT_PROJECT)

  # Here we assume that pwd within the 'cmt' directory of the package we want to operate
  # thus 'requirements' is just there.
  #cmt_read_requirements("${project}" "${path}" "${package}" "${version}" "${prefix}" requirements)

  if(NOT("${tag}" STREQUAL ""))
    foreach(t IN LISTS tag)
      cmt_activate_tag("${t}")
    endforeach()
  endif()

  if("${action}" STREQUAL "show uses")
    cmt_show_uses()
  elseif("${action}" STREQUAL "show symbols")
    cmt_show_symbols()
  elseif("${action}" STREQUAL "show macros")
    cmt_show_macros()
  elseif("${action}" STREQUAL "show sets")
    cmt_show_sets()
  elseif("${action}" STREQUAL "show tags")
    cmt_show_tags()
  elseif("${action}" STREQUAL "show patterns")
    cmt_show_patterns()
  elseif("${action}" MATCHES "show macro ")
    string(REPLACE "show macro " "" name "${action}")
    cmt_show_symbol("${name}")
  endif()

  message("CMAKE_CURRENT_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR} CMAKE_CURRENT_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}")
endfunction()

#---------------------------------------------------------
function(find_cmt_project project)

  # Find the properties useful when using the project
  #
  #  ${project}_INCLUDE_DIRS  - where to find header files of the project, etc.
  #  ${project}_LIBRARIES     - List of libraries when using the project.
  #  ${project}_LINK_LIBRARY  - Path where libraries are found when using the project.
  #  ${project}_FOUND         - True if the project is found.

  unset(${project}_INCLUDE_DIRS)
  unset(${project}_INCLUDE_DIR)
  unset(${project}_LIBRARIES)

  # Find the CMT project location
  set(CMTPROJECTPATH c:/Arnault/cmt2/test)
  find_file(project_root ${project}/cmt/project.cmt ${CMTPROJECTPATH})
  string(REGEX REPLACE "/cmt/project.cmt" "" project_root "${project_root}")
  # message("project_root=${project_root}")

  # Look for the header file.
  FILE(GLOB ${project}_INCLUDE_DIR ${project_root}/installarea */*.hxx */*.h */*.hpp)
  # message(" > ${project}_INCLUDE_DIR=${${project}_INCLUDE_DIR} ")
  SET(${project}_INCLUDE_DIRS ${${project}_INCLUDE_DIR})

  # Look for the library.
  unset(project_libs)
  FILE(GLOB project_libs ${project_root}/installarea/${CMAKE_FIND_LIBRARY_PREFIXES}*${CMAKE_FIND_LIBRARY_SUFFIXES} ${project_root}/installarea/${CMAKE_FIND_LIBRARY_PREFIXES}*.a)
  # message(" > project_libs=${project_libs}")

  #FIND_LIBRARY(${project}_LIBRARY ${project_libs} PATHS ${project_root}/installarea)
  #message(" > ${project}_LIBRARY=${${project}_LIBRARY}")

  foreach(lib IN LISTS project_libs)
    string(REGEX REPLACE "[^/]*[/]" "" lib "${lib}")
    if(NOT("${CMAKE_FIND_LIBRARY_PREFIXES}" STREQUAL ""))
      string(REGEX REPLACE "${CMAKE_FIND_LIBRARY_PREFIXES}" "" lib "${lib}")
    endif()
    string(REGEX REPLACE "${CMAKE_FIND_LIBRARY_SUFFIXES}" "" lib "${lib}")
    # message(" > lib=${lib}")
    list(APPEND ${project}_LIBRARIES ${lib})
  endforeach()

  set(${project}_LIBRARY ${${project}_LIBRARIES})

  # message(" > ${project}_LIBRARIES=${${project}_LIBRARIES}")

  # handle the QUIETLY and REQUIRED arguments and set ${project}_FOUND to TRUE if 
  # all listed variables are TRUE

  INCLUDE(${CMAKE_ROOT}/Modules/FindPackageHandleStandardArgs.cmake)

  FIND_PACKAGE_HANDLE_STANDARD_ARGS(${project} DEFAULT_MSG ${project}_LIBRARY ${project}_LIBRARIES ${project}_INCLUDE_DIR)

  MESSAGE("")

  # Copy the results to the output variables.
  IF(${project}_FOUND)
    set(${project}_ROOT ${project_root})
    SET(${project}_LINK_DIRECTORY ${${project}_ROOT}/installarea)

    set(${project}_ROOT ${project_root} PARENT_SCOPE)
    SET(${project}_LIBRARIES ${${project}_LIBRARY} PARENT_SCOPE)
    SET(${project}_INCLUDE_DIR ${${project}_INCLUDE_DIR} PARENT_SCOPE)
    SET(${project}_INCLUDE_DIRS ${${project}_INCLUDE_DIR} PARENT_SCOPE)
    SET(${project}_LINK_DIRECTORY ${${project}_ROOT}/installarea PARENT_SCOPE)


    MESSAGE("Find project ${project}")
    MESSAGE("  ${project}_LIBRARIES ${${project}_LIBRARY}")
    MESSAGE("  ${project}_INCLUDE_DIR ${${project}_INCLUDE_DIR}")
    MESSAGE("  ${project}_INCLUDE_DIRS ${${project}_INCLUDE_DIRS}")
    MESSAGE("  ${project}_LINK_DIRECTORY ${${project}_LINK_DIRECTORY}")

  ELSEIF()

    MESSAGE("Find project ${project} failed")

  ENDIF()

  MESSAGE("")

  MARK_AS_ADVANCED(${project}_INCLUDE_DIRS ${project}_LIBRARY ${project}_LINK_DIRECTORY)
endfunction ()

#---------------------------------------------------------

#cmt_init ()