About hb_ProcessOpen()

[Pete]

Hi all,

I have some ambiguities about hb_ProcessOpen()

hProcess := hb_ProcessOpen( cCommand, StdInput, @StdOut, @ErrOut,
lDetached )

As i understand it (please correct if wrong):

cCommand -> the command (program etc) that will be executed

StdInput -> from where the command (expect to) get input ?? (could it
be a file/screen/port?)

StdOut -> var to get command's standar output

ErrOut -> var to get command's errors output

lDetached -> show or hide command's execution window

Some Questions:
- the parent program waits until cCommand finish or not?
- if cCommand calls a second command/program the output of this second
command/program will be redirected/cached into StdOut/ErrOut vars?

- what is the purpose of HB_PROCESSVALUE(hProcess) , i mean, what it
returns (some error code or what?) and how it could exploited.

- HB_PROCESSCLOSE(hProcess) has to be invoked to terminate
hb_ProcessOpen() or the process is terminated when cCommand finishes?

Any help would be greatly appreciated.

---
Pete

[Juan L. Gamero]

Pete:

Take a look at this Changelog entry:

2009-01-13 14:07 UTC+0100 Przemyslaw Czerpak (druzus/at/priv.onet.pl)

(NOTE: HB_openProcess() and HB_closeProcess() where later renamed to HB_ProcessOpen() and HB_ProcessClose().

These are the current syntax:

HB_ProcessOpen( <cCommand>, [ @<cStdIn>, @<cStdOut>, @<cStdErr>, <lDetach>, @<nProcId> ] ) -> <hProcess>

HB_ProcessValue( <hProcess>, <lWait> ) -> <nResult>

HB_ProcessClose( <hPorcess>, <lGentle> ) -> <lResult>

HB_ProcessRun( <cCommand>, [ <cStdIn> ], [ @<cStdOut> ], [ @<cStdErr> ], [ <lDetach> ] ) -> <nResult>

Hope it helps.

--

Juan Luis

[Pete]

On Mar 26, 4:59 pm, "Juan L. Gamero" <jlgam...@gmail.com> wrote:
> Pete:
>
> Take a look at this Changelog entry:

Hi Juan,

Thank you very much, for your reply which at least testifies your
willingness to help.
Yet, i haven't figured out much things regarding to the specific
questions of my previous post.

(It seems that either, nobody of the readers in this list does use the
hb_ProcessOpen() function
or maybe nobody has time/interest to share his/her knowledge.)

I think that I have left with no other choice than the "try and error"
method of learning.

regards,

---
Pete

[Juan L. Gamero]

Pete:

I'm sorry I can't help you further with this hb_process* functions.

Only a little correction to the functions reference:

HB_ProcessOpen( cCommand [, @hStdIn, @hStdOut, @hStdErr, lDetach, @nProcId ] ) -> hProcess (hStdIn, hStdOut and hStdErr will store HANDLES)

HB_ProcessValue( hProcess, lWait ) -> nResult

HB_ProcessClose( hProcess, lGentle ) -> lResult

HB_ProcessRun( cCommand [, cStdIn, @cStdOut, @cStdErr, lDetach ] ) -> nResult (cStdIn, cStdOut, cStdErr will store string BUFFERS) Also you can take a look at hbmk2.prg in utils/hbmk2 folder, specially the hbmk_hb_processRunCatch() function wich uses the functions you ask for. Regards, -- Juan Luis

[Óscar Hernández Suárez]

Hello.

This is an proof of concept of using an interface to communicate with a Java application using JSON.

----8<----

REQUEST HB_GT_STD_DEFAULT

PROCEDURE Main()

   LOCAL hProcess

   LOCAL hStdIn

   LOCAL hStdOut

   LOCAL hStdErr

   LOCAL nSize := 1024

   LOCAL cBuffer

   LOCAL nReadedErr

   LOCAL nReadedOut

   LOCAL hInput := { => }

   LOCAL n

   LOCAL hPerson

   LOCAL hDecode

   LOCAL cInput

   LOCAL cError := ""

   LOCAL cOutput := ""

   hInput[ "id" ] := 1001

   hInput[ "list" ] := {}

   FOR n := 1 TO 1000

      hPerson := { => }

      hPerson[ "name" ] := "John"

      hPerson[ "surname" ] := "Smith" + Chr( 13 ) + Chr( 10 ) + " and Smith"

      AAdd( hInput[ "list" ], hPerson )

   NEXT

   ? 

   BEGIN SEQUENCE

   cInput := hb_JsonEncode( hInput, .f. ) + Chr( 10 )

   ? "INPUT:", Len( cInput )

   hProcess := hb_processOpen( "java.exe -cp JSON.jar;. HJAVA", @hStdIn, @hStdOut, @hStdErr, .t. )

   ? "WRITE:", FWrite( hStdIn, cInput )

   DO WHILE .T.

      ? "WAITING..."

      cBuffer := Space( nSize )

      nReadedErr := hb_PRead( hStdErr, @cBuffer, nSize, 0 )

      IF nReadedErr > 0

         cErr += Left( cBuffer, nReadedErr )

      ENDIF

      cBuffer := Space( nSize )

      nReadedOut := hb_PRead( hStdOut, @cBuffer, nSize, 0 )

      IF nReadedOut > 0

         cOutput += Left( cBuffer, nReadedOut )

      ENDIF

      IF nReadedErr < 0 .AND. nReadedOut < 0

EXIT

      ENDIF

   ENDDO

   IF Len( cOutput ) > 0

      hDecode := { => }

      hb_JsonDecode( cOutput, @hDecode )

      ? hb_JsonEncode( hDecode, .t. )

   ENDIF

   IF Len( cError ) > 0

      ? cError

   ENDIF

   ALWAYS

   hb_processClose( hProcess, .t. ) // kill if needed

   ? "ret=" + hb_ntos( hb_processValue( hProcess ) ) // wait and return exit code

   FClose( hStdIn )

   FClose( hStdOut )

   FClose( hStdErr )

   END SEQUENCE

   RETURN

---->8----

Source "HJAVA.java":

----8<---- 

import java.util.Scanner; // JRE 1.5

import org.json.JSONObject;

import org.json.JSONException;

class HJAVA

{

   public static void main( String[] args )

   {

      Scanner scanner = new Scanner( System.in );

      String line = scanner.nextLine();

      String result;

      try

      {

         JSONObject json = new JSONObject( line );

         json.put( "status", 200 );

         json.put( "status_text", "OK" );

          

         resultado = json.toString();

      }

      catch ( JSONException e )

      {

         try

         {

            JSONObject json = new JSONObject();

            json.put( "status", 500 );

            json.put( "status_text", e.toString() );

         

            result = json.toString();

         }

         catch ( JSONException ee )

         {

            result = "";

         }

      }

      System.out.print( result );

      System.exit( 0 );

   }

}

---->8----

A problem I've seen is when calling hb_ProcessClose() in Windows, if the process executes other processes, they are not finished. We should use the winapi TerminateJobObject and similar.

Sorry for the example so cumbersome, i have little time available and I could not reduce it more. I hope you can get the idea.

Regards.

[Pete]

On Wednesday, March 27, 2013 11:51:27 AM UTC+2, Óscar Hernández Suárez wrote:

Hello.

This is an proof of concept of using an interface to communicate with a Java application using JSON.

Thank you very much, Oscar!
It helps alot.

---
Pete

[Pete]

On Mar 27, 1:38 am, "Juan L. Gamero" <jlgam...@gmail.com> wrote:
> Pete:
>

> Also you can take a look at hbmk2.prg in utils/hbmk2 folder, specially
> the hbmk_hb_processRunCatch() function wich uses the functions you ask for.
>

Well, before I do a post, in this group, i tend to make all my "home-
work".
So did in this case. I "greped" the entire Harbour/src
along with changelog.txt
Then, I spent enough time examining the <hbprocfn.c> and <hbproces.c>
where the hb_process*() are implemented.
Unfortunately there is not much of documentation inside them!
By "not much", i mean no-documentation, at all!
Not even an one-liner description about the core function
hb_fsProcessOpen()
which is the kernel-func of the whole implementation.
I also searched into the holy-beast of all the harbour .prg sources,
(hbmk2.prg). I must admit that the diving into this abysmal source,
is an interesting experience suitable for people with strong nerves
and a heroic, although chaotic, sense of coding.
And then i thought that somebody here (in the group) might had
something more enlightening to offer.
I think i now know a little-bit more than before. Thanks again.

---
Pete

[vszakats]

Hello Pete,

I also searched into the holy-beast of all the harbour .prg sources,

(hbmk2.prg). I must admit that the diving into this abysmal source,
is an interesting experience suitable for people with strong nerves
and a heroic, although chaotic, sense of coding.

Great to be here and read that the code I wrote is basically
a horrible shit in your opinion. Especially as an excuse of you
not being able to read the very simplistic and self-contained
hbmk_hb_processRunCatch() function inside that horrific
(my God!) source code, which you got for free. All this while
continuously complaining about lack of free docs.

And then i thought that somebody here (in the group) might had
something more enlightening to offer.

The only thing to be asked on a volunteer forum is what one's
self can offer, not what others can.

-- Viktor

[Pete]

Hello Viktor,


I admit that you're a great programmer (proven), genuinely devoted to
the open-source affair and particularly to Harbour-project , but if
you (mis)interpret the term "holy-beast" as "horrible shit" then you
know absolutely nothing about the so called "High Art" (and that's
disappointingly unacceptable for high-skilled programmers! or am I
doing an invalid remark, about high-skilled programmers?) ;-)
Now, if you want to know my feeling, while reading the sources of
hbmk2 (probably not, but i'll tell you): I could describe this great
program's source as the Colosseum of all the 'xbase' sources ever
written and shone, under the sun of the FOSS-planet, and also as the
Pantheon of all the hb_* functions, not to mention the immeasurable
population (almost like a beach's sand-grains) of all the 'LOCALs',
'DEFINEs' and giant 'ARRAYs elements'. Pretty much 16.750 lines
(blanks included), weighing not less than 675 KB (692.016 byte,
actually) of pure harbour code.

That's a miracle! but the real miracle is that this code works and
works very well.

Now you may not like my view, but wtf? those are my thoughts while I'm
reading this monolithic source.
I don't believe that you believe that "Any thought that occurs in the
process of reading this source is subject to authorization. [and that]
Unauthorized thinking of it is prohibited" to paraphrase a funny quote
i have found in the net. Do you?

That said, i would ask you to avoid making wrong assumptions that is
leading you to explosive replies, with no particular reason.
The "very simplistic and self-contained hbmk_hb_processRunCatch()
function", which i was able to read despite your rather offensive
comment, doesn't shed much light regarding the questions i have asked
in my first post, (which i don't know if took the trouble to read).

I copy them here for convenience:
------------------------------------------------------------------------

Some Questions:

- the parent program waits until cCommand finish or not?
- if cCommand calls a second command/program the output of this second
command/program will be redirected/cached into StdOut/ErrOut vars?

- what is the purpose of HB_PROCESSVALUE(hProcess) , i mean, what it
returns (some error code or what?) and how it could exploited.

- HB_PROCESSCLOSE(hProcess) has to be invoked to terminate
hb_ProcessOpen() or the process is terminated when cCommand finishes?

------------------------------------------------------------------------

and here is your code:

------------------------------------------------------------------------
STATIC FUNCTION hbmk_hb_processRunCatch( cCommand, /* @ */
cStdOutErr )
LOCAL hProc
LOCAL hOutErr
LOCAL cData
LOCAL nLen
LOCAL nExitCode
cStdOutErr := ""
IF ( hProc := hb_processOpen( cCommand,, @hOutErr, @hOutErr ) ) !=
F_ERROR
cData := Space( 1024 )
DO WHILE ( nLen := FRead( hOutErr, @cData, hb_BLen( cData ) ) ) > 0
cStdOutErr += hb_BLeft( cData, nLen )
ENDDO
nExitCode := hb_processValue( hProc )
FClose( hOutErr )
OutStd( cStdOutErr )
ELSE
nExitCode := -999
ENDIF
RETURN nExitCode
------------------------------------------------------------------------

If hbmk_hb_processRunCatch() gives clear answers about the above
questions
then yes, I am unable to get it and I'm not shamed to admit it.
Ok, i can do some guesses about f.e. the nExitCode but it partialy
only answers
one of my questions. And while a guess may be a first-hand aid, it
doesn't
mean that is a documented knowledge.
You probably know all the relevant answers, and you're not obliged to
share them,
but keep in mind that it could serve as documentation available to all
the
harbour comunity not as a "free docs" but as shared knowledge which is
a
fundamental principle of the FOSS culture.
...

> that horrific (my God!) source code,
> which you got for free.
> All this while continuously complaining
> about lack of free docs.

Arbitrary points.
First, I didn't get your source code "for free".
You probably mean "free of money" but even so, I didn't get it "for
free".
Believe it or not, nothing is free in the net. Everything has its
cost, (moneys included). Now if it happens the one's (taker) cost to
not go
into the pocket of the other (giver) it's an other story
which needs much-much lines to exposed.
Second, I don't "continuously complain about lack of free docs"
(again the "free" argument).
From time to time, I do some queries to find documentation.
In the past the documentation affair, has been discussed,
with no positive results. You know why? I know. (I think..)

But my reply is starting to simulate, in length, the volume of your
hbmk2
but without the practical usefulness of the later.
So better to stop here with a hope that you'll not get it wrong again
and think to hit me in the foot. ;-)
(some relax and a sense of humor is what we all need sometimes..)

regards,

---
Pete

[vszakats]

On Thursday, March 28, 2013 1:13:28 PM UTC+1, Pete wrote:

Hello Viktor,


I admit that you're a great programmer (proven), genuinely devoted to
the open-source affair and particularly to Harbour-project , but if
you (mis)interpret the term "holy-beast" as "horrible shit" then you

I'm not English linguist, but 'abysmal' pretty much means the above.
 

know absolutely nothing about the so  called "High Art"  (and that's
disappointingly unacceptable for high-skilled programmers! or am I
doing an invalid remark, about high-skilled programmers?) ;-)
Now, if you want to know my feeling, while reading the sources of
hbmk2 (probably not, but i'll tell you): I could  describe this great
program's source as the Colosseum of all the 'xbase' sources ever
written and shone, under the sun of the FOSS-planet, and also as the
Pantheon of all the hb_* functions, not to mention the immeasurable
population (almost like a beach's sand-grains) of all the 'LOCALs',
'DEFINEs' and giant 'ARRAYs elements'. Pretty much 16.750 lines
(blanks included), weighing not less than 675 KB (692.016 byte,
actually) of pure harbour code.

That's a miracle! but the real miracle is that this code works and
works very well.

It is indeed, or plain luck! ;) Unfortunately it also testifies as an
example of code that has grown naturally with very little chance
of being rewritten in more structured manner by me, given how
much time, hassle and retesting it would involve, with marginal
benefit. There is nothing special about it, most make systems (and
lots of other live code out there) look like that or worse.

If someone doesn't like this, please rewrite it, just like I did with
previous Harbour make solutions (hbmake, hbmk, bld, core build).
Big work? It is. Now hbmk2 is even pretty well documented as
a response to Przemek's criticism for the lack of "specification",
though probably existing docs written for few months still don't
qualify as such in an academic or even practical sense. I wish I
had the "specification" for everything in the open source world
or let alone Harbour, plus of course, clear code that's easily
digestible at first quick glance and as a whole ;)

Now you may not like my view, but wtf? those are my thoughts while I'm
reading this monolithic source.
I don't believe that you believe that "Any thought that occurs in the
process of reading this source is subject to authorization. [and that]
Unauthorized thinking of it is prohibited" to paraphrase a funny quote
i have found in the net. Do you?

Pff, is this necessary? Neither can I, nor do I have any intentions
to "prohibit" anyone's opinion. If you read the opinions just in the
last few weeks or years, it's quite apparent ;)

But than again, may I have the right the reflect on a thought put
out there by someone to public? Pretty useless, I have to say,
because all these are opinions, and will lower the quality of discussion
forums, but anyway. Probably it's very entertaining, too, like a crappy
TV show.

You should also understand that for me this whole development
is a permanent and endless loop of personal hassles and negative
feedback in response to huge work done in public. This, I'm still
not used to and probably never will, and sometimes I do need to
reflect.

That said, i would ask you to avoid making wrong assumptions that is
leading you to explosive replies, with no particular reason.
The "very simplistic and self-contained hbmk_hb_processRunCatch()
function", which i was able to read despite your rather offensive
comment, doesn't shed much light regarding the questions i have asked
in my first post, (which i don't know if took the trouble to read).

I did and almost sent a reply along the lines of 'learning by
example' and pointing to existing code in Harbour itself, but
I saw no point for multiple reasons. Lucky me, as you had
already grepped and deemed the clear answer to your problem
not fit for your taste or purpose.

- the parent program waits until cCommand  finish or not?
- if cCommand calls a second command/program the output of this second
command/program will be redirected/cached into StdOut/ErrOut vars?

- what is the purpose of HB_PROCESSVALUE(hProcess) , i mean, what it
returns (some error code or what?) and how it could exploited.

- HB_PROCESSCLOSE(hProcess) has to be invoked to terminate
hb_ProcessOpen() or the process is terminated when cCommand finishes?

All of these quite easy to test, some of the easy to read from
hbmk2 or uhttpd code. I'm sure many will be happy to read the
answers as a result of a personal research. And mind you, nobody
has "magical power", only the existing sources, and time to find
these out. Or, the hope that Przemek will jump in an elaborate on
them as the mind behind these functions. As for me, I'm happy he
put these out there for us to explore further.

hbmk2's hb_process*() usage is 100% the result of reading existing
ChangeLog docs, conversing on the public list (very briefly if any
in this particular case), reading existing sources and examples.
 

Ok, i can do some guesses about f.e. the nExitCode but it partialy
only answers
one of my questions. And while a guess may be a first-hand aid, it

See!
 

doesn't
mean that is a documented knowledge.

documented knowlegde? You mean documented by someone
else? anybody else in particular?

Anyhow, it does mean that it works and that you can start somewhere
to explore further if you mean to.
 

You probably know all the relevant answers, and you're not obliged to
share them,
but keep in mind that it could serve as documentation available to all
the
harbour comunity not as a "free docs" but as shared knowledge which is
a
fundamental principle of the FOSS culture.

False. See above what I wrote about "magical power". There
is no such thing.

As for sharing. I wouldn't even go into it, because even your raising
of the question is insulting.
 

Arbitrary points.
First, I didn't get your source code "for free".

 

You probably mean "free of money" but even so, I didn't get it "for
free".
Believe it or not, nothing is free in the net. Everything has its
cost, (moneys included). Now if it happens the one's (taker) cost to
not go
into the pocket of the other (giver) it's an other story
which needs much-much lines to exposed.

Gosh, I'm sorry, probably someone would have to pay your costs
of lost time and else. This seems to be the new notion in Harbour
community: giving deadlines and asking for compensation for ones
loss due to using free tools. This was the point when I understood
why all the "no guarantees" disclaimers in free tools.

Anyhow I know what you mean, but if you feel the costs of free
software too high, maybe it's not the good choice for you and a
paid solution would be less costly. (no pun intended)

Second, I don't "continuously complain about lack of free docs"
(again the "free" argument).
From time to time, I do some queries to find documentation.
In the past the documentation affair, has been discussed,
with no positive results. You know why? I know. (I think..)

I know why: nobody volunteered to write them. Simple. If nobody
volunteered with free docs, or spare time to answer it to you, either
create them, or hire someone to create it for you. It's nothing
personal, it's how it works. There is no magic. There is people's
spare time, which they freely use for whatever they chose to
for whatever (more often than not - selfish) reasons.

but without the practical usefulness of the later.

So better to stop here with a hope that you'll not get it wrong again
and think to hit me in the foot. ;-)
(some relax and a sense of humor is what we all need sometimes..)

This is disappointing.

-- Viktor

[Alex Strickland]

Hi Viktor

> I'm not English linguist, but 'abysmal' pretty much means the above.

I'm pretty sure something about an abyss was intended - but I'm not sure
it's much better.

--
Regards
Alex

[Pete]

On Thursday, March 28, 2013 3:24:18 PM UTC+2, vszakats wrote:

> You should also understand that for me this whole development
>  is a permanent and endless loop of personal hassles and negative
> feedback in response to huge work done in public. This, I'm still
> not used to and probably never will, and sometimes I do need to
> reflect.

 

The truth is that the harbour project, if it is still alive, it is thanks to your persistent devotion and continuous efforts especially in the last months where the "big guns" have disappeared  from the field. I understand the pressure, what else i could say, other than that many harbour users are grateful for your support?

 

> As for me, I'm happy he put these out there
> for us to explore further.

 

You may be happy but i am not so much. Let me explain why i 'm not that easy to share the joy. Two reasons:
1. While it is potentially useful, it demands a lot of laboring to become applicable and to bring in all the expected (and possibly big) benefit; but the most important is...
2. It boosts, unintentionally, one of the gray sides of the FOSS realm, which is no other than the ongoing tendency for insufficient documentation and/or lack of support. (one of the main arguments used against the spread and use of open sourced software)

Doing a great contribution of code (in whatever degree of quality and quantity it is this) without a basic documentation it's in some extend incomplete. And anybody saying that a basic documentation is essential, and looking for it, surely doesn't try to degrade the contribution but rather seeks to cure the incompleteness.
Now, I am already hearing the easy argument:
- Look, if you can't use it, then you don't use it. That simple!
- Is it that simple indeed?
- No!
- Why no?
- Well, if you can't get it, then.. you don't get it! ;-)


