Breaking out of nested subroutine?

Discussion in 'Perl Misc' started by Hemant Shah, Jul 29, 2004.

  1. Hemant Shah

    Hemant Shah Guest

    Folks,

    How do I break out from a nested subroutine to the outside of parent
    subroutine?


    # ----- Module2.pm
    sub Function2()
    {

    sub Function3()
    {
    If certain condition is met go back to Function1.
    How do I return to Function1 from here?
    }

    Some perl code.

    Function3();

    More perl code.
    }


    # ----- Module1.pm

    use Module2;

    sub Function1()
    {
    Module2::Function2();

    How do I get here from Function3()?

    More code.
    }


    # ----- Main Program

    use Module1;

    Module1::Function1();

    More code.



    Thanks.

    --
    Hemant Shah /"\ ASCII ribbon campaign
    E-mail: \ / ---------------------
    X against HTML mail
    TO REPLY, REMOVE NoJunkMail / \ and postings
    FROM MY E-MAIL ADDRESS.
    -----------------[DO NOT SEND UNSOLICITED BULK E-MAIL]------------------
    I haven't lost my mind, Above opinions are mine only.
    it's backed up on tape somewhere. Others can have their own.
     
    Hemant Shah, Jul 29, 2004
    #1
    1. Advertising

  2. Hemant Shah

    Matt Garrish Guest

    "Hemant Shah" <> wrote in message
    news:ce9con$jqo$...
    >
    >
    > Folks,
    >
    > How do I break out from a nested subroutine to the outside of parent
    > subroutine?
    >
    >
    > # ----- Module2.pm
    > sub Function2()
    > {
    >
    > sub Function3()
    > {
    > If certain condition is met go back to Function1.
    > How do I return to Function1 from here?
    > }
    >
    > Some perl code.
    >
    > Function3();
    >
    > More perl code.
    > }
    >
    >
    > # ----- Module1.pm
    >
    > use Module2;
    >
    > sub Function1()
    > {
    > Module2::Function2();
    >
    > How do I get here from Function3()?
    >
    > More code.
    > }
    >
    >
    > # ----- Main Program
    >
    > use Module1;
    >
    > Module1::Function1();
    >
    > More code.
    >


    Return a value from Function3 indicating whether you should go back to
    Function1. As a rather contrived example:

    Function1();

    sub Function1 {
    Function2();
    print "Have a good day!\n";
    }

    sub Function2 {
    my ($ok, $retval) = Function3();
    return unless $ok;
    print "Your lucky number is $retval!\n";
    }

    sub Function3 {
    my $x = sprintf("%2d", rand(1)*100);
    if ($x != 13) {
    return 1,$x;
    }
    else {
    return 0,0;
    }
    }

    Matt
     
    Matt Garrish, Jul 29, 2004
    #2
    1. Advertising

  3. Hemant Shah

    gnari Guest

    "Hemant Shah" <> wrote in message
    news:ce9con$jqo$...
    >
    >
    > Folks,
    >
    > How do I break out from a nested subroutine to the outside of parent
    > subroutine?
    >
    >
    > # ----- Module2.pm
    > sub Function2()
    > {
    >
    > sub Function3()
    > {
    > If certain condition is met go back to Function1.
    > How do I return to Function1 from here?


    return ABORTVALUE if somecondition;

    > }
    >
    > Some perl code.
    >
    > Function3();

    return if Function3() == ABORTVALUE;

    >
    > More perl code.
    > }


    gnari
     
    gnari, Jul 29, 2004
    #3
  4. Hemant Shah

    Bob Walton Guest

    Hemant Shah wrote:

    ....
    > How do I break out from a nested subroutine to the outside of parent
    > subroutine?
    >
    >
    > # ----- Module2.pm
    > sub Function2()
    > {
    >
    > sub Function3()
    > {
    > If certain condition is met go back to Function1.
    > How do I return to Function1 from here?
    > }
    >
    > Some perl code.
    >
    > Function3();
    >
    > More perl code.
    > }
    >
    >
    > # ----- Module1.pm
    >
    > use Module2;
    >
    > sub Function1()
    > {
    > Module2::Function2();
    >
    > How do I get here from Function3()?
    >
    > More code.
    > }
    >
    >
    > # ----- Main Program
    >
    > use Module1;
    >
    > Module1::Function1();
    >
    > More code.



    Menant, you can put a block around the call to Function2(), and then use
    a "last" statement to break out of that block. Like:

    # ----- Main Program
    use junk479m1;
    print "main program\n";
    junk479m1::Function1();
    #More code.
    print "more code in main program\n";


    # ----- junk479m1.pm
    package junk479m1;
    use junk479m2;
    sub Function1()
    {
    print "function1\n";
    {junk479m2::Function2();} #note block around the call

    #How do I get here from Function3()?
    #More code.
    print "function1 more code\n";
    }
    1;

    # ----- junk479m2.pm
    package junk479m2;
    sub Function2()
    {
    sub Function3()
    {
    print "function3\n";
    #If certain condition is met go back to Function1.
    last; #execute this conditionally
    #How do I return to Function1 from here?
    print "more stuff in function3\n";
    }
    #Some perl code.
    print "function2\n";
    Function3();
    print "more code in function2\n";
    #More perl code.
    }
    1;

    HTH. BTW, your modules were missing the "package" statement and they
    did not return a true value as written. Also, the definition of a sub
    inside a sub another sub is OK, I guess, but a bit unconventional. I'm
    not sure if it compiles it everytime Function2 is executed? If so, that
    would be a waste of cycles.
    --
    Bob Walton
    Email: http://bwalton.com/cgi-bin/emailbob.pl
     
    Bob Walton, Jul 29, 2004
    #4
  5. On Wed, 28 Jul 2004 23:27:19 +0000, Hemant Shah wrote:

    >
    > Folks,
    >
    > How do I break out from a nested subroutine to the outside of parent
    > subroutine?


    What you are asking for, is called a non-local goto in C terminology,
    and is considered an extremely bad programming practice. In order to
    emulate it, one would have to have a subroutine called main() (where did I
    see that before?) set it up as a signal handler for, say, signal 10
    (USR1). When one wants to jump back from a subroutine, signal is sent to
    itself by using kill function. and you find yourself back in the "main"
    function. That was, in essence, the same way it was implemented in C
    library. Of course, your perl script would look like this.

    #!/usr/bin/perl -w
    use strict;
    # You need POSIX package to send signal to yourself. It contains
    # the getpid() function needed to get your process id.
    use POSIX;
    use Whatever::else::You::want::to::use;
    # Global variables
    my ($glob1,$glob2,....,$globn);
    main;

    sub main {
    .....
    }

    Normally, perl programmers have hard time to un-learn things like C,
    and master perl idioms. What you are asking for, is a C programming
    technique, so you'll have to emulate program structure and behavior
    of the C programs, which means going exactly the opposite way then
    the most perl programmers usually go.


    --
    A city is a large community where people are lonesome together.
     
    Mladen Gogala, Jul 29, 2004
    #5
  6. Hemant Shah

    Zeljko Vrba Guest

    On 2004-07-28, Hemant Shah <> wrote:
    >
    >
    > Folks,
    >
    > How do I break out from a nested subroutine to the outside of parent
    > subroutine?
    >

    As someone already said, this is nonlocal goto (setjmp/longjmp in C).
    In perl you can emulate this with die/eval:

    eval {
    # call your sub
    }
    if($@ eq 'something') {
    # $@ is return value from die
    }

    your sub:
    sub X {
    # whatever
    die 34; # this is your return value to innermost eval{}
    }
     
    Zeljko Vrba, Jul 29, 2004
    #6
  7. Hemant Shah

    Anno Siegel Guest

    Bob Walton <> wrote in comp.lang.perl.misc:
    > Hemant Shah wrote:


    [...]

    > ... Also, the definition of a sub
    > inside a sub another sub is OK, I guess, but a bit unconventional. I'm
    > not sure if it compiles it everytime Function2 is executed? If so, that
    > would be a waste of cycles.


    A sub definition is only compiled once, nested or not. What you get is
    a named closure (unless you consider that a contradiction in terms).
    That is, the inner sub can access lexical variables defined in the
    outer one.

    Come to think of it, that's another way to abort a call:

    sub outer {
    # ...
    my $abort;
    sub inner {
    # ...
    if ( some_condition() ) {
    $abort = 1;
    return;
    }
    # ...
    inner( ...);
    return if $abort;
    # ...
    }

    However, that's all too tricky for my taste. The straightforward method
    is to return something characteristic from the inner call that tells
    the outer call not to continue.

    Anno
     
    Anno Siegel, Jul 29, 2004
    #7
  8. -berlin.de (Anno Siegel) writes:

    > Bob Walton <> wrote in comp.lang.perl.misc:
    > > Hemant Shah wrote:

    >
    > [...]
    >
    > > ... Also, the definition of a sub
    > > inside a sub another sub is OK, I guess, but a bit unconventional. I'm
    > > not sure if it compiles it everytime Function2 is executed? If so, that
    > > would be a waste of cycles.

    >
    > A sub definition is only compiled once, nested or not. What you get is
    > a named closure (unless you consider that a contradiction in terms).


    It does not behave a proper closure.

    > That is, the inner sub can access lexical variables defined in the
    > outer one.


    But only the first time the outer sub is called.

    > Come to think of it, that's another way to abort a call:
    >
    > sub outer {
    > # ...
    > my $abort;
    > sub inner {
    > # ...
    > if ( some_condition() ) {
    > $abort = 1;
    > return;
    > }
    > # ...
    > inner( ...);
    > return if $abort;
    > # ...
    > }
    >
    > However, that's all too tricky for my taste.


    Also it doesn't work after the fist call to outer().

    For further explaintion of this, look up the explaintion of the
    warning that perl will emit when you compile the above code.

    --
    \\ ( )
    . _\\__[oo
    .__/ \\ /\@
    . l___\\
    # ll l\\
    ###LL LL\\
     
    Brian McCauley, Jul 29, 2004
    #8
  9. Hemant Shah

    Anno Siegel Guest

    Brian McCauley <> wrote in comp.lang.perl.misc:
    > -berlin.de (Anno Siegel) writes:
    >
    > > Bob Walton <> wrote in comp.lang.perl.misc:
    > > > Hemant Shah wrote:

    > >
    > > [...]
    > >
    > > > ... Also, the definition of a sub
    > > > inside a sub another sub is OK, I guess, but a bit unconventional. I'm
    > > > not sure if it compiles it everytime Function2 is executed? If so, that
    > > > would be a waste of cycles.

    > >
    > > A sub definition is only compiled once, nested or not. What you get is
    > > a named closure (unless you consider that a contradiction in terms).

    >
    > It does not behave a proper closure.


    You're right.

    > > That is, the inner sub can access lexical variables defined in the
    > > outer one.

    >
    > But only the first time the outer sub is called.
    >
    > > Come to think of it, that's another way to abort a call:
    > >
    > > sub outer {
    > > # ...
    > > my $abort;
    > > sub inner {
    > > # ...
    > > if ( some_condition() ) {
    > > $abort = 1;
    > > return;
    > > }
    > > # ...
    > > inner( ...);
    > > return if $abort;
    > > # ...
    > > }
    > >
    > > However, that's all too tricky for my taste.

    >
    > Also it doesn't work after the fist call to outer().
    >
    > For further explaintion of this, look up the explaintion of the
    > warning that perl will emit when you compile the above code.


    Yeah... missed that too.

    Sorry for the sloppy posting.

    Anno
     
    Anno Siegel, Jul 29, 2004
    #9
  10. Hemant Shah

    Hemant Shah Guest

    While stranded on information super highway Bob Walton wrote:
    > Hemant Shah wrote:
    >
    > ...
    >> How do I break out from a nested subroutine to the outside of parent
    >> subroutine?
    >>
    >>
    >> # ----- Module2.pm
    >> sub Function2()
    >> {
    >>
    >> sub Function3()
    >> {
    >> If certain condition is met go back to Function1.
    >> How do I return to Function1 from here?
    >> }
    >>
    >> Some perl code.
    >>
    >> Function3();
    >>
    >> More perl code.
    >> }
    >>
    >>
    >> # ----- Module1.pm
    >>
    >> use Module2;
    >>
    >> sub Function1()
    >> {
    >> Module2::Function2();
    >>
    >> How do I get here from Function3()?
    >>
    >> More code.
    >> }
    >>
    >>
    >> # ----- Main Program
    >>
    >> use Module1;
    >>
    >> Module1::Function1();
    >>
    >> More code.

    >
    >
    > Menant, you can put a block around the call to Function2(), and then use
    > a "last" statement to break out of that block. Like:
    >
    > # ----- Main Program
    > use junk479m1;
    > print "main program\n";
    > junk479m1::Function1();
    > #More code.
    > print "more code in main program\n";
    >
    >
    > # ----- junk479m1.pm
    > package junk479m1;
    > use junk479m2;
    > sub Function1()
    > {
    > print "function1\n";
    > {junk479m2::Function2();} #note block around the call
    >
    > #How do I get here from Function3()?
    > #More code.
    > print "function1 more code\n";
    > }
    > 1;
    >
    > # ----- junk479m2.pm
    > package junk479m2;
    > sub Function2()
    > {
    > sub Function3()
    > {
    > print "function3\n";
    > #If certain condition is met go back to Function1.
    > last; #execute this conditionally
    > #How do I return to Function1 from here?
    > print "more stuff in function3\n";
    > }
    > #Some perl code.
    > print "function2\n";
    > Function3();
    > print "more code in function2\n";
    > #More perl code.
    > }
    > 1;
    >
    > HTH. BTW, your modules were missing the "package" statement and they
    > did not return a true value as written. Also, the definition of a sub
    > inside a sub another sub is OK, I guess, but a bit unconventional. I'm
    > not sure if it compiles it everytime Function2 is executed? If so, that
    > would be a waste of cycles.


    Thanks, I will give that a try. The code I posted was just a small
    fragment, so it did not have all the statements from a perl module.

    > --
    > Bob Walton
    > Email: http://bwalton.com/cgi-bin/emailbob.pl
    >


    --
    Hemant Shah /"\ ASCII ribbon campaign
    E-mail: \ / ---------------------
    X against HTML mail
    TO REPLY, REMOVE NoJunkMail / \ and postings
    FROM MY E-MAIL ADDRESS.
    -----------------[DO NOT SEND UNSOLICITED BULK E-MAIL]------------------
    I haven't lost my mind, Above opinions are mine only.
    it's backed up on tape somewhere. Others can have their own.
     
    Hemant Shah, Jul 29, 2004
    #10
  11. Hemant Shah

    Hemant Shah Guest

    Folks,

    Thanks for all the different ways to break out of a nested subroutine
    I will give them a try and see which works.

    There may be a simpler way in the module I am using.

    I am using XML::pARSER to parse an xml file and have define handlers for
    Start, End, and Char. I want to stop processing, when I encounter a
    particular tag (i.e. break out of Start handler and stop further processing
    of XML file).



    --
    Hemant Shah /"\ ASCII ribbon campaign
    E-mail: \ / ---------------------
    X against HTML mail
    TO REPLY, REMOVE NoJunkMail / \ and postings
    FROM MY E-MAIL ADDRESS.
    -----------------[DO NOT SEND UNSOLICITED BULK E-MAIL]------------------
    I haven't lost my mind, Above opinions are mine only.
    it's backed up on tape somewhere. Others can have their own.
     
    Hemant Shah, Jul 29, 2004
    #11
  12. Mladen Gogala wrote:

    > On Wed, 28 Jul 2004 23:27:19 +0000, Hemant Shah wrote:
    >
    >> How do I break out from a nested subroutine to the outside of parent
    >> subroutine?

    >
    > What you are asking for, is called a non-local goto in C terminology,
    > and is considered an extremely bad programming practice.


    You can't generalise like that. Those situations happen quite frequently,
    and they're what exception handling in C++, Java, etc. is designed for.

    --
    Seungbeom Kim
     
    Seungbeom Kim, Jul 29, 2004
    #12
  13. Hemant Shah

    Guest

    Seungbeom Kim <> writes:

    > Mladen Gogala wrote:
    >
    > > On Wed, 28 Jul 2004 23:27:19 +0000, Hemant Shah wrote:
    > >
    > >> How do I break out from a nested subroutine to the outside of parent
    > >> subroutine?

    > > What you are asking for, is called a non-local goto in C terminology,
    > > and is considered an extremely bad programming practice.

    >
    > You can't generalise like that. Those situations happen quite
    > frequently, and they're what exception handling in C++, Java, etc. is
    > designed for.
    >


    Scheme is much better off, as it has call-with-current-continuation
    which even allows to resume subroutines later on.

    Klaus Schilling
     
    , Jul 29, 2004
    #13
  14. On Thu, 29 Jul 2004 13:14:53 -0700, Seungbeom Kim wrote:


    > You can't generalise like that. Those situations happen quite
    > frequently, and they're what exception handling in C++, Java, etc. is
    > designed for.


    Exception handling is not the same as longjmp. Exception handling is an OO
    technique in which objects "throw error objects" (unfortunately, English
    betrays us here) which are then "caught" in exception handlers. Non-local
    goto or long jump is also a technique based on system trap, but without
    any handlers, just a context switch. The expression "break out of
    subroutine" is more reminiscent of longjmp then of the throw-catch
    mechanism, at least in my opinion. You'll note that, in contrast to C,
    perl doesn't have "goto" command, which was deemed bad by Mr. Dijsktra in
    his historic paper called "Modular Programming", published in the middle
    of the last century. From the point of view of modular programming, any
    goto is a bad thing. Non-local goto is a very bad thing, I'm afraid.

    --
    A city is a large community where people are lonesome together.
     
    Mladen Gogala, Jul 29, 2004
    #14
  15. Mladen Gogala <> writes:

    > On Thu, 29 Jul 2004 13:14:53 -0700, Seungbeom Kim wrote:
    >
    > > You can't generalise like that. Those situations happen quite
    > > frequently, and they're what exception handling in C++, Java, etc. is
    > > designed for.

    >
    > Exception handling is not the same as longjmp. Exception handling is an OO
    > technique in which objects "throw error objects" (unfortunately, English
    > betrays us here) which are then "caught" in exception handlers. Non-local
    > goto or long jump is also a technique based on system trap, but without
    > any handlers, just a context switch. The expression "break out of
    > subroutine" is more reminiscent of longjmp then of the throw-catch
    > mechanism,


    Doesn't seem to inply one mechanism over the other to me.

    > at least in my opinion.


    Throw-catch is just a more elegant way to do what longjmp achieved in
    a rather quick and dirty fashion. In Perl (and other modern
    languages) when you break out of deep stack frame t unwinds the stack
    giving each stack frame a chance to clean up after itself.

    > You'll note that, in contrast to C, perl doesn't have "goto"
    > command,


    Errr...?

    > which was deemed bad by Mr. Dijsktra in
    > his historic paper called "Modular Programming", published in the middle
    > of the last century. From the point of view of modular programming, any
    > goto is a bad thing.


    Be aware that not only is Perl's goto() a goto but so too are
    return(), next(), last() and especially redo().

    Use the best tool for the job. Do not let just reject it because it
    has been "deemed bad".

    --
    \\ ( )
    . _\\__[oo
    .__/ \\ /\@
    . l___\\
    # ll l\\
    ###LL LL\\
     
    Brian McCauley, Jul 29, 2004
    #15
  16. On Thu, 29 Jul 2004 23:04:00 +0100, Brian McCauley wrote:

    > Errr...?


    You are right. I've never used it, and I didn't even know it existed.
    >
    >> which was deemed bad by Mr. Dijsktra in
    >> his historic paper called "Modular Programming", published in the middle
    >> of the last century. From the point of view of modular programming, any
    >> goto is a bad thing.

    >
    > Be aware that not only is Perl's goto() a goto but so too are
    > return(), next(), last() and especially redo().


    Next is an equivalent to "continue", last is an equivalent to "break".
    C doesn't have anything like "redo". Why do you think those are goto's?
    When you translate them to assembly language, they all do include JMP
    command, but they're not equivalent to the goto command in its classic
    sense.

    >
    > Use the best tool for the job. Do not let just reject it because it
    > has been "deemed bad".


    Modular programming dictates you to break program in subroutines and
    functions where it makes sense, instead of writing monolithic monsters
    having 10,000+ lines of code in a single program unit. When you have
    subs, goto just doesn't look like The Right Way (TM) to control the
    program flow. Of course, it is all highly subjective. The important
    thing for programs is to work and to be easy to maintain. If you can
    achieve that with a goto or two, good for you.




    --
    A city is a large community where people are lonesome together.
     
    Mladen Gogala, Jul 29, 2004
    #16
  17. Hemant Shah

    Uri Guttman Guest

    >>>>> "A" == Abigail <> writes:

    A> Well, I find 'goto' in C programs quite handy. In Perl too, except I
    A> usually spell 'goto' as 'redo', 'next' or 'last'.


    A> BTW, I've no doubt that Mr. Dijkstra would have the same dim
    A> opinion about Perl as a language as he had for 'goto' as a
    A> statement.

    heh, i agree. we all want those fun state variables in each nested loop
    and checking for them at each level. GAHHH!!!!

    and to the OP, magic goto is very useful but has little to do with
    classic goto. larry had a bad habit of overloading function names (eval,
    select, goto).

    uri

    --
    Uri Guttman ------ -------- http://www.stemsystems.com
    --Perl Consulting, Stem Development, Systems Architecture, Design and Coding-
    Search or Offer Perl Jobs ---------------------------- http://jobs.perl.org
     
    Uri Guttman, Aug 1, 2004
    #17
  18. Hemant Shah

    Matija Papec Guest

    X-Ftn-To: Abigail

    Abigail <> wrote:
    >A few things:
    >
    >- Perl does have a 'goto' statement. In fact, it has three goto statements,
    > and three statements who, while they aren't spelled 'goto', aren't very
    > different from a 'goto'. ('last', 'next' and 'redo').


    But they are different, and they differ in significant way; at least when
    analyzing code from algorithm perspective.

    >- The paper you are referring to is:
    > Edsger W. Dijkstra: "Go To Statement Considered Harmful"
    > However, the title isn't his. The title he put on the paper he submitted
    > to the CACM was "A case against the GOTO statement"; the editor, Niklaus
    > Wirth, changed the title.
    >- There's another famous computer scientist, who, unlike EWD, gives the
    > impression of actually having used a computer more than once in his life.
    > He also wrote a paper. The paper I refer to:
    > Donald E. Knuth: "Structured Programming with goto Statements"
    > I prefer this 72 page discussion of goto's pro and cons over the 2.5 page
    > emotional pamphlet of EWD. Heck, DEK's reference list is longer than EWDs
    > entire paper.


    IMO, using goto is like swearing. There are people that never swear, even
    when they should, and so they cut themselves from clear and straight to the
    point way of expression (at least in some specific situations). On the other
    hand, Dijkstra IMHO had some hard time with poor programmers which were
    swearing all the time, so he came to idea to take away "goto" freedom from
    them so their work could become more readable. It all depends to whom are
    you applying the rules which brings us to familiar cons. and pros. for
    freedom/strict environment.



    --
    Matija
     
    Matija Papec, Aug 1, 2004
    #18
  19. On Thu, 29 Jul 2004 18:55:35 -0400, Mladen Gogala
    <> wrote:

    [about goto()]

    >> Errr...?

    >
    >You are right. I've never used it, and I didn't even know it existed.


    Not only does it exist, but it also allow an &-form which is not
    really a goto in the sense you were talking about:

    [admittedly stupid example]


    #!/usr/bin/perl -l

    use strict;
    use warnings;

    sub doit;

    doit $_, qw/foo bar baz/ for 0..2;

    sub doit () {
    my $i=shift;
    print "Operation <$i>:";
    goto ( sub { print for @_ },
    sub { print scalar @_ },
    sub { print "@_" } )[$i];
    }

    __END__



    Michele
    --
    you'll see that it shouldn't be so. AND, the writting as usuall is
    fantastic incompetent. To illustrate, i quote:
    - Xah Lee trolling on clpmisc,
    "perl bug File::Basename and Perl's nature"
     
    Michele Dondi, Aug 1, 2004
    #19
  20. On Sat, 31 Jul 2004 23:21:47 +0000, Abigail wrote:

    > Well, I find 'goto' in C programs quite handy. In Perl too, except I
    > usually spell 'goto' as 'redo', 'next' or 'last'.


    It's not the same thing. The "C" equivalent of "next" is "continue",
    equivalent of "last" is "break", while C doesn't have an equivalent of
    "redo". If the command exists, you are welcome to use it, but I want to be
    the one who would maintain your programs, if you make an extensive use of
    the "goto" command. Modular programming languages are usually accompanied
    by certain kind of aesthetics which regards the use of "goto" statement as
    "ugly". This is not a liberty issue, this is aesthetics. It's exactly the
    same thing as putting a bra on the goddess of justice, or putting a
    loincloth on a replica of Michelangelo's "David": doable, but silly.

    --
    A city is a large community where people are lonesome together.
     
    Mladen Gogala, Aug 1, 2004
    #20
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Amy
    Replies:
    0
    Views:
    513
  2. rbt

    breaking out of nested loop

    rbt, Jul 12, 2005, in forum: Python
    Replies:
    9
    Views:
    513
    Raymond Hettinger
    Jul 13, 2005
  3. Tim Golden

    RE: breaking out of nested loop

    Tim Golden, Jul 12, 2005, in forum: Python
    Replies:
    1
    Views:
    369
    Dennis Lee Bieber
    Jul 13, 2005
  4. Tagore

    breaking out of multiple nested loops

    Tagore, Nov 15, 2009, in forum: C Programming
    Replies:
    42
    Views:
    2,019
    Gus Gassmann
    Dec 5, 2009
  5. king
    Replies:
    5
    Views:
    188
Loading...

Share This Page