Harbour Make (hbmk2)

Harbour Make (hbmk2) 3.2.0dev (r2013-04-03 03:33)
Copyright (c) 1999-2013, Viktor Szakáts
http://harbour-project.org/

Syntax:

hbmk2 [options] [<script[s]>] <src[s] [.prg|.c|.obj|.o|.rc|.res|.def|.po|.pot|.hbl|@.clp|.d|.ch]>

Description:

hbmk2 is an integrated and portable build tool, making it possible to create various types of executable binaries (executable, dynamic library, static library, Harbour portable binary) out of multiple types of source files (C, C++, Objective-C, Harbour, gettext translations, Windows resources). ‘Integrated’ means that a single hbmk2 project file can control all or most aspects of the build process. ‘Portable’ means that a single hbmk2 project file can control the build on all supported OS platforms and across all supported C compilers. It also aims to cover the majority of build tasks via short and simple project files (options). hbmk2 supports pure -non-Harbour- C/C++/Objective-C projects as well. In order to achieve above goals, hbmk2 will autodetect Harbour, C compiler and other required tools, then configure and call them appropriately. hbmk2 allows to extend the types of supported source files via plugins.

Besides building executables, hbmk2 is able to run Harbour scripts (both source and precompiled) directly, and it also features an interactive shell prompt.

Options:

  • -o<outname> output file name
  • -l<libname> link with <libname> library. <libname> should be without path, extension and ‘lib’ prefix (unless part of the name). Do not add core Harbour libraries, they are automatically added as needed. If <libname> starts with a ‘-‘ character, the library will be removed from the list of libraries at link time.
  • -L<libpath> additional path to search for libraries
  • -i<p>|-incpath=<p> additional path to search for headers
  • -static|-shared link with static/shared libs
  • -gt<name> link with GT<name> GT driver, can be repeated to link with more GTs. First one will be the default at run-time
  • -inc[-] enable/disable incremental build mode (default: disabled)
  • -hbexe create executable (default)
  • -hblib create static library
  • -hbdyn create dynamic library (without linked Harbour VM)
  • -hbdynvm create dynamic library (with linked Harbour VM)
  • -mt|-st link with multi/single-thread Harbour VM
  • -gui|-std create GUI/console executable
  • -main=<mainfunc> override the name of starting function/procedure
  • -request=<func> force function/procedure to be linked
  • -fullstatic link with all static libs
  • -pic[-] create position independent object code (always enabled in -hbdyn/-hbdynvm modes)
  • -[full|fix]shared create shared Harbour binaries without/with absolute dir reference to Harbour library (default: ‘fullshared’ when Harbour is installed on system location, ‘fixshared’ otherwise) (fix/full option in *nix only)
  • -nulrdd[-] link with nulrdd
  • -debug[-] add/exclude C compiler debug info. For Harbour level debug, use Harbour option -b as usual
  • -optim[-] toggle C compiler optimizations (default: on)
  • -cpp[-] force C++/C mode
  • -cpp=<value> select C++ mode. Allowed values are: def, yes, no
  • -map[-] create (or not) a map file
  • -implib[-] create (or not) an import library (in -hbdyn/-hbexe mode). The name will have a postfix added.
  • -implib=<output> create import library (in -hbdyn/-hbexe mode) name to <output> (default: same as output)
  • -ln=<link> create symbolic link pointing to <output> (<link> is considered relative to <output>)
  • -strip[-] strip (no strip) binaries
  • -trace[-] show commands executed
  • -beep[-] enable (or disable) single beep on successful exit, double beep on failure
  • -ignore[-] ignore errors when running compiler tools (default: off)
  • -hbcppmm[-] override standard C++ memory management functions with Harbour ones
  • -winuni[-] select between UNICODE (WIDE) and ANSI compilation modes (default: ANSI) (Windows only. For WinCE it is always set to UNICODE)
  • -nohblib[-] do not use static core Harbour libraries when linking
  • -nodefgt[-] do not link default GTs (effective in -static mode)
  • -nolibgrouping[-] disable library grouping on gcc based compilers
  • -nomiscsyslib[-] do not add extra list of system libraries to default library list
  • -traceonly show commands to be executed, but do not execute them
  • -warn=<level> set C compiler warning level
    <level> can be: max, yes, low, no, def (default: yes)
  • -safe[-] enable safety options in C compiler/linker (default: enabled on Windows, disabled on other systems)
  • -compr=<level> compress executable/dynamic lib (needs UPX tool)
    <level> can be: yes, no, min, max
  • -run[-] run/do not run output executable
  • -vcshead=<file> generate .ch header file with local repository information. Git, SVN, Mercurial, Bazaar, Fossil, CVS and Monotone are currently supported. Generated header will define preprocessor constant _HBMK_VCS_TYPE_ with the name of detected VCS and _HBMK_VCS_ID_ with the unique ID of local repository. If no VCS system is detected, a sequential number will be rolled automatically on each build.
  • -tshead=<file> generate .ch header file with timestamp information. Generated header will define preprocessor constants _HBMK_BUILD_DATE_, _HBMK_BUILD_TIME_, _HBMK_BUILD_TIMESTAMP_ with the date/time of build
  • -icon=<file> set <file> as application icon. <file> should be a supported format on the target platform (not supported by some platforms/compilers). On Windows, it is implemented by generating and linking a resource file.
  • -manifest=<file> embed manifest <file> in executable/dynamic lib (Windows only)
  • -sign=<key> sign executable with <key> (Windows and Darwin only). On Windows signtool.exe is used (part of MS Windows SDK) or posign.exe (part of Pelles C 7), in that order, both autodetected.
  • -signpw=<pw> use <pw> as password when signing executable (Windows and Darwin only)
  • -instfile=<g:file> add <file> in to the list of files to be copied to path specified by -instpath option. <g> is an optional copy group (case sensitive), it must be at least two characters long. In case you do not specify <file>, the list of files in that group will be emptied.
  • -instpath=<g:path> copy target file(s) to <path>. if <path> is a directory, it should end with path separator, in this case files specified by -instfile option will also be copied. can be specified multiple times. <g> is an optional copy group, it must be at least two characters long. Build target will be automatically copied to default (empty) copy group. There exist following built-in <g> groups: ‘depimplib’ for import libraries and ‘depimplibsrc’ for import library source (.dll) files, both belonging to dependencies.
  • -instforce[-] copy target file(s) to install path even if already up to date
  • -depimplib[-] enable (or disable) import library generation for import library sources specified in -depimplibs= options (default: yes)
  • -stop[=<text>] stop without doing anything and display <text> if specified
  • -echo=<text> echo text on screen
  • -pause force waiting for a key on exit in case of failure (with alternate GTs only)
  • -exitstr show error result as human readable text on exit
  • -info turn on informational messages
  • -quiet[-] suppress all screen messages
  • -bldf[-] inherit all/no (default) flags from Harbour build
  • -bldf=[p][c][l] inherit .prg/.c/linker flags (or none) from Harbour build
  • -F<framework> link with <framework> framework (Darwin only)
  • -prgflag=<f> pass single flag to Harbour compiler
  • -cflag=<f> pass single flag to C compiler
  • -resflag=<f> pass single flag to resource compiler (Windows only)
  • -ldflag=<f> pass single flag to linker (executable)
  • -dflag=<f> pass single flag to linker (dynamic library)
  • -aflag=<f> pass single flag to linker (static library)
  • -iflag=<f> pass single flag to import library creation command
  • -signflag=<f> pass single flag to code sign command
  • -runflag=<f> pass single flag to output executable when -run option is used
  • -cflag+=<f> pass single flag to C compiler overriding C compiler flags added by hbmk2 itself. Use with caution.
  • -ldflag+=<f> pass single raw option to linker (executable) after the library list. Use with caution.
  • -dflag+=<f> pass single raw option to linker (dynamic library) after the library list. Use with caution.
  • -3rd=<f> options/flags reserved for 3rd party tools, always ignored by hbmk2 itself
  • -env:<e>[<o>[<v>]] alter local environment. <e> is the name of the environment variable to alter. <o> can be ‘=’ to set/override, ‘-‘ to delete, ‘+’ to append to the end of existing value, ‘#’ to insert to the beginning of existing value. <v> is the value to set/append/insert.
  • -jobs=<n> start n compilation threads (multiprocess platforms only)
  • -head=<m> control source header parsing (in incremental build mode)
    <m> can be: native (uses compiler to extract dependencies), full (default, uses simple text parser on the whole file), dep, off
  • -rebuild rebuild (in incremental build mode)
  • -rebuildall rebuild with sub-projects (in incremental build mode)
  • -clean clean (in incremental build mode)
  • -workdir=<dir> working directory
    (default: .hbmk/<platform>/<compiler> [*] in incremental mode, OS temp directory otherwise)
  • -hbcontainer virtual build target, it does not create anything. Useful for creating an .hbp with the sole purpose of referencing sub-projects
  • -hbimplib create import library (Windows only)
  • -hbl[=<output>] output .hbl filename. %{hb_lng} macro is accepted in filename
  • -lng=<languages> list of languages to be replaced in %{hb_lng} macros in .pot/.po filenames and output .hbl/.po filenames. Comma separated list:
    -lng=en,hu-HU,de
  • -po=<output> create/update .po file from source. Merge it with previous .po file of the same name
  • -minipo[-] do (not) add Harbour version number and source file reference to .po (default: add them)
  • -rebuildpo recreate .po file, thus removing all obsolete entries in it
  • -hbx=[<.ch>] Create Harbour header (in .hbx format) with all external symbols. Empty parameter will disable it.
  • -autohbc=<.ch:.hbc> <.ch> is a header file name. <.hbc> is a .hbc filename to be automatically included in case the header is found in any of the compiled sources. (EXPERIMENTAL)
  • -deppkgname=<d:n> <d> is the name of the dependency. <n> name of the package dependency. Can be specified multiple times.
  • -depkeyhead=<d:h> <d> is the name of the dependency. <h> is the key header (.h) of the package dependency. Multiple alternative headers can be specified.
  • -depoptional=<d:f> <d> is the name of the dependency. <f> can be ‘yes’ or ‘no’, specifies whether the dependency is optional. Default: no
  • -depcontrol=<d:v> <d> is the name of the dependency. <v> is a value that controls how detection is done. Accepted values: no, yes, force, nolocal, local. Default: content of environment variable HBMK_WITH_<d>
  • -depincroot=<d:r> <d> is the name of the dependency. Set <r> as root directory for paths specified in -depincpath options.
  • -depincpath=<d:i> <d> is the name of the dependency. Add <i> to the header detection path list.
  • -depincpathlocal=<d:i> <d> is the name of the dependency. Add <i> to the header detection path list, where <i> is pointing to a directory local to the project and containing an embedded (aka. ‘locally hosted’) dependency.
  • -depimplibs=<d:dll> <d> is the name of the dependency. Add <dll> to the import library source list.
  • -depimplibd=<d:lib> <d> is the name of the dependency. Set generated import library name to <lib>
  • -depfinish=<d> <d> is the name of the dependency. Closes the dependency definition and does the actual dependency detection, setting all predefined filter macro variables and build options accordingly. Optional, if omitted, detection will take place after processing all options.
  • -plugin=<filename> add plugin. <filename> can be: .hb, .prg, .hrb
  • -pi=<filename> pass input file to plugins
  • -pflag=<f> pass single flag to plugins