P.S. I'm not english linguist, me too. The Myriam-Websterr just now told me that:
----------------------------
Definition of ABYSMAL
1.
a : having immense or fathomless extension downward, backward, or inward <an abysmal cliff>
b : immeasurably great : profound <abysmal ignorance>
c : immeasurably low or wretched <abysmal living conditions of the poor>
2
: abyssal
------------------------------------------------------------------
I used the term in the meaning of the (a) definition,
but reading to the (b) and (c) i tend to think that the word can have a negative sense. Maybe I could use a less dangerous word but that's the problem with the non-natives broken-english; sometimes they are a "feature" sometimes "a bug". I suppose we can live with this. ;-)

---
Pete

[vszakats]

On Thursday, March 28, 2013 3:24:18 PM UTC+2, vszakats wrote:

> You should also understand that for me this whole development
>  is a permanent and endless loop of personal hassles and negative
> feedback in response to huge work done in public. This, I'm still
> not used to and probably never will, and sometimes I do need to
> reflect.

 

The truth is that the harbour project, if it is still alive, it is thanks to your persistent devotion and continuous efforts especially in the last months where the "big guns" have disappeared  from the field. I understand the pressure, what else i could say, other than that many harbour users are grateful for your support?

Only Przemek disappeared who contributed often and to all parts
of Harbour. The pressure is permanent since at least 3 years, but I
admit it's getting worse.

 > As for me, I'm happy he put these out there

> for us to explore further.

You may be happy but i am not so much. Let me explain why i 'm not that easy to share the joy. Two reasons:
1. While it is potentially useful, it demands a lot of laboring to become applicable and to bring in all the expected (and possibly big) benefit; but the most important is...
2. It boosts, unintentionally, one of the gray sides of the FOSS realm, which is no other than the ongoing tendency for insufficient documentation and/or lack of support. (one of the main arguments used against the spread and use of open sourced software)

Well, there is no guarantee in open source, like it would be
in a _contractual_ obligation. Missing this from an open source
project is missing the point of it IMO. The state of project -
documentation included - is solely up to the volunteers.
If that volunteer offering is not enough for someone, well, one
can do several things, including complaining about it, but it
won't change anything fundamental (only make those who
contribute, feel turned down maybe)

Let's consider the case that hb_process*() was not committed
or Harbour... well, would it be better now? No.

Doing a great contribution of code (in whatever degree of quality and quantity it is this) without a basic documentation it's in some extend incomplete. And anybody saying that a basic documentation is essential, and looking for it, surely doesn't try to degrade the contribution but rather seeks to cure the incompleteness.
Now, I am already hearing the easy argument:
- Look, if you can't use it, then you don't use it. That simple!
- Is it that simple indeed?
- No!
- Why no?
- Well, if you can't get it, then.. you don't get it! ;-)

It's indeed one of the possibilities. It's actually the
cheapest and requires the least effort. Luckily you
have other choices, too, some of those make it stand
out even compared to a commercial offering. Ie.
you cannot usually do a lot of things with a commercial
offering if you turn them down, except finding another
offer. With open source you have the freedom to
take things in your own hand in a thousand different,
productive ways.

This is made possible by past contributors efforts
and their willing to have their work licensed this way.
Not a small feat, I'd say.
 

a : having immense or fathomless extension downward, backward, or inward <an abysmal cliff>
b : immeasurably great : profound <abysmal ignorance>
c : immeasurably low or wretched <abysmal living conditions of the poor>
2
: abyssal
------------------------------------------------------------------
I used the term in the meaning of the (a) definition,
but reading to the (b) and (c) i tend to think that the word can have a negative sense. Maybe I could use a less dangerous word but that's the problem with the non-natives broken-english; sometimes they are a "feature" sometimes "a bug". I suppose we can live with this. ;-)

Here is the Dictionary app I use (part of the OS):
---
abysmal |əˈbizməl|
adjective
1 informal extremely bad; appalling: the quality of her work is abysmal.
2 literary very deep.
---

Maybe not the best choice when describing someones
product in a good (?) way :) But I hear you, you meant
complicated, far-reaching, exhaustive, spaghetti code.
If so, I agree, even with the food bit, as I routinely broke
the nesting and function size rules. Reason is simple,
it started out as a humble replacement for bld.bat. Grown
a bit into every directions.

-- Viktor