* unprincipled metaprogramming: any metaprogramming facility whereby module-level elements (e.g. delcarations, code, modules themselves) may partake in Turing-complete transformations (hence precluding complete analysis), may generate unsound code (i.e. what would be a compile-time error), or may modify code at run-time (i.e. through dynamic scope or global mutation).
* principled metaprogramming: not the above; i.e., all code transformations terminate (allowing automatic analysis), all generated code is syntactically sound (mostly this means not having to worry about escaping stuff), and code transformations don't modify existing code.
There are probably other things and some exceptions, but that's the jist of it.
eval(), C++ templates, C macros, and prototypes are all examples of unprincipled metaprogramming.
Parametric modules (OCaml), hygienic macros (Racket), and multistage programming (MetaOCaml almost) are all examples of principled metaprogramming. (I say "almost" for MetaOCaml because code generation expressions may not terminate; but this is neither required nor encouraged, and it is easy to guard against.)
I think only OCaml functors really qualify to what you call "principled", but then - it's not the most powerful kind of metaprogramming I've seen.
For example, in terms of this macro system, you can (and you could for a long time) define a simplest non-terminating macro like this:
(define-syntax loop
(syntax-rules ()
((loop) (loop))))
Racket Macro Stepper gives a following warning when used to step through the macro expansion: Macro expansion has taken a suspiciously large number of steps.
Click Stop to stop macro expansion and see the steps taken so far, or
click Continue to let it run a bit longer.