Options below are available on command-line:

  • -target=<script> specify a new build target. <script> can be .prg (or no extension) or .hbp file. Note that .hbp files are automatically considered as separate build targets.
  • -hbrun run build target
  • -hbraw stop after running Harbour compiler
  • -hbcmp|-clipper stop after creating the object files
    create link/copy hbmk2 to hbcmp/clipper for the same effect
  • -hbcc accept raw C flags
    create link/copy hbmk2 to hbcc for the same effect
  • -hblnk accept raw linker flags
  • -autohbm[-] enable (or disable) processing of hbmk.hbm in current directory (default: yes)
  • -hb10 enable Harbour 1.0.x compatibility mode
  • -hb20 enable Harbour 2.0.x compatibility mode
  • -hb30 enable Harbour 3.0.x compatibility mode
  • -xhb enable xhb mode
  • -hbc enable pure C mode
  • -rtlink
  • -blinker
  • -exospace emulate Clipper compatible linker behavior
    create link/copy hbmk2 to rtlink/blinker/exospace for the same effect
  • -hbreg[=global] register Harbour Script (.hb) with hbmk2 (Windows only)
  • -hbunreg[=global] unregister Harbour Script (.hb) from hbmk2 (Windows only)
  • -find <text> lists all known Harbour functions that contain <text> in their name, along with their package (case insensitive, accepts multiple values, can contain wildcard characters)
  • -hbmake=<file> convert hbmake project <file> to .hbp file
  • -xbp=<file> convert .xbp (xbuild) project <file> to .hbp file
  • -xhp=<file> convert .xhp (xMate) project <file> to .hbp file
  • –hbdirbin output Harbour binary directory to stdout
  • –hbdirdyn output Harbour dynamic library directory to stdout
  • –hbdirlib output Harbour static library directory to stdout
  • –hbdirinc output Harbour header directory to stdout
  • –hbinfo[=nested] output Harbour build information to stdout. Output is in JSON format. The included paths always contain forward slashes. Each JSON block is followed by an 0x0A byte.
  • -plat=<platform> override default target platform (default: automatic)
  • -cpu=<cpu> override default target CPU (default: automatic) (EXPERIMENTAL)
  • -comp=<compiler> override C compiler autodetection
    Special value:
    – bld: use original build settings (default on *nix)
  • -build=<name> specify a build name
  • -lang=<lang> override default language. <lang> is an ISO language code.
  • -width=<n> set output width to <n> characters (0=unlimited).
  • -shl show sub-project level in output lines
  • -viewhelp long help in text viewer
  • -longhelp long help
  • -longhelpmd long help in Markdown format
  • -harbourhelp Harbour compiler help (all Harbour compiler options are accepted as is by hbmk2)
  • -credits Harbour compiler credits
  • -build Harbour compiler build information
  • -version display version header only

Options below are internal/developer ones (compatibility not guaranteed):

  • -debugtime measure time spent on the build
  • -debuginc display internals of incremental build
  • -debugstub display content of all internally generated source files
  • -debugi18n display internals on translation file generation
  • -debugdepd display internals of dependency detection
  • -debugpars display all input parameters in processing order
  • -debugrte generate a run-time error

You can sym-link/copy/rename hbmk2 to the following names to alter default mode of operation:

  • hbrun*|*hbrun mode script runner / interactive shell
  • hbrund|hbrun*d mode script runner / interactive shell in debug mode
  • harbour mode -hbraw (emulate – raw – Harbour compiler)
  • clipper mode -hbcmp (emulate Clipper compiler)
  • rtlink mode -rtlink (emulate Clipper linker)
  • exospace mode -rtlink (emulate Clipper linker)
  • blinker mode -rtlink (emulate Clipper linker)
  • *10 option -hb10
  • *20 option -hb20
  • *30 option -hb30
  • x\* option -xhb
  • hbcmp*|*hbcmp mode -hbcmp (emulate Harbour compiler producing a binary object)
  • hbcc*|*hbcc mode -hbcc (emulate C compiler)
  • hblnk*|*hblnk mode -hblnk (emulate C linker)
  • hbexe*|*hbexe mode -hbexe
  • hblib*|*hblib mode -hblib
  • hbdyn*|*hbdyn mode -hbdyn

Files:

  • *.hbp project file. Can contain any number of command-line options, which are expected to create an output. Lines beginning with ‘#’ character are ignored, otherwise newline is optional and options are space separated, just like on the command-line. You must enclose option containing space in double quotes. Each .hbp file reference will be executed as a sub-project.
  • *.hbm collection of options. Can be used to collect common ones into a file and include that into project files. Uses same format as .hbp files.
  • *.hbc collection of options that accompany components (aka ‘libs’, aka packages). Use different syntax than command-line and .hbp/.hbm files. Lines beginning with ‘#’ character are ignored, each directive must be placed in separate line.
  • *.ch if passed directly as a source file, it will be used as additional standard header
  • hbmk.hbc standard .hbc file that gets automatically processed, if present. Possible location(s) (in order of precedence) [*]: %APPDATA%\.harbour, <hbmk2 directory>
  • hbmk.hbm optional .hbm file residing in current working directory, which gets automatically processed before other options
  • $hb_pkg_dynlib.hbm special .hbm file embedded inside hbmk2. It manages the details of creating a dynamic library (in the style of Harbour contribs).
  • $hb_pkg_install.hbm special .hbm file embedded inside hbmk2. It manages the details of installing build targets and related package files to standard locations (in the style of Harbour contribs).
  • *.hb Harbour script
  • *.hrb Harbour portable binary (aka precompiled Harbour script)
  • hbstart.hb startup Harbour script for interactive Harbour shell. It gets executed automatically on shell startup, if present. Possible locations (in order of precedence) [*]: .\, %APPDATA%\.harbour, <hbmk2 directory>
  • shell plugins .hb and .hrb plugins for interactive Harbour shell. They may reside in [*]: %APPDATA%\.harbour\
  • .hb_history stores command history for interactive Harbour shell. You can disable history by making the first line ‘no’ (without quotes and with newline). Resides in [*]: %APPDATA%\.harbour\
  • hb_extension list of extensions to load in interactive Harbour shell. One extension per line, part of line beyond a ‘#’ character is ignored. Alternate filename on MS-DOS: hb_ext.ini. Resides in [*]: %APPDATA%\.harbour\

Macro variables:

  • ${hb_root} directory of hbmk2
  • ${hb_dir} directory of the filename it is used in
  • ${hb_dirname} top directory of the filename it is used in
  • ${hb_name} name of the filename it is used in (without directory and extension)
  • ${hb_self} full filename it is used in
  • ${hb_curdir} current working directory
  • ${hb_tempdir} OS directory for temporary files
  • ${hb_targetname} name of the project (without directory and extension). Returns .adhoc. if there is not project file.
  • ${hb_targettype} type of the project (hbexe, hblib, hbdyn, hbdynvm, hbimplib, hbppo, hbhrb, hbcontainer)
  • ${hb_plat} selected platform
  • ${hb_comp} selected C compiler
  • ${hb_comp_ver} C compiler version
  • ${hb_build} build name
  • ${hb_cpu} selected CPU
  • ${hb_work} default base workdir name
  • ${hb_workdynsub} default workdir subdirectory for dynamic library targets
  • ${hb_dynprefix} dynamic library prefix
  • ${hb_dynsuffix} dynamic library suffix
  • ${hb_dynext} dynamic library extension
  • ${hb_ver} Harbour version in hexadecimal triple byte format. F.e.: 030200
  • ${hb_verstr} Harbour version in human readable format <major>.<minor>.<release><status>. F.e.: 3.2.0dev
  • ${hb_major} Harbour major version number
  • ${hb_minor} Harbour minor version number
  • ${hb_release} Harbour release version number
  • ${hb_status} Harbour version status
  • ${hb_revision} Harbour revision
  • ${hb_host_plat} Harbour host platform
  • ${hb_host_plat_unix} returns ‘1’ if Harbour host platform is *nix compatible
  • ${hb_bin} Harbour binary directory
  • ${hb_lib} Harbour static library directory
  • ${hb_lib3rd} Harbour 3rd party static library directory
  • ${hb_dyn} Harbour dynamic library directory
  • ${hb_inc} Harbour header directory
  • ${hb_addons} Harbour add-ons base directory
  • ${hb_first} name of source file that holds the entry function (without directory and extension)
  • ${hb_outputdir} directory of the output
  • ${hb_outputname} name of the output (without extension)
  • ${hb_level} sub-project recursion level
  • ${<depname>} returns the header directory of dependency <depname>, or ‘1’ if it is not detected
  • ${<envvar>} returns the value of the environment variable <envvar>

Filters (you can combine and/or negate them):

  • {<platform>} target platform. Where <platform> can be any value accepted by -plat= option.
  • {<compiler>} target C compiler. Where <compiler> can be any value accepted by -comp= option.
  • {<cpu>} target CPU. Where <cpu> can be any of: x86, x86_64, ia64, arm, mips, sh
  • {<targettype>} build target type. Where <targettype> is any of the values returned by macro variable ${hb_targettype}.
  • {mt} build target is multi-threaded (see -mt option)
  • {st} build target is single-threaded (see -st option)
  • {gui} GUI target (see -gui option)
  • {std} console target (see -console option)
  • {debug} C level debugging is enabled (see -debug option)
  • {nodebug} C level debugging is disabled (see -debug- option)
  • {shared} shared build (see -shared and related options)
  • {static} static build (see -static and related options)
  • {lngcpp} forced C++ mode (see -cpp option)
  • {lngc} forced C mode (see -cpp- option)
  • {winuni} Windows UNICODE (WIDE) mode (see -winuni option)
  • {winansi} Windows ANSI mode (see -winuni- option)
  • {unix} target platform is *nix compatible (bsd, hpux, sunos, beos, qnx, android, vxworks, symbian, linux, darwin, cygwin, minix, aix)
  • {allwin} target platform is Windows compatible (win, wce)
  • {allgcc} target C compiler belongs to gcc family (gcc, mingw, mingw64, mingwarm, djgpp, gccomf, clang, open64, pcc)
  • {allmingw} target C compiler is mingw* (mingw, mingw64, mingwarm)
  • {allmsvc} target C compiler is msvc* (msvc, msvc64, msvcia64, msvcarm)
  • {allbcc} target C compiler is bcc* (bcc, bcc64)
  • {allpocc} target C compiler is pocc* (pocc, pocc64, poccarm)
  • {allicc} target C compiler is icc* (icc, iccia64)
  • {hb10} Harbour 1.0.x compatibility mode (see -hb10 option)
  • {hb20} Harbour 2.0.x compatibility mode (see -hb20 option)
  • {hb30} Harbour 3.0.x compatibility mode (see -hb30 option)
  • {xhb} xhb mode (see -xhb option)
  • {hb_ispath='<file|dir>’} filter will pass if <file> or <dir> name exists on disk.
  • {MACRO} filter will pass if ${MACRO} value is not empty and not equal to ‘0’ or ‘no’ (case insensitive)
  • {MACRO='<value>’} filter will pass if ${MACRO} value equals to <value> (case insensitive).
  • {MACRO>'<value>’} filter will pass if ${MACRO} value is larger than <value> (case insensitive).
  • {MACRO<‘<value>’} filter will pass if ${MACRO} value is smaller than <value> (case insensitive).

Predefined constants in sources:

  • __HBSCRIPT__HBMK_PLUGIN when an .hb script is compiled as hbmk2 plugin
  • __HBEXTREQ__ when an .hbx source file is present in a project (available in Harbour sources)
  • HBMK_HAS_<hbcname> when <hbcname>.hbc package is linked to the build target. The value is the version= value from the .hbc file, converted to a decimal number, which is ‘1’, if not specified. (available in Harbour sources)
  • HBMK_HAS_<depname> when <depname> dependency was detected (available in C sources)
  • __HBSCRIPT__HBSHELL when a Harbour source file is run as a shell script
  • <standard Harbour> __PLATFORM__*, __ARCH*BIT__, __*_ENDIAN__, etc…

Predefined constants in build files (they are available after ‘-depfinish=<depname>’ / ‘depfinish=<depname>’):

  • HBMK_HAS_<depname> when <depname> dependency was detected
  • HBMK_DIR_<depname> return the header directory where <depname> was detected, or empty if it was not.
  • HBMK_HAS_<depname>_LOCAL when <depname> dependency was detected in a location configured by -depincpathlocal= option

Environment variables:

  • HBMK_OPTIONS accepts any options as if they were passed in the beginning of the command-line
  • HB_PLATFORM accepts same values as -plat= option
  • HB_COMPILER accepts same values as -comp= option
  • HB_CPU accepts same values as -cpu= option
  • HB_BUILD_NAME accepts same values as -build= option
  • HB_LANG accepts same values as -lang= option
  • HB_USER_LIBS accepts same values (space separated) as -l option
  • HB_USER_LIBPATHS accepts same values (space separated) as -L option
  • HB_USER_PRGFLAGS options to be passed to Harbour compiler (before command-line options)
  • HB_USER_CFLAGS options to be passed to C compiler (before command-line options)
  • HB_USER_RESFLAGS options to be passed to resource compiler (before command-line options) (Windows only)
  • HB_USER_LDFLAGS options to be passed to linker (executable) (before command-line options)
  • HB_USER_DFLAGS options to be passed to linker (dynamic library) (before command-line options)
  • HB_USER_AFLAGS options to be passed to linker (static library) (before command-line options)
  • HB_COMPILER_VER override C compiler version autodetection (gcc and msvc compiler families only). Format: <15><00>[.<00>] = <major><minor>[.<revision>]
  • HB_CCPATH override C compiler executable directory (gcc compiler families only)
  • HB_CCPREFIX override C compiler executable prefix (gcc compiler families only)
  • HB_CCSUFFIX override C compiler executable suffix (gcc compiler families only)
  • HB_INSTALL_PREFIX override Harbour base installation directory
  • HB_INSTALL_ADDONS override Harbour base add-ons directory
  • HB_EXTENSION space separated list of extensions to load in interactive Harbour shell

.hbc directives (they should be written in separate lines):

  • echo=<msg> display <msg>
  • skip=[<msg>] skip processing the rest of the .hbc file. Display <msg>, if specified.
  • stop=[<msg>] stop the build. Display <msg>, if specified.
  • sources= add space separated list of files as input files
  • headers= add space separated list of .ch format headers as standard header
  • libs= add space separated list of libraries (see more at -l option)
  • frameworks= add space separated list of frameworks (Darwin only)
  • requests= add space separated list of symbols to force link to the build target
  • syslibs= add space separated list of libraries as system libraries (before regular libraries)
  • hbcs= embed space separated list of .hbc files. Names without the extension is accepted. These references are processed in place.
  • autohbcs= space separated list of values as in -autohbc= option
  • libpaths= space separated list of additional library paths
  • incpaths= add space separated list of additional header paths (for both Harbour and C)
  • instfiles= space separated list of values as in -instfile= option
  • instpaths= space separated list of values as in -instpath= option
  • prgflags= space separated list of values as in -prgflag= option
  • cflags= space separated list of values as in -cflag= option
  • resflags= space separated list of values as in -resflag= option
  • ldflags= space separated list of values as in -ldflag= option
  • ldflags+= space separated list of values as in -ldflag+= option
  • dflags= space separated list of values as in -dflag= option
  • dflags+= space separated list of values as in -dflag+= option
  • pflags= space separated list of values as in -pflag= option
  • psources= space separated list of values as in -pi= option
  • gui=<bool> ‘yes’ = -gui, ‘no’ = -std option
  • mt=<bool> ‘yes’ = -mt, ‘no’ = -st option
  • pic=<bool> ‘yes’ = -pic, ‘no’ = -pic- option
  • shared=<bool> ‘yes’ = -shared, ‘no’ = -static option
  • shareddef=<bool> similar to shared=, but works only if shared/static mode was not set before
  • fullstatic=<bool> ‘yes’ = -fullstatic, ‘no’ = -static option
  • debug=<bool> ‘yes’ = -debug, ‘no’ = -debug- option
  • optim= ‘yes’ = -optim, ‘no’ = -optim- option
  • nulrdd=<bool> ‘yes’ = -nulrdd, ‘no’ = -nulrdd- option
  • nodefgt=<bool> ‘yes’ = -nodefgt, ‘no’ = -nodefgt- option
  • map=<bool> ‘yes’ = -map, ‘no’ = -map- option
  • hbcppmm=<bool> ‘yes’ = -hbcpmm, ‘no’ = -hbcpmm- option
  • implib=<bool> ‘yes’ = -implib, ‘no’ = -implib- option
  • winuni=<bool> ‘yes’ = -winuni, ‘no’ = -winuni- option
  • strip=<bool> ‘yes’ = -strip, ‘no’ = -strip- option
  • run=<bool> ‘yes’ = -run, ‘no’ = -run- option
  • inc=<bool> ‘yes’ = -inc, ‘no’ = -inc- option
  • safe=<bool> ‘yes’ = -safe, ‘no’ = -safe- option
  • cpp= same as -cpp= option
  • warn= same as -warn= option
  • compr= same as -compr= option
  • head= same as -head= option
  • plugins= space separated list of hbmk2 plugins to load
  • gt=<name> same as -gt<name> option
  • gtdef=<name> set the default GT to be used
  • env= same as -env: option
  • deppkgname= same as -deppkgname= option
  • depkeyhead= same as -depkeyhead= option
  • depoptional= same as -depoptional= option
  • depcontrol= same as -depcontrol= option
  • depincroot= same as -depincroot= option
  • depincpath= same as -depincpath= option
  • depincpathlocal= same as -depincpathlocal= option
  • depimplibs= same as -depimplibs= option
  • depimplibd= same as -depimplibd= option
  • depfinish= same as -depfinish= option
  • name= package name
  • description= package description
  • version=<x.y.z> package version number, where x,y,z >= 0 <= 255. Defaults to 0.0.1, if not specified.
  • keywords= space separated list of keywords
  • licences= space separated list of licenses
  • repository= space separated list of source repository references

Plugin API:
(‘hbmk’ is the context variable received by the plugin entry function)

  • hbmk_Register_Input_File_Extension( hbmk, <cExt> ) -> NIL
    Register input file extension to be passed to plugin (by default all unknown file extensions are passed to Harbour compiler).
  • hbmk_AddInput_PRG( hbmk, <cFileName> ) -> NIL
    Add a Harbour input file to the project.
  • hbmk_AddInput_C( hbmk, <cFileName> ) -> NIL
    Add a C input file to the project.
  • hbmk_AddInput_CPP( hbmk, <cFileName> ) -> NIL
    Add a C++ input file to the project.
  • hbmk_AddInput_RC( hbmk, <cFileName> ) -> NIL
    Add a Windows resource input file to the project.
  • hbmk_AddInput_OBJ( hbmk, <cFileName> ) -> NIL
    Add a binary object file to the project.
  • hbmk_AddInput_INSTFILE( hbmk, <cFileName>, [<cGroup>] ) -> NIL
    Add a file to be installed, with an optional -instpath= group name.
  • hbmk_OutStd( hbmk, <cText> ) -> NIL
    Output text to stdout.
  • hbmk_OutErr( hbmk, <cText> ) -> NIL
    Output text to stderr.
  • hbmk_OutStdRaw( hbmk, … ) -> NIL
    Output text to stdout without any formatting.
  • hbmk_OutErrRaw( hbmk, … ) -> NIL
    Output text to stderr without any formatting.
  • hbmk_Macro( hbmk, <cMacro> ) -> <cResult>
    Evaluate hbmk2 macro expression.
  • hbmk_FNameEscape( hbmk, <cFileName> ) -> <cFileName>
    Escape/quote filename for using it as external command parameter.
  • hbmk_PathSepToTarget( hbmk, <cFileName> ) -> <cFileName>
    Convert filename to the format required for the target platform/C compiler.
  • hbmk_PathSepToForward( <cPath> ) -> <cPath>
    Convert filename to have forward slash directory separators.
  • hbmk_PathFromWorkdirToCWD( hbmk ) -> <cRelativePath>
    Return relative path of -workdir= value from current working directory.
  • hbmk_FindInPath( <cFileName>, [<xPath>], [<aExtDef>] ) -> <cFNFound> | NIL
    Find file in <xPath> (array or pathsep delimited string are accepted) with list of <aExtDef> alternate extensions (defaults to executable binaries). Returns filename if found and NIL if not.
  • hbmk_FNameDirExtSet( <cFileName>, [<cDirNew>], [<cExtNew>] ) -> <cFileName>
    Change directory and/or extension in filename.
  • hbmk_FuncNameEncode( <cFuncName> ) -> <cFuncNameEncoded>
    Encode function name according to Harbour compiler rules for forming HB_FUNC() function names in C code.
  • hbmk_StrStripQuote( <cString> ) -> <cString>
    Strip double quote enclosure from a string.
  • hbmk_ArrayToList( <aList>, [<cSeparator>] ) -> <cList>
    Convert array of strings to a string. Default separator is a single space.

Plugin variables:
(‘hbmk’ context hash items, case-sensitive, read-only unless marked otherwise)

  • “apiver” API version as an integer
  • “cSTATE” callback state. Can be: ‘init’, ‘pre_all’, ‘pre_prg’, ‘pre_res’, ‘pre_c’, ‘pre_link’, ‘pre_lib’, ‘pre_cleanup’, ‘post_build’, ‘post_all’
  • “params” array of parameters passed to plugins via -pflag=/pi= options or having an extension registered via hbmk_Register_Input_File_Extension()
  • “vars” hash of plugin custom variables. Writable, local to each plugin
  • “cPLAT” -plat value
  • “cCOMP” -comp value
  • “nCOMPVer” see HB_COMPILER_VER envvar
  • “cCPU” -cpu value
  • “cBUILD” -build= value
  • “cOUTPUTNAME” -o value
  • “cTARGETNAME” see ${hb_targetname} macro
  • “cTARGETTYPE” see ${hb_targettype} macro
  • “lREBUILD” -rebuild option status
  • “lCLEAN” -clean option status
  • “lDEBUG” -debug option status
  • “lMAP” -map option status
  • “lSTRIP” -strip option status
  • “lDONTEXEC” -traceonly option status
  • “lIGNOREERROR” -ignore option status
  • “lTRACE” -trace option status
  • “lQUIET” -q option status
  • “lINFO” -info option status
  • “lBEEP” -beep option status
  • “lRUN” -run option status
  • “lINC” -inc option status
  • “cCCPATH” see HB_CCPATH envvar
  • “cCCPREFIX” see HB_CCPREFIX envvar
  • “cCCSUFFIX” see HB_CCSUFFIX envvar
  • “cCCEXT” see HB_CCEXT envvar
  • “cWorkDir” -workdir= value
  • “nExitCode” Current exit code

Shell API available in Harbour scripts:

  • hbshell_gtSelect( [<cGT>] ) -> NIL
    Switch GT. Default [*]: ‘gtwin’
  • hbshell_Clipper() -> NIL
    Enable Clipper compatibility (non-Unicode) mode.
  • hbshell_include( <cHeader> ) -> <lSuccess>
    Load Harbour header.
  • hbshell_uninclude( <cHeader> ) -> <lSuccess>
    Unload Harbour header.
  • hbshell_include_list() -> NIL
    Display list of loaded Harbour header.
  • hbshell_ext_load( <cPackageName> ) -> <lSuccess>
    Load package. Similar to #request PP directive.
  • hbshell_ext_unload( <cPackageName> ) -> <lSuccess>
    Unload package.
  • hbshell_ext_get_list() -> <aPackages>
    List of loaded packages.
  • hbshell_DirBase() -> <cBaseDir>
    hb_DirBase() not mapped to script.
  • hbshell_ProgName() -> <cPath>
    hb_ProgName() not mapped to script.

Examples to start with hbmk2:

  • To run the interactive shell (‘dot’ prompt)
    $ hbmk2 .
  • To run a Harbour script
    $ hbmk2 myscript.hb [<parameter[s]>]

Examples to build and run Harbour portable binary (aka precompiled Harbour script):

  • To build
    $ hbmk2 -gh myscript.hb
  • To run result of above
    $ hbmk2 myscript.hrb [<parameter[s]>]

Examples to build a Harbour application:

  • To build one simple .prg
    $ hbmk2 hello.prg
  • To build multiple .prg sources into one application in incremental mode
    $ hbmk2 mymain.prg myfuncs.prg -inc
  • To build an application using a project file
    $ hbmk2 myapp.hbp
  • To build an application using incremental mode
    $ hbmk2 myapp.hbp -inc
  • To build an application which uses a contrib package or 3rd party (add-on) package that ships with an .hbc file
    $ hbmk2 myapp.prg hbct.hbc
  • To build an application which uses a raw library
    $ hbmk2 myapp.prg -lmylib -L<path_to_mylib>
  • To build an application which uses a Windows resource
    $ hbmk2 mymain.prg myres.rc
  • To build an application which links against Harbour dynamic libraries
    $ hbmk2 -shared myapp.prg
  • To build an application out of all .prg and .c sources residing in ‘source’ subdir
    $ hbmk2 -omyapp src/*.prg src/*.c

Examples to build a Harbour static library:

  • To build library ‘mylib’ from sources
    $ hbmk2 -hblib mylibsrc.prg -omylib
  • To build library ‘mylib’ from sources using incremental mode
    $ hbmk2 -hblib mylibsrc.prg -omylib -inc

Exit codes (“errorlevels”):

  • 0 no error
  • 1 unknown platform
  • 2 unknown compiler
  • 3 failed Harbour detection
  • 5 failed stub creation
  • 6 failed in compilation (Harbour, C compiler, Resource compiler)
  • 7 failed in final assembly (linker or library manager)
  • 8 unsupported
  • 9 failed to create working directory
  • 19 help
  • 10 dependency missing or disabled
  • 20 plugin initialization
  • 30 too deep nesting
  • 50 stop requested
  • <other> when -run option is used, the exit code will be the one returned by the target executable

Notes:

  • <script> can be:
    <@script> or <script.hbm>: command-line options in file
    <script.hbp>: command-line options in file, it also marks a new build target if specified on the command-line
    <script.hbc>: package configuration file
  • Source filename without extension will load the .hbp file, if such .hbp file exists in current directory. If not, .prg extension will be used.
  • Multiple -l, -L, -i and <script> parameters are accepted.
  • Regular Harbour compiler options are also accepted as is.
    (see them with -harbourhelp option)
  • hbmk.hbc option file in hbmk2 directory is always processed if it exists. On *nix platforms ~/.harbour, /etc/harbour, <base>/etc/harbour, <base>/etc are checked (in that order) before the hbmk2 directory.
  • hbmk.hbm make script in current directory is always processed if it exists.
  • Using forwards slashes is recommended in option values as directory separator, but backslashes are also equally accepted.
  • Filters are accepted in each .hbc line and most options.
    Filters can be combined using ‘&’ (and), ‘|’ (or) operators, negated by ‘!’ operator and grouped by parentheses. Ex.: {win}, {gcc}, {linux|darwin}, {win&!pocc}, {(win|linux)&!watcom}, {unix&mt&gui}, -cflag={win}-DMYDEF, -stop{dos}, -stop{!allwin}
  • Most .hbc lines (libs=, hbcs=, prgflags=, cflags=, ldflags=, libpaths=, instfiles=, instpaths=, echo=) and corresponding command-line parameters will accept macro variables. libpaths= also accepts %{hb_name} which translates to the name of the .hbc file under search.
  • Options accepting macro variables also support command substitution. Enclose command inside “, and, if the command contains space, also enclose in double quotes. Standard output of the command will be used as the value. F.e. “-cflag=`wx-config –cflags`”, or ldflags={unix&gcc}”`wx-config –libs`”.
  • When multiple build target type selection options (-hblib, -hbdyn, etc.) are specified, the first one will be significant, the rest will be silently ignored.
  • Libraries and object files built with/for CA-Cl*pper will not work with any supported platform/compiler.
  • Defaults and feature support may vary by platform/compiler.
  • GNU Make or any C compiler specific make tool and MSYS (on Windows) are not needed to run hbmk2.
  • . (dot) passed as first parameter will enter the interactive Harbour shell.
  • .hb, .hrb or .dbf file passed as first parameter will be run as Harbour script. If the filename contains no path components, it will be searched in current working directory and in PATH. If not extension is given, .hb and .hrb extensions are searched, in that order. .dbf file will be opened automatically in shared mode and interactive Harbour shell launched. Non-standard extensions will be autodetected for source and precompiled script types. Note, for Harbour scripts, the codepage is set to UTF-8 by default. The default core header ‘hb.ch’ is automatically #included. The default date format is the ISO standard: yyyy-mm-dd. The default GT is ‘gtcgi’, unless full-screen CUI calls are detected, when ‘gtwin’ [*] is automatically selected (except for INIT PROCEDUREs).
  • You can use key <Alt+V> in interactive Harbour shell to paste text from the clipboard.
  • Values marked with [*] may be host platform and/or configuration dependent. This help was generated on ‘win’ host platform.

Supported <compiler> values for each supported <platform> value:

  • linux gcc, clang, icc, watcom, sunpro, open64
  • darwin gcc, clang, icc
  • win mingw, msvc, clang, bcc, bcc64, watcom, icc, pocc, xcc, mingw64, msvc64, msvcia64, iccia64, pocc64
  • wce mingwarm, mingw, msvcarm, poccarm
  • os2 gcc, gccomf, watcom
  • dos djgpp, watcom
  • bsd gcc, clang, pcc
  • hpux gcc
  • beos gcc
  • qnx gcc
  • android gcc, gccarm
  • vxworks gcc, diab
  • symbian gcc
  • cygwin gcc
  • minix clang, gcc
  • aix gcc
  • sunos gcc, sunpro

License:

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA (or visit
their web site at http://www.gnu.org/).

License extensions:
– This source code must be kept and distributed as part
of the Harbour package and/or the placement of the tool sources
and files must reflect that it is part of Harbour Project.
– Copyright information must always be presented by
projects including this tool or help text.
– Modified versions of the tool must clearly state this
fact on the copyright screen.
– Source code modifications shall always be made available
along with binaries.
– Help text and documentation is licensed under
Creative Commons Attribution-ShareAlike 3.0:
http://creativecommons.org/licenses/by-sa/3.0/

Author:

  • Viktor Szakáts (vszakats.net/harbour)

Source : https://github.com/harbour/core/blob/master/utils/hbmk2/doc/hbmk2.en.md

For further info :

Extract Lines

/*
Extract Lines
Extract specified lines from a text file.
 
 Build script : 
 
 c:\harbour\bin\hbmk2 ExtrcLines -lhbxpp -lxhb -lhbmisc -lhbct
 
 Run : ExtrcLines <cInFile> <cKeyWord>
Original file backed-up to a unique-name folder.
 
 In this sample lines includes <cKeyword> extracted and case in-sensitive comparation made. 
 
 For different conditions you can change above line 53 :
 
 IF ! ( UPPER( cKeyWord ) $ UPPER( c1Line ) )
 
*/
PROCEDURE Main( cInFile, cKeyWord )
LOCAL oFile, c1Line, cBackFOld, cBackUpFile
 LOCAL lFirstLine := .T.
 
 SET( _SET_EOF, .F. )
 
 IF !EMPTY( cInFile )
 
 SetMode( 25, 80 )
 CLS
 
 IF !EMPTY( cKeyWord )
cBackFOld := HL_UniqFFName( ".\BackUp" )
 MakeDir( cBackFOld ) 
 
 cBackUpFile := cBackFOld + "\" + cInFile
 
 COPY FILE (cInFile) TO (cBackUpFile)
 
 IF FILE( cBackUpFile )
 oFile := TFileRead():New( cBackUpFile )
 oFile:Open()
 
 IF oFile:Error()
 QOUT( oFile:ErrorMsg( "FileRead: " ) )
 ELSE
 SET ALTE TO ( cInFile ) 
 SET ALTE ON
 WHILE oFile:MoreToRead()
 c1Line := oFile:ReadLine()
 IF ! ( UPPER( cKeyWord ) $ UPPER( c1Line ) )
 IF lFirstLine
 QQOUT( c1Line )
 lFirstLine := .F.
 ELSE
 QOUT( c1Line )
 ENDIF 
 ENDIF 
 END WHILE
 oFile:Close()
 END IF
 ELSE
 ALERT( cInFile + " file not found." )
 ENDIF FILE( cInFile )
 SET ALTE OFF
 SET ALTE TO 
 ELSE
 ALERT( " Key word not specified." )
 ENDIF !EMPTY( cKeyWord )
 ELSE
 ALERT( " Input file not specified." )
 ENDIF !EMPTY( cInFile )
 
RETURN // ExtractLines.Main()
*.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._
FUNCTION HL_UniqFFName( ; // Unique File / Folder name
 cPrefix,; 
 cExtension ) 
 
 LOCAL cRVal,;
 nFFNamLen,; 
 nIterate := 0
IF HB_ISNIL( cExtension )
 cExtension := ''
 ENDIF
 
 IF !EMPTY( cExtension ) .AND. LEFT( cExtension, 1 ) # "."
 cExtension := "." + cExtension
 ENDIF
 
 cRVal := cPrefix + NTOC( VAL( TToS( HB_DATETIME() ) ), 36 ) 
 nFFNamLen := LEN( cRVal )
WHILE HB_DIREXISTS( cRVal + cExtension ) 
 cRVal := LEFT( cRVal, nFFNamLen ) + LTRIM( STR( ++nIterate, 0 ) )
 ENDDO
cRVal += cExtension
 
RETURN cRVal // HL_UniqFFName()
*.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._.-._

Volum Info

* Harbour Example lists the volume serial numbers 
* and volum labels of all drives in the system ( PC ) 
*
* Build :
*
*          c:\harbour\bin\hbmk2 VolInfo -lhbct -lxhb -run
*
PROCEDURE Main()
   LOCAL nDrive, cDrive, nSerial, cSerial
   SetMode( 25, 80 )  
   CLS
   SETPOS( 5, 0 )
   FOR nDrive := 1 TO 26
      cDrive  := CHR( 64 + nDrive ) + ":\"
      nSerial := VolSerial( cDrive )
      IF nSerial # -1
         cSerial := NTOC( nSerial, 16 )
         ? cDrive, STUFF( cSerial, 5, 0, ":" ) + " " + GetVolInfo( cDrive )
      ENDIF
   NEXT
   @ MAXROW(), 0
   WAIT "EOF VolInfo.prg"
RETURN

HbRun

HbRun is a console interpreter and program ( command file / script file / .prg / .hrb ) runner for the Harbour Language.

It can work as interpreter when invoked without parameters or can execute xBase / Harbour source code in .prg file or compiled Harbour Portable Objects (.hrb) file given as parameter.

Type of file is recognized by extension used with <file> parameter. If not given then .hrb is used.

In other words, HbRun can be use in both interpret  and batch mode.

Regarding parameter given or not, when calling HbRun this ‘mode’ determined by program itself. If a parameter ( usually a .prg or .hrb file name ) given, program run in ‘batch’ mode, runs (executes) given script file and end. If no parameter given, program enter interpreter mode.

Using HbRun as an interpreter, may be very useful, productive, and educative for xBase programmers. Too many xBase programmers was learned everything, including   DBF file system and xBase programming language by famous “dot prompt”. Today many xBase programmers uses HbRun daily basis.

When HbRun begin, open a console screen with two basic area: status bars at top and dot prompt line at bottom.

Status bars :

 hbrunStatLines

Dot prompt is quite simple visually: a dot and a  line in inverse color beginning with a blinking cursor :

 hbRunDotPrompt

You may enter here a command to see the result.

For example “DIR” command will give a list of database (.dbf) files in current directory:

hbRun_Dir

SET COLO TO “GR+/N” command will remember you old days :

hbRun_Dir2

The DIR command can be used with DOS style “filter / skeleton” parameter :

DIR *.PRG
DIR *.*

etc.

Inspecting any table ( .dbf file ) is very simple:

USE CLIENTS
BROWSE ()

 hbrunBrowse

 Expand a little:

SET COLO TO “GB+/N”
USE CLIENTS
BROWSE( 3, 10, 24, 60 )

hbrunBrowse2

If you plan to use this snap frequently, make a .prg file (say brwclien.prg) with this three line and run it with DO command:

DO BRWCLIEN

Sometime LIST command may be better:

LIST CL_ID, CLI_SNAM, CLI_NAME, CLI_TLF

hbrun_list

 You can add FOR clause to the LIST command:

LIST CL_ID, CLI_SNAM, CLI_NAME, CLI_TLF FOR RECN() < 10

or

LIST CL_ID, CLI_SNAM, CLI_NAME, CLI_TLF FOR EMPTY( CLI_TLF )

The structure info of a table frequently requires while daily work to xBase Programmers.

Here three small programs for obtain structure info of a table. Usage is quite simple: open ( USE ) your table and enter DO <prgFileName>; for example:

USE CLIENT
DO LISTSTRU
or
DO DISPSTRU
or
DO SAVESTRU

 Notes :

-      To avoid some possible screen metric conflicts caused by default console (DOS box) settings of OS, may be useful some adjusting before invoke HbRun; such as:

MODE CON LINES=48 COLS=128

-       “?” command may be useful as a built-in calculator :

? 2*2           // 4
? 2**8          // 256
? SQRT( 81 )    // 9

-      HbRun keep a “history” for commands entered (for a limited count of commands of course). You can access (and re-enter when required) by using up and down keys. Moreover this history may be usable after re-invoke HbRun.

-      Though Harbour Language is essential, some legal Harbour commands / functions may be un-recognizable by HbRun.

-      Though some legal statements works in interpret mode, may not works in batch mode (such as Browse() ).

Last Note : No further explanation required for experienced xBase programmers; try, see and learn.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Examples :

 
/*
 DispStru.prg 

 Display structure of current table ( .dbf file ) on screen.

*/
MEMVAR ASTRUCT, NTOTLEN
IF EMPTY( ALIAS() )
   SETCOLOR( "R/N" )
   ? "No active table in the current work area !", LTRIM( STR( SELECT() ) )
ELSE 
   @ 3, 0 CLEA TO MAXROW() - 1, MAXCOL()
   aStruct := DBSTRUCT()
   nTotLen := 1
   AEVAL( aStruct, { | a1Field | nTotLen += a1Field[ 3 ] } )
   AEVAL( aStruct, { | a1Field, n1FieldNo | ;
   aStruct[ n1FieldNo ] := STR( n1FieldNo, 3 ) + " " +;
                           PADR( a1Field[ 1 ], 12 ) +;
                           PADC( a1Field[ 2 ], 4 ) +;
                           PADL( a1Field[ 3 ], 5 ) +;
                           PADL( a1Field[ 4 ], 3 ) } )
   ? "Structure of database :", DBINFO( 10 )
   ? "Number of data records :", LTRIM( STR( LASTREC() ) )
   ? "Date of last update :", LUPDATE()
   ? "Fld Name Type Width Dec"
   ? "--- ---------- ---- ----- ---"
   @ 21,0 SAY "** Total ** " + PADL( nTotLen, 6 )
   ACHOICE( 8, 0, 20, 30, aStruct ) 
ENDIF
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/*
 ListStru.prg 

 List structure of current table ( .dbf file ) on screen.

*/
MEMVAR ASTRUCT, NTOTLEN
IF EMPTY( ALIAS() )
   SETCOLOR( "R/N" )
   ? "No active table in the current work area !", LTRIM( STR( SELECT() ) )
ELSE 
   @ 3, 0 CLEA TO MAXROW() - 1, MAXCOL()
   aStruct := DBSTRUCT()
   nTotLen := 1
   AEVAL( aStruct, { | a1Field | nTotLen += a1Field[ 3 ] } ) 
   AEVAL( aStruct, { | a1Field, n1FieldNo | ;
   aStruct[ n1FieldNo ] := STR( n1FieldNo, 3 ) + " " +;
                           PADR( a1Field[ 1 ], 12 ) +;
                           PADC( a1Field[ 2 ], 4 ) +;
                           PADL( a1Field[ 3 ], 5 ) +;
                           PADL( a1Field[ 4 ], 3 ) } )
   ? "Structure of database :", DBINFO( 10 )
   ? "Number of data records :", LTRIM( STR( LASTREC() ) )
   ? "Date of last update :", LUPDATE()
   ? "Fld Name Type Width Dec"
   ? "--- ---------- ---- ----- ---"
   AEVAL( aStruct, { | c1Field | QOUT( c1Field ) } ) 
   ? "** Total ** ", PADL( nTotLen, 5 )
ENDIF
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/*
SaveStru.prg

 Save structure of current table ( .dbf file ) to a file.

 Notes :

 - This program uses ListStru.prg
 - Name of target file constructed at line 18; 
   if required you may use alternate ways or
   simply using a constant.
*/
MEMVAR AlteFName
IF EMPTY( ALIAS() )
   SETCOLOR( "R/N" )
   ? "No active table in the current work area !", LTRIM( STR( SELECT() ) )
ELSE 
   AlteFName := LEFT( ALIAS(), 4 ) + "STRU" 
   SET ALTE TO &AlteFName
   SET ALTE ON
   DO LISTSTRU
   SET ALTE OFF
   SET ALTE TO
ENDIF
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

HbMk2 : Harbour Maker

Harbour Make (hbmk2) 3.2.0dev (Rev. 18805)
Copyright (c) 1999-2013, Viktor Szakáts

http://harbour-project.org/

Syntax:

hbmk2 [options] [<script[s]>] <src[s][.prg|.c|.obj|.o|.rc|.res|.def|.po|.pot|.hbl|@.clp|.d|.ch]>

Options:
-o<outname> output file name
-l<libname> link with <libname> library. <libname> should be without
path, extension and ‘lib’ prefix (unless part of
libname). Do not add core Harbour libraries, they are
automatically added as needed.
-L<libpath> additional path to search for libraries
-i<p>|-incpath=<p> additional path to search for headers
-static|-shared link with static/shared libs
-mt|-st link with multi/single-thread Harbour VM
-gt<name> link with GT<name> GT driver, can be repeated to link
with more GTs. First one will be the default at runtime
-inc[-] enable/disable incremental build mode (default: disabled)
-hbexe create executable (default)
-hblib create static library
-hbdyn create dynamic library (without linked Harbour VM)
-hbdynvm create dynamic library
-hbimplib create import library

-gui|-std create GUI/console executable
-main=<mainfunc> override the name of starting function/procedure
-request=<func> force function/procedure to be linked
-fullstatic link with all static libs
-pic[-] create position independent object code (always enabled
in -hbdyn/-hbdynvm modes)
-[full|fix]shared create shared Harbour binaries without/with absolute dir
reference to Harbour library (default: ‘fullshared’ when
Harbour is installed on system location, ‘fixshared’
otherwise) (fix/full option in *nix only)
-nulrdd[-] link with nulrdd
-debug[-] add/exclude C compiler debug info. For Harbour level
debug, use Harbour option -b as usual
-optim[-] toggle C compiler optimizations (default: on)
-cpp[-] force C/C++ mode
-cpp=<value> select C++ mode. Allowed values are: def, yes, no
-map[-] create (or not) a map file
-implib[-] create (or not) an import library (in -hbdyn/-hbexe
mode). The name will have a postfix added.
-implib=<output> create import library (in -hbdyn/-hbexe mode) name to
<output> (default: same as output)
-ln=<link> create symbolic link pointing to <output> (<link> is
considered relative to <output>)
-strip[-] strip (no strip) binaries
-trace[-] show commands executed
-beep[-] enable (or disable) single beep on successful exit,
double beep on failure
-ignore[-] ignore errors when running compiler tools (default: off)
-hbcppmm[-] override standard C++ memory management functions with
Harbour ones
-winuni[-] select between UNICODE (WIDE) and ANSI compilation modes
(default: ANSI) (Windows only. For WinCE it is always set
to UNICODE)
-nohblib[-] do not use static core Harbour libraries when linking
-nodefgt[-] do not link default GTs (effective in -static mode)
-nolibgrouping[-] disable library grouping on gcc based compilers
-nomiscsyslib[-] do not add extra list of system libraries to default
library list
-traceonly show commands to be executed, but do not execute them
-warn=<lev> set C compiler warning level
<lev> can be: max, yes, low, no, def (default: yes)
-compr=<lev> compress executable/dynamic lib (needs UPX)
<lev> can be: yes, no, min, max
-run[-] run/do not run output executable
-vcshead=<file> generate .ch header file with local repository
information. SVN, CVS, Git, Mercurial, Bazaar, Fossil and
Monotone are currently supported. Generated header will
define macro _HBMK_VCS_TYPE_ with the name of detected
VCS and _HBMK_VCS_ID_ with the unique ID of local
repository
-tshead=<file> generate .ch header file with timestamp information.
Generated header will define macros _HBMK_BUILD_DATE_,
_HBMK_BUILD_TIME_, _HBMK_BUILD_TIMESTAMP_ with the
date/time of build
-icon=<file> set <file> as application icon. <file> should be a
supported format on the target platform
-manifest=<file> embed manifest <file> in executable/dynamic lib (Windows
only)
-sign=<key> sign executable with <key> (Windows and Darwin only)
-signpw=<pw> use <pw> as password when signing executable (Windows and
Darwin only)
-instfile=<g:file> add <file> in to the list of files to be copied to path
specified by -instpath option. <g> is an optional copy
group (case sensitive), it must be at least two
characters long. In case you don’t specify <file>, the
list of files in that group will be emptied.
-instpath=<g:path> copy target to <path>. if <path> is a directory, it
should end with path separatorm, in this case files
specified by -instfile option will also be copied. can be
specified multiple times. <g> is an optional copy group,
it must be at least two characters long. Build target
will be automatically copied to default (empty) copy
group.
-instforce[-] copy target to install path even if it is up to date
-depimplib[-] enable (or disable) import library generation for import
library sources specified in -depimplibs= options
(default: yes)
-stop[=<text>] stop without doing anything and display <text> if
specified
-echo=<text> echo text on screen
-pause force waiting for a key on exit in case of failure (with
alternate GTs only)
-info turn on informational messages
-quiet[-] suppress all screen messages

-bldf[-] inherit all/no (default) flags from Harbour build
-bldf=[p][c][l] inherit .prg/.c/linker flags (or none) from Harbour build
-F<framework> link with <framework> framework (Darwin only)
-cflag=<f> pass single flag to C compiler
-resflag=<f> pass single flag to resource compiler (Windows only)
-ldflag=<f> pass single flag to linker (executable)
-aflag=<f> pass single flag to linker (static library)
-dflag=<f> pass single flag to linker (dynamic library)
-iflag=<f> pass single flag to import library creation command
-prgflag=<f> pass single flag to Harbour compiler
-runflag=<f> pass single flag to output executable when -run option is
used
-cflag+=<f> pass single flag to C compiler overriding C compiler
flags added by hbmk2 itself. Use with caution.
-3rd=<f> options/flags reserved for 3rd party tools, always
ignored by hbmk2 itself
-env:<e>[<o>[<v>]] alter local environment. <e> is the name of the
environment variable to alter. <o> can be ‘=’ to
set/override, ‘-‘ to delete, ‘+’ to append to the end of
existing value, ‘#’ to insert to the beginning of
existing value. <v> is the value to set/append/insert.
-jobs=<n> start n compilation threads (multiprocess platforms only)
-head=<m> control source header parsing (in incremental build mode)
<m> can be: native (uses compiler to extract
dependencies), full (default, uses simple text parser on
the whole file), dep, off
-rebuild rebuild (in incremental build mode)
-rebuildall rebuild with sub-projects (in incremental build mode)
-clean clean (in incremental build mode)
-workdir=<dir> working directory
(default: .hbmk/plat/comp in incremental mode, OS temp
directory otherwise)

-hbl[=<output>] output .hbl filename. %{hb_lng} macro is accepted in
filename
-lng=<languages> list of languages to be replaced in %{hb_lng} macros in
.pot/.po filenames and output .hbl/.po filenames. Comma
separared list:
-lng=en,hu-HU,de
-po=<output> create/update .po file from source. Merge it with
previous .po file of the same name
-minipo[-] do (not) add Harbour version number and source file
reference to .po (default: add them)
-rebuildpo recreate .po file, thus removing all obsolete entries in
it

-hbx=[<.ch>] Create Harbour header (in .hbx format) with all external
symbols. Empty parameter will disable it.
-autohbc=<.ch:.hbc> <.ch> is a header file name. <.hbc> is a .hbc filename to
be automatically included in case the header is found in
any of the compiled sources. (EXPERIMENTAL)

-deppkgname=<d:n> <d> is the name of the dependency. <n> name of the
package depedency. Can be specified multiple times.
-depkeyhead=<d:h> <d> is the name of the dependency. <h> is the key header
(.h) of the package dependency. Multiple alternative
headers can be specified.
-depoptional=<d:f> <d> is the name of the dependency. <f> can be ‘yes’ or
‘no’, specifies whether the dependency is optional.
Default: no
-depcontrol=<d:v> <d> is the name of the dependency. <v> is a value that
controls how detection is done. Accepted values: no, yes,
force, nolocal, local. Default: content of envvar
HBMK_WITH_<d>
-depincroot=<d:r> <d> is the name of the dependency. Set <r> as root
directory for paths specified in -depincpath options.
-depincpath=<d:i> <d> is the name of the dependency. Add <i> to the header
detection path list.
-depincpathlocal= <d> is the name of the dependency. Add <i> to the header
<d:i> detection path list, where <i> is pointing to a directory
local to the project and containing an embedded (or
locally hosted) dependency.
-depimplibs=<d:dll> <d> is the name of the dependency. Add <dll> to the
import library source list.
-depimplibd=<d:lib> <d> is the name of the dependency. Set generated import
library name to <lib>

-plugin=<filename> add plugin. <filename> can be: .hb, .prg, .hrb
-pi=<filename> pass input file to plugins
-pflag=<f> pass single flag to plugins

Options below are available on command line only:

-target=<script> specify a new build target. <script> can be .prg (or no
extension) or .hbp file. Note that .hbp files are
automatically considered as separate targets.

-hbrun run target
-hbraw stop after running Harbour compiler
-hbcmp|-clipper stop after creating the object files
create link/copy hbmk2 to hbcmp/clipper for the same
effect
-hbcc accept raw C flags
create link/copy hbmk2 to hbcc for the same effect
-hblnk accept raw linker flags
-autohbm[-] enable (or disable) processing of hbmk.hbm in current
directory (default: yes)
-hb10 enable Harbour 1.0.x compatibility mode
-hb20 enable Harbour 2.0.x compatibility mode
-xhb enable xhb mode
-hbc enable pure C mode
-rtlink
-blinker
-exospace emulate Clipper compatible linker behavior
create link/copy hbmk2 to rtlink/blinker/exospace for the
same effect

-hbreg[=global] register Harbour Script (.hb) with hbmk2 (Windows only)
-hbunreg[=global] unregister Harbour Script (.hb) from hbmk2 (Windows only)

-hbmake=<file> convert hbmake project <file> to .hbp file
-xbp=<file> convert .xbp (xbuild) project <file> to .hbp file
-xhp=<file> convert .xhp (xMate) project <file> to .hbp file

–hbdirbin output Harbour binary directory
–hbdirdyn output Harbour dynamic library directory
–hbdirlib output Harbour static library directory
–hbdirinc output Harbour header directory
–hbinfo[=nested] output Harbour build information. Output is in JSON
format. The included paths always contain forward
slashes. Each JSON block is followed by an 0x0A byte.

-plat=<platform> force/select target platform (default: autodetection)
-comp=<compiler> force/select C compiler (default: autodetection)
Special value:
– bld: use original build settings (default on *nix)
-cpu=<cpu> select target CPU. (EXPERIMENTAL)
-build=<name> use a specific build name
-lang=<lang> override default language. Similar to HB_LANG envvar.
-width=<n> set output width to <n> characters (0=unlimited).
-shl show sub-project level in output lines
–version display version header only

Notes:
– <script> can be:
<@script> or <script.hbm>: command line options in file
<script.hbp>: command line options in file, it also marks a new target if
specified on the command line
<script.hbc>: package configuration file
– Multiple -l, -L, -i and <script> parameters are accepted.
– Regular Harbour compiler options are also accepted.
(see them with -harbourhelp option)
– hbmk.hbc option file in hbmk2 directory is always processed if it exists.
On *nix platforms ~/.harbour, /etc/harbour, <base>/etc/harbour, <base>/etc
are checked (in that order) before the hbmk2 directory.
– hbmk.hbm make script in current directory is always processed if it exists.
– .hbc options (they should come in separate lines): libs=[<libname[s]>],
hbcs=[<.hbc file[s]>], gt=[gtname], syslibs=[<libname[s]>],
frameworks=[<framework[s]>], prgflags=[Harbour flags], cflags=[C compiler
flags], resflags=[resource compiler flags], ldflags=[linker flags],
pflags=[flags for plugins], libpaths=[paths], sources=

,
headers=[Harbour header files], psources=

,
incpaths=[paths], requests=[func], instfiles=[files], instpaths=[paths],
autohbcs=[<.ch>:<.hbc>], plugins=[plugins],
gui|mt|pic|shared|nulrdd|nodefgt|debug|opt|map|strip|hbcppmm|winuni|implib|
run|inc=[yes|no], cpp=[yes|no|def], warn=[max|yes|low|no|def],
compr=[yes|no|min|max], head=[off|full|native|dep], skip=<reason>,
stop=<reason>, echo=<text>
Lines starting with ‘#’ char are ignored
– Platform filters are accepted in each .hbc line and with several options.
Filter format: {[!][<plat>|<comp>|<cpu>|<keyword>]}. Filters can be
combined using ‘&’, ‘|’ operators and grouped by parentheses. Ex.: {win},
{gcc}, {linux|darwin}, {win&!pocc}, {(win|linux)&!watcom}, {unix&mt&gui},
-cflag={win}-DMYDEF, -stop{dos}, -stop{!allwin},
{allwin|allmsvc|allgcc|allmingw|allicc|allbcc|allpocc|unix},
{x86|x86_64|ia64|arm|mips|sh},
{debug|nodebug|gui|std|mt|st|shared|static|winuni|winansi|xhb}
– Certain .hbc lines (libs=, hbcs=, prgflags=, cflags=, ldflags=, libpaths=,
instfiles=, instpaths=, echo=) and corresponding command line parameters
will accept macros: ${hb_root}, ${hb_dir}, ${hb_dirname}, ${hb_name},
${hb_self}, ${hb_curdir}, ${hb_tempdir}, ${hb_targetname},
${hb_targettype}, ${hb_plat}, ${hb_comp}, ${hb_comp_ver}, ${hb_build},
${hb_cpu}, ${hb_work}, ${hb_workdynsub}, ${hb_dynprefix}, ${hb_dynsuffix},
${hb_dynext}, ${hb_ver}, ${hb_verstr}, ${hb_major}, ${hb_minor},
${hb_release}, ${hb_status}, ${hb_revision}, ${hb_host_plat},
${hb_host_plat_unix}, ${hb_bin}, ${hb_lib}, ${hb_lib3rd}, ${hb_dyn},
${hb_inc}, ${hb_first}, ${hb_outputdir}, ${hb_outputname}, ${hb_level},
${<envvar>}. libpaths= also accepts %{hb_name} which translates to the name
of the .hbc file under search.
– Options accepting macros also support command substitution. Enclose command
inside “, and, if the command contains space, also enclose in double
quotes. F.e. “-cflag=`wx-config –cflags`”, or
ldflags={unix&gcc}”`wx-config –libs`”.
– Libraries and object files built with/for CA-Cl*pper won’t work with any
supported platform/compiler.
– Defaults and feature support may vary by platform/compiler.
– Options can also be specified in environment variable HBMK_OPTIONS
– .hb or .hrb file passed as first parameter will be run as Harbour script.
Note, for Harbour scripts, the codepage is set to UTF-8 by default.
– . (dot) passed as first parameter will enter the interactive Harbour shell.

Supported <comp> values for each supported <plat> value:
– linux : gcc, clang, icc, watcom, sunpro, open64
– darwin : gcc, clang, icc
– win : mingw, msvc, clang, bcc, bcc64, watcom, icc, pocc, xcc,
mingw64, msvc64, msvcia64, iccia64, pocc64
– wce : mingwarm, mingw, msvcarm, poccarm
– os2 : gcc, gccomf, watcom
– dos : djgpp, watcom
– bsd : gcc, clang, pcc
– hpux : gcc
– beos : gcc
– qnx : gcc
– android : gcc, gccarm
– vxworks : gcc, diab
– symbian : gcc
– cygwin : gcc
– minix : gcc, clang, ack
– aix : gcc
– sunos : gcc, sunpro

For further info :

 

 

 

Harbour Utilities / Tools

Harbour :

Harbour  : Harbour compiler

 HbFormat : Formats the source code according to certain criteria

HbIDE  : Visual Development environment for the Harbour and other xBase dialects

Hbi18n : A tool that makes finding applications for other languages

HbMk2    : Ultimate project maker for Harbour applications

HbNetIO  : Harbour NETIO Server

HbPP   : Harbour preprocessor

HbRun  : Console interpreter and .prg/.hrb runner for the Harbour Language

HbTest   : Harbour Regression Test Suite

3rth Party:

rcc.exe  : Qt resource compiler

uic.exe  : Qt User Interface Compiler

upx.exe  : Ultimate Packer for eXecutables

windres  : Resource compiler

Some usage tips

Harbour.exe

Harbour 3.2.0dev (Rev. 18805)
Copyright (c) 1999-2013, http://harbour-project.org/
Syntax:  c:\harbour\bin\harbour.exe <file[s][.prg]|@file> [options]
Options:  /a               automatic memvar declaration
          /b               debug info
          /build           display detailed version info
          /credits         display credits
          /d<id>[=<val>]   #define <id>
          /es[<level>]     set exit severity
          /fn[:[l|u]|-]    set filename casing (l=lower u=upper)
          /fd[:[l|u]|-]    set directory casing (l=lower u=upper)
          /fp[:<char>]     set path separator
          /fs[-]           turn filename space trimming on or off (default)
          /g<type>         output type generated is <type> (see below)
          /gc[<type>]      output type: C source (.c) (default)
                           <type>: 0=compact (default) 1=normal 2=verbose
                                   3=generate real C code
          /gh              output type: Harbour Portable Object (.hrb)
          /gd[.<destext>]  generate dependencies list into (.d) file
          /ge[<mode>]      error output <mode>: 0=Clipper (default)
                                                1=IDE friendly
          /i<path>         #include file search path
          /i[-|+]          disable/enable support for INCLUDE envvar
          /j[<file>]       generate i18n gettext file (.pot)
          /k               compilation mode (type -k? for more data)
          /l               suppress line number information
          /m               compile module only
          /n[<type>]       no implicit starting procedure
                           <type>: 0=no implicit starting procedure
                                   1=no starting procedure at all
                                   2=add starting procedure if necessary
          /o<path>         object file drive and/or path
          /p[<path>]       generate pre-processed output (.ppo) file
          /p+              generate pre-processor trace (.ppt) file
          /q               quiet
          /q0              quiet and don't display program header
          /q2              disable all output messages
          /r:<max>         set maximum number of preprocessor iterations
          /s[m]            syntax check only [minimal for dependencies  
                           list]
          /u[<file>]       use command def set in <file> (or none)
          /u+<file>        add command def set from <file>
          /undef:<id>      #undef <id>
          /v               variables are assumed M->
          /w[<level>]      set warning level number (0..3, default 1)
          /x[<prefix>]     set symbol init function name prefix (for .c
                           only)
          /z               suppress shortcutting (.and. & .or.)
          @<file>          compile list of modules in <file>

Note : After HbMk2, direct use of Harbour.exe not required.

HbFormat.exe

Harbour Source Formatter 3.2.0dev (Rev. 18770)

Copyright (c) 2009-2012, Alexander S.Kresin
http://harbour-project.org/
Syntax:  hbformat [options] [@config] <file[s]>

C:\Harbour\contrib\hbformat\utils\hbformat.ini:
#
# $Id: hbformat.ini 18847 2013-02-13 22:33:19Z vszakats $
#
# Eol: -1 - no change, 0 - OS default, 1 - DOS, 2 - UNIX
#nEol = -1
# If true, convert file name to lower case
#lFCaseLow = no
# If yes, converts all tabs to spaces
#lNoTabs = yes
# If yes, indent code
#lIndent = yes
# If yes, make case conversion
#lCase = yes
# If yes, reformat spaces
#lSpaces = yes
# If yes, indent "Function", "Procedure", "Class", "Method"
#lIndFunc = no
# If yes, indent "Local", "Private", etc. in a function beginning
#lIndVar = yes
# If yes, indent directives
#lIndDrt = no
# If yes, indent "Return"
#lIndRet = yes
# Leftmost indent - amount of spaces
#nIndLeft = 3
# indent - amount of spaces
#nIndNext = 3
# Indent for continuation ( after ';' ) lines - amount of spaces
#nIndCont = 3
# If yes, convert asterisk '*' to '//'
#lCnvAst = yes
# If yes, convert '&&' to '//'
#lCnvAmp = yes
# Number of spaces after /* and // comments ( -1 - no change )
#nSpaceComment = 1
# If yes, convert .NOT. TO !
#lCnvNot = yes
# Case of commands ( -1 - no change, 1 - upper, 2 - lower, 3 - title )
#nCaseCmd = 1
# Case of boolean operators ( -1 - no change, 1 - upper, 2 - lower, 3 - title )
#nCaseBoo = 1
# Case of functions ( -1 - no change, 1 - upper, 2 - lower, 3 - title, 4 - as in pattern )
#nCaseFnc = 4
# Case of functions ( -1 - no change, 1 - upper, 2 - lower, 3 - title )
#nCaseUnk = -1
# Case of directives ( -1 - no change, 1 - upper, 2 - lower, 3 - title )
#nCaseDrt = 2
# Number of spaces after # in directives ( -1 - no change )
#nSpaceDrt = 0
# -1 - no change, 1 - insert empty line before a function ( procedure,class ) declaration, 2 - remove it
#nLineFnc = 1
# -1 - no change, 1 - insert empty line before return, 2 - remove it
#nLineRet = 1
# -1 - no change, 1 - insert empty line before variables declaration, 2 - remove it
#nLineVar = 1
# -1 - no change, 1 - insert empty line before code in function, 2 - remove it
#nLineCode = 1
# Max level of nesting in brackets, while space is added after a comma
#nBr4Comma = 1
# Max level of nesting in brackets, while space is added after/before a bracket
#nBr4Brac = 2
# Extension for a formatted file ( if empty - replace original )
#cExtSave =
# Extension for a backup file
#cExtBack = bak
# List of space separated .hbx files for specifying proper casing of function names
#cHBXList =

Hbi18n.exe

Internationalization (sometimes shortened to “I18N , meaning “I – eighteen letters -N”) is the process of planning and implementing products and services so that they can easily be adapted to specific local languages and cultures, a process called localization . The internationalization process is sometimes called translation or localization enablement .

Harbour i18n .pot/.hbl file manager 3.2.0dev (Rev. 18770)
Copyright (c) 2009-2013, Przemyslaw Czerpak
http://harbour-project.org/
Syntax: hbi18n -m | -g | -a [-o<outfile>] [-e] [-q] <files1[.pot] ...>
    -m          merge given .pot files
    -g          generate .hbl file from given .pot files
    -a          add automatic translations to 1-st .pot file using
                translations from other .pot or .hbl files
    -o<outfile> output file name
                default is first .pot file name with
                .po (merge) or .hbl extension
    -e          do not strip empty translation rules from .hbl files
    -q          quiet mode

HbIDE : Visual Development environment for the Harbour and other xBase dialects

HbIDE

HbNetIO.exe

Harbour NETIO Server 3.2.0dev (Rev. 17976)
Copyright (c) 2009-2012, Przemyslaw Czerpak, Viktor Szakats
http://harbour-project.org/

HbPP.exe

Harbour Preprocessor 3.2.0dev
Copyright (c) 1999-2013, http://harbour-project.org/
 Syntax:  c:\harbour\bin\hbpp <file[.prg]> [options]
 Options:  -d<id>[=<val>]        #define <id>
          -e[<func>]            use <func> as entry function in generated .c
          -i<path>              add #include file search path
          -u[<file>]            use command def set in <file> (or none)
          -c[<file>]            look for ChangeLog file
          -o<file>              creates .c file with PP rules
          -v<file>              creates .h file with version information
          -w                    write preprocessed (.ppo) file
          -q[012]               disable information messages

Note:  if neither -o nor -v is specified then -w is default action

HbTest.exe

Harbour Regression Test Suite
Copyright (c) 1999-2013, Viktor Szakats
http://harbour-project.org/

Syntax:  hbtest [options]

Options:  -h, -?        Display this help.
          -all          Display all tests, not only the failures.
          -skip:<list>  Skip the listed test numbers.

 

3rth Party :

 rcc.exe  : ( Qt resource compiler )

Enter  rcc -? for options.

uic.exe  : ( Qt User Interface Compiler )

Enter  uic –help for options.

UPX.exe (Ultimate Packer for eXecutables)

Enter  upx -? for options.

windres  : ( Resource compiler )

Enter  windres3011 –help for options.

Parsing Text – Tokens

/*
From Harbour changelog (at 2007-04-04 10:35 UTC+0200 By Przemyslaw Czerpak )
Added set of functions to manipulate string tokens:
HB_TOKENCOUNT( <cString>, [ <cDelim> ], [ <lSkipStrings> ],
 [ <lDoubleQuoteOnly> ] ) -> <nTokens>

 HB_TOKENGET( <cString>, <nToken>, [ <cDelim> ], [ <lSkipStrings> ],
 [ <lDoubleQuoteOnly> ] ) -> <cToken>

 HB_TOKENPTR( <cString>, @<nSkip>, [ <cDelim> ], [ <lSkipStrings> ],
 [ <lDoubleQuoteOnly> ] ) -> <cToken>

 HB_ATOKENS( <cString>, [ <cDelim> ], [ <lSkipStrings> ],
 [ <lDoubleQuoteOnly> ] ) -> <aTokens>

 All these functions use the same method of tokenization. They can
 accept as delimiters string longer then one character. By default
 they are using " " as delimiter. " " delimiter has special mening

 Unlike other delimiters repeted ' ' characters does not create empty
 tokens, f.e.: 

 HB_ATOKENS( " 1 2 3 " ) returns array:
 { "1", "2", "3" }

 Any other delimiters are restrictly counted, f.e.:

 HB_ATOKENS( ",,1,,2,") returns array:
 { "", "", "1", "", "2", "" }
And a strong suggession made at 2009-12-09 21:25 UTC+0100 ( By Przemyslaw Czerpak )
I strongly suggest to use hb_aTokens() and hb_token*() functions.
 They have more options and for really large data many times
 (even hundreds times) faster.

*/
#define CRLF HB_OsNewLine()
PROCEDURE Main()
LOCAL cTextFName := "Shakespeare.txt",;
 c1Line 

 SET COLO TO "W/B"
 SetMode( 40, 120 )

 CLS

 HB_MEMOWRIT( cTextFName,;
 "When in eternal lines to time thou grow'st," + CRLF + ;
 "So long as men can breathe, or eyes can see," + CRLF + ;
 "So long lives this, and this gives life to thee." )

 aLines := HB_ATOKENS( MEMOREAD( cTextFName ), CRLF )

 ?
 ? "Text file line by line :"
 ?
 AEVAL( aLines, { | c1Line | QOUT( c1Line ) } )
 ?
 WAIT "Press a key for parsing as words"
 CLS
 ?
 ? "Text file word by word :"
 ?
 FOR EACH c1Line IN aLines
 a1Line := HB_ATOKENS( c1Line ) 
 AEVAL( a1Line, { | c1Word | QOUT( c1Word ) } )
 NEXT 
 ?
 WAIT "Press a key for parsing directly as words"
 CLS
 ?
 ? "Text file directly word by word :"
 ?
 aWords := HB_ATOKENS( MEMOREAD( cTextFName ) )
 AEVAL( aWords, { | c1Word | QOUT( c1Word ) } ) 

 ?
 @ MAXROW(), 0
 WAIT "EOF TP_Token.prg" 

RETURN // TP_Token.Main()
 TP_Token

Parsing Text – FParse()

/*
FParse()
Parses a delimited text file and loads it into an array.
Syntax :
FParse( <cFileName>, <cDelimiter> ) --> aTextArray
Arguments :
<cFileName> : This is a character string holding the name of the text file to load 
 into an array. It must include path and file extension. 
 If the path is omitted from <cFileName>, 
 the file is searched in the current directory. 

 <cDelimiter> : This is a single character used to parse a single line of text. 
 It defaults to the comma.
Return :
The function returns a two dimensional array, or an empty array when the file 
cannot be opened. 

Description :

 Function FParse() reads a delimited text file and parses each line 
 of the file at <cDelimiter>. The result of line parsing is stored in an array.
This array, again, is collected in the returned array, 
 making it a two dimensional array
FParse() is mainly designed to read the comma-separated values (or CSV) file format, 
 were fields are separated with commas and records with new-line character(s). 

Library is : xHb 

*/
#define CRLF HB_OsNewLine()
PROCEDURE Main()
LOCAL cTextFName := "Shakespeare.txt",;
      a1Line 

 SET COLO TO "W/B"
 SetMode( 40, 120 )

 CLS

 HB_MEMOWRIT( cTextFName,;
              "When in eternal lines to time thou grow'st," + CRLF + ;
              "So long as men can breathe, or eyes can see," + CRLF + ;
              "So long lives this, and this gives life to thee." )

 aLines := FParse( cTextFName, " " )

 ?
 ? "Text file word by word :"
 ?
 FOR EACH a1Line IN aLines
    AEVAL( a1Line, { | c1Word | QOUT( c1Word ) } )
 NEXT 
 ?
 @ MAXROW(), 0
 WAIT "EOF TP_FParse.prg" 

RETURN // TP_FParse.Main()

TP_FParse