Stats

  • Locked Locked
  • Replies 5
  • Subscribers 143
  • Views 7490
  • Members are here 0
This discussion has been locked.
You can no longer post new replies to this discussion. If you have a question you can start a new discussion

Weird "case" statement behavior (at least to me...), can someone please explain this to me?

Sheppy

Hello all,

Today I ran into a problem which toke me a long time to find the cause. It is with the "case" statement. First I show you something that is very simple and that does work:

testString = "one"
case( testString
    ( "one"
        printf("it is 1!\n")
    )
    ( "two"
        printf("it is 2!\n")
    )
    ( t
        printf("it is something else!\n")
    )
)

testString = "two"
case( testString
    ( "one"
        printf("it is 1!\n")
    )
    ( "two"
        printf("it is 2!\n")
    )
    ( t
        printf("it is something else!\n")
    )
)

testString = "bla"
case( testString
    ( "one"
        printf("it is 1!\n")
    )
    ( "two"
        printf("it is 2!\n")
    )
    ( t
        printf("it is something else!\n")
    )
)

When you run this code (just copy-past into CIW...) the output of the case statements is as you would expect:

it is 1!
it is 2!
it is something else!

However, if you specify a variable like so:

testOptions = list( "one" "two" )

And replace the "case" statement with this:

case( testString
    ( nthelem( 1 testOptions )
        printf("it is 1!\n")
    )
    ( nthelem( 2 testOptions )
        printf("it is 2!\n")
    )
    ( t
        printf("it is something else!\n")
    )
)

The output is not what I expected:

it is something else!
it is something else!
it is something else!

Testing the "nthelem" part shows no problem, it perfectly outputs the right string (or whatever you put in the list).

If you do the same with a "cond" statement (using the "nthelem" statement), it works perfectly fine.

My question: what is happening here? Why is the result what it is, and not what I was expecting?

Thanks in advance.

With kind regards,

Sjoerd

Parents
  • Andrew Beckett

    Hi Sjoerd,

    The reason is not for speed. There are a few reasons:

    1. Since you are commonly comparing against literal values, if the expression is evaluated, you'd have to quote (with "'") any symbols in the target expression
    2. The form allows you to have multiple match values in a list (without the list needing to be quoted or using the list() function). This wouldn't be possible if the expression was evaluated - because then you'd probably expect it to be able to match a list. Other languages have the idea of a switch/case statement which can fall through to another (which causes no end of trouble in those languages because of accidentally omitting "break"), but we don't have that here - you have to explicitly list all target matches in one place. Without the multiple-target form, you'd have to repeat the clause multiple times with different targets.
    3. Most other languages only compare literal values (in C you can't compare strings, only ints, floats and enums).
    4. You can easily have the evaluated form using cond() instead...

    In fact you can always write a macro to do what you want. For example:

    (defmacro CCFcaseEval (match @rest clauses)
      `(cond
         ,@(foreach mapcar clause clauses
                    (if (eq (car clause) t)
                      clause
                      `((equal ,match ,(car clause)) ,@(cdr clause))))))

    With this, you can use your code:

    CCFcaseEval( testString
        ( nthelem( 1 testOptions )
            printf("it is 1!\n")
        )
        ( nthelem( 2 testOptions )
            printf("it is 2!\n")
        )
        ( t
            printf("it is something else!\n")
        )
    )

    and it will then do what you want. If you can understand the slight gobbledegook of the macro, you will see that it actually transforms into a cond() statement:

    expandMacro('CCFcaseEval( testString
        ( nthelem( 1 testOptions )
            printf("it is 1!\n")
        )
        ( nthelem( 2 testOptions )
            printf("it is 2!\n")
        )
        ( t
            printf("it is something else!\n")
        )
      )
    )

    This produces:

    cond(
        ((testString == nthelem(1 testOptions))
            printf("it is 1!\n")
        )
        ((testString == nthelem(2 testOptions))
            printf("it is 2!\n")
        )
        (t
            printf("it is something else!\n")
        )
    )

    You probably wish you hadn't asked now!

    Kind Regards,

    Andrew.

Reply
  • Andrew Beckett

    Hi Sjoerd,

    The reason is not for speed. There are a few reasons:

    1. Since you are commonly comparing against literal values, if the expression is evaluated, you'd have to quote (with "'") any symbols in the target expression
    2. The form allows you to have multiple match values in a list (without the list needing to be quoted or using the list() function). This wouldn't be possible if the expression was evaluated - because then you'd probably expect it to be able to match a list. Other languages have the idea of a switch/case statement which can fall through to another (which causes no end of trouble in those languages because of accidentally omitting "break"), but we don't have that here - you have to explicitly list all target matches in one place. Without the multiple-target form, you'd have to repeat the clause multiple times with different targets.
    3. Most other languages only compare literal values (in C you can't compare strings, only ints, floats and enums).
    4. You can easily have the evaluated form using cond() instead...

    In fact you can always write a macro to do what you want. For example:

    (defmacro CCFcaseEval (match @rest clauses)
      `(cond
         ,@(foreach mapcar clause clauses
                    (if (eq (car clause) t)
                      clause
                      `((equal ,match ,(car clause)) ,@(cdr clause))))))

    With this, you can use your code:

    CCFcaseEval( testString
        ( nthelem( 1 testOptions )
            printf("it is 1!\n")
        )
        ( nthelem( 2 testOptions )
            printf("it is 2!\n")
        )
        ( t
            printf("it is something else!\n")
        )
    )

    and it will then do what you want. If you can understand the slight gobbledegook of the macro, you will see that it actually transforms into a cond() statement:

    expandMacro('CCFcaseEval( testString
        ( nthelem( 1 testOptions )
            printf("it is 1!\n")
        )
        ( nthelem( 2 testOptions )
            printf("it is 2!\n")
        )
        ( t
            printf("it is something else!\n")
        )
      )
    )

    This produces:

    cond(
        ((testString == nthelem(1 testOptions))
            printf("it is 1!\n")
        )
        ((testString == nthelem(2 testOptions))
            printf("it is 2!\n")
        )
        (t
            printf("it is something else!\n")
        )
    )

    You probably wish you hadn't asked now!

    Kind Regards,

    Andrew.

Children
No Data

Community Guidelines

The Cadence Design Communities support Cadence users and technologists interacting to exchange ideas, news, technical information, and best practices to solve problems and get the most from Cadence technology. The community is open to everyone, and to provide the most value, we require participants to follow our Community Guidelines that facilitate a quality exchange of ideas and information. By accessing, contributing, using or downloading any materials from the site, you agree to be bound by the full Community Guidelines.