Differents bt function and subroutine

hi gem's
i want 2 know  wether the form return's a value r not......

hi,
1)
Functions should behave like mathematical functions. That is, they should take arguments and compute and return a result without any side effects. They should not perform I/O and they should not change the values of their actual arguments. (Fortran won't stop you from writing a function that causes side effects, but it is poor form nonetheless.)
Subroutines should take arguments and (since they can't return anything) cause side effects. That is, they should perform I/O or change the values of their actual arguments. This is the only way that a subroutine has of communicating with the outside world.
2)
Subroutines
A subroutine takes a number of input parameters but does not return a value.  The input parameters are passed by-value, which means their values are copied directly onto the stack when the routine is called.  There are no pointers in TEA.  A subroutine may have local variables which must also be stored on the stack.  The number of input parameters and local variables is limited by the amount of free stack space.
An example subroutine is listed below.  It has two input parameters and one local variable.  The asm block contains VM instructions .
void foo(int n, char c)
  int var1;
  asm
    (VM code goes here)
When executing a subroutine, the input parameters go on the stack first in the order in which they are declared.  The call instruction pushes the return address bytes to the stack and branches to the subroutine.  Once inside the subroutine, any local variables are stored on the stack in the order in which they are declared.  Uninitialized local variables are initialized to "-1" by default.  Calling the example routine listed above requires seven stack bytes: three for the input parameters, two for the return address, and two for the local variable.  Prior to execution of the instructions in the asm block, the top seven stack btyes will contain:n (high) n (low) c return addr. (high) return addr. (low) var1 (high) var1 (low)
If n=0x0320, c=0x14, and the return address is 0x0120, the values in the top seven stack bytes will be:0x03 0x20 0x14 0x01 0x20 0xFF 0xFF
The TEA compiler creates code that does this parameter passing and local variable allocation automatically.  The user may write code within the asm block that accesses the input parameters and local variables.  After the subroutine completes its task, the VM will pop the local variables off the stack, branch to the return address, and discard the input parameters.  This clean-up process is also automatic.
Functions
A function takes a number of input parameters and returns a value.  As with subroutines, the input parameters are passed by-value.  Parameter passing and local variable allocation also works the same way.  Unlike subroutines, functions require a place holder in the stack for the return value.  Furthermore, the compiler requires an explicit return statement for each function.  Because of this, the user must declare a local variable to hold a temporary return value and use the TEA return statement to pass the result.
An example function is listed below.  It has one input parameter and two local variables.  The asm block contains VM instructions .
int foo(char c)
  int result;
  int var1=0;
  asm
    (VM code goes here)
  return result;
When executing a function, the first thing to go on the stack is a place holder for the return value.  Calling the example routine listed above requires nine stack bytes: two for the return value place holder, one for the input parameter, two for the return address, and four for the local variables.  Prior to execution of the instructions in the asm block, the top nine stack btyes will contain:int (high) int (low) c return addr. (high) return addr. (low) result (high) result (low) var1 (high) var1 (low)
If c=0x24 and the return address is 0x024A, the values in the top nine stack bytes will be:0xFF 0xFF 0x24 0x02 0x4A 0xFF 0xFF 0x00 0x00
The result variable is unitialized so it is set to "-1" by default.  The return value place holder is also set to "-1" by default.  The var1 variable is initialized to "0".  The code in the asm block must write its output to the result variable for the function to work properly.  At function completion, the return statement writes the return value into the place holder.  Then the VM will pop the local variables off the stack, branch to the return address, and discard the input parameters.  The return value will be on top of the stack.

Similar Messages

  • Difference between Macros and subroutine

    Hi all,
    What is the difference between the macros subroutine and function module functinalitywise.;

    Hi,
    Macros can only be used in the program the are defined in and only after the definition.
    Macros can take max 9 parameters.
    Macros are expanded at compilation / generation.
    Subroutines (FORM) can be called from both the program the are defined in and other programs ('perform
    ' of 'perform in program ').
    Subroutines can take any amount of parameters.
    Subroutines are 'expanded' at runtime.
    Functions are just like FORMs, but are intended to be called external.
    Some differences between FUNCTIONs and FORMs:
    The name of a FORM must be unique within the program (two programs can have different FORMs with the same name). A FORM is intended to be called internal (from within the program, however by a 'trick' you can call them external).
    The name of a FUNCTION has to be unique throughout the system. A FUNCTION is intended to be called external (and is thus shared by 'many' programs).
    The latter is more important for programmers and maintenance. Since a FUNCTION is called external, it is important to keep the interface (parameters) the same. The interface of a FORM (which is intended to be called internal) is check when debugging a program (but it is only checked within the program that is debugged). So if the interface of a FORM is changed, but the call to the FORM (perform ) is not, the debugger will notice this and issue an error message.
    In general:
    A MACRO is more or less an abbreviation for some lines of code that are used more than once or twice.
    A FORM is a local subroutine (which can be called external).
    A FUNCTION is (more or less) a subroutine that is called external.
    Since debugging a MACRO is not really possible, prevent the use of them (I've never used them, but seen them in action). If the subroutine is used only local (called internal) use a FORM. If the subroutine is called external (used by more than one program) use a FUNCTION.
    --Excerpt from http://sap.ittoolbox.com/documents/popular-q-and-a/macro-vs-subroutine-1594#
    DATA p_c(10).
    FIELD-SYMBOLS: <fs> TYPE ANY.
    DATA p_old1 TYPE i VALUE 10.
    DATA p_old2 TYPE i VALUE 11.
    DATA p_old3 TYPE i VALUE 12.
    DATA p_old4 TYPE i VALUE 13.
    DATA p_old5 TYPE i VALUE 14.
    DATA p_old6 TYPE i VALUE 15.
    DATA p_old7 TYPE i VALUE 16.
    DATA p_old8 TYPE i VALUE 17.
    DATA p_old9 TYPE i VALUE 18.
    DATA p_old10 TYPE i VALUE 19.
    DATA p_old11 TYPE i VALUE 21.
    DATA p_old12 TYPE i VALUE 22.
    DATA p_old13 TYPE i VALUE 23.
    DATA p_old14 TYPE i VALUE 24.
    DEFINE ADD_MAPPING.
    p_c = &1.
    CONDENSE p_c.
    CONCATENATE 'p_old' p_c INTO p_c.
    ASSIGN (p_c) TO <fs>.
    WRITE <fs>.
    END-OF-DEFINITION.
    DO 14 TIMES.
    ADD_MAPPING sy-index.
    ENDDO.
    http://sap.ittoolbox.com/documents/popular-q-and-a/macro-vs-subroutine-1594
    http://help.sap.com/saphelp_nw2004s/helpdata/en/9f/db972835c111d1829f0000e829fbfe/frameset.htm
    Regards,
    Priyanka.

  • Difference between Macros and subroutines

    Hi experts can any one tell difference between macros and subroutines.

    1) Macros can only be used in the program the are defined in and only after the definition are expanded at compilation / generation. Subroutines (FORM) can be called from both the program the are defined in and other programs . A MACRO is more or less an abbreviation for some lines of code that are used more than once or twice. A FORM is a local subroutine (which can be called external). A FUNCTION is (more or less) a subroutine that is called external. Since debugging a MACRO is not really possible, prevent the use of them (I’ve never used them, but seen them in action). If the subroutine is used only local (called internal) use a FORM. If the subroutine is called external (used by more than one program) use a FUNCTION
    2)  The macros, which we may use,
    (stored in table TRMAC)
    , we cannot debug that code.
    3) where as in subroutine,
    its a abap code, directly visile in
    the editor,
    and we can debug this code.
    4) MACROS =>
    Getting a feel of macros
    The basic syntax of macros is as follows:
    DEFINE macro_name. "Macro Definition
    ……………. Statements
    ……………. Statements
    END-OF-DEFINITION. "Macro Definition
    macro_name par1 par2 …par9. "Macro call -parameters separated by spaces
    Within the DEFINE... and END-OF-DEFINITION lies the body of the macro—the statements that you wish to be executed each time the macro is called. These statements may be any valid ABAP statements, such as WRITE, CLEAR, FORM calls, or database statements such as SELECT or UPDATE.
    To familiarize yourself with the working of macros, it's necessary to take a close look at exactly what happens when an ABAP program containing a macro call is generated. Consider Listing A.
    All ABAP programs must be generated before they can be executed. At the time of program generation, the system supplants each macro call, as shown in Listing A, with the statement(s) placed between the macro definition. Furthermore, the parameters passed at the time of macro calling are copied in place of the any placeholders (numbered &1, &2 …&9) found in the body of the macro definition. The system simply ignores the presence of the macros during the execution of the program—that is, all statements are executed as a single block of code:
    write : int1.
    write : int2.
    write : int3.
    Other than readability and meaningfulness, macros also offer performance advantages. For testing purposes, I wrote a macro that incremented the value of a variable by 1 and called the macro N times via a DO loop, as shown here:
    DEFINE INCREMENT.
    ADD 1 TO &1.
    END-OF-DEFINITION.
    DO N TIMES.
    INCREMENT VAR1.
    ENDDO.
    SUBROUTINES=>
    Subroutines
    You call subroutines from ABAP programs using the PERFORM statement.
    Subroutines are introduced with the FORM statement and concluded with the ENDFORM statement.
    You can define subroutines in any ABAP program. You can either call a subroutine that is part of the same program or an external subroutine, that is, one that belongs to a different program. If you call an internal subroutine, you can use global data to pass values between the main program and the subroutine. When you call an external subroutine, you must pass actual parameters from the main program to formal parameters in the subroutine.
    *U Shud start rewarding helpfull answers*
    amit

  • Difference between macro and subroutine

    what is the difference between macro and subroutine? i
    need some example on macro

    Hi,
    <b>
    Subroutines</b>
    Subroutines are procedures that you can define in any ABAP program and also
    call from any program. Subroutines are normally called internally, that is, they
    contain sections of code or algorithms that are used frequently locally. If you want
    a function to be reusable throughout the system, use a function module.
    <b>Defining Subroutines</b>
    A subroutine is a block of code introduced by FORM and concluded by ENDFORM.
    FORM <subr> [USING ... [VALUE(]<pi>[)] [TYPE <t>|LIKE <f>]... ]
    [CHANGING... [VALUE(]<pi>[)] [TYPE <t>|LIKE <f>]... ].
    ENDFORM.
    <subr> is the name of the subroutine. The optional additions USING and
    CHANGING define the parameter interface. Like any other processing block,
    subroutines cannot be nested. You should therefore place your subroutine
    definitions at the end of the program, especially for executable programs (type 1).
    In this way, you eliminate the risk of accidentally ending an event block in the
    wrong place by inserting a FORM...ENDFORM block.
    <b>Macros</b>
    If you want to reuse the same set of statements more than once in a program, you can include
    them in a macro. For example, this can be useful for long calculations or complex WRITE
    statements. You can only use a macro within the program in which it is defined, and it can only
    be called in lines of the program following its definition.
    The following statement block defines a macro <macro>:
    DEFINE <macro>.
    <statements>
    END-OF-DEFINITION.
    You must specify complete statements between DEFINE and END-OF-DEFINITION. These
    statements can contain up to nine placeholders (&1, &2, ..., &9). You must define the macro
    before the point in the program at which you want to use it.
    Macros do not belong to the definition part of the program. This means that the DEFINE...ENDOF-
    DEFINITION block is not interpreted before the processing blocks in the program. At the
    same time, however, macros are not operational statements that are executed within a
    processing block at runtime. When the program is generated, macro definitions are not taken
    into account at the point at which they are defined. For this reason, they do not appear in the
    overview of the structure of ABAP programs [Page 44].
    A macro definition inserts a form of shortcut at any point in a program and can be used at any
    subsequent point in the program. As the programmer, you must ensure that the macro
    definition occurs in the program before the macro itself is used. Particular care is required if you
    use both macros and include programs, since not all include programs are included in the syntax
    check (exception: TOP include).
    To use a macro, use the following form:
    <macro> [<p1> <p2> ... <p9>].
    When the program is generated, the system replaces <macro> by the defined statements and
    each placeholder &i by the parameter <pi>. You can use macros within macros. However, a
    macro cannot call itself.
    DATA: RESULT TYPE I,
    N1 TYPE I VALUE 5,
    N2 TYPE I VALUE 6.
    DEFINE OPERATION.
    RESULT = &1 &2 &3.
    OUTPUT &1 &2 &3 RESULT.
    END-OF-DEFINITION.
    DEFINE OUTPUT.
    WRITE: / 'The result of &1 &2 &3 is', &4.
    END-OF-DEFINITION.
    OPERATION 4 + 3.
    OPERATION 2 ** 7.
    OPERATION N2 - N1.
    The produces the following output:
    The result of 4 + 3 is 7
    The result of 2 ** 7 is 128
    The result of N2 - N1 is 1
    Here, two macros, OPERATION and OUTPUT, are defined. OUTPUT is nested in
    OPERATION. OPERATION is called three times with different parameters. Note
    how the placeholders &1, &2, ... are replaced in the macros.
    Rgds,
    Prakash

  • What is the difference between function and method

    Hey I need help I dont know which is the difference between function and method ?
    Does anybody can ask me this question.
    Thanks

    jverd wrote:
    The first two answers were also correct.Also the blocked message, quoted here for posterity:
    "Tinkerbell" wrote:
    Methods are defined by Java whereas functions are not. ~

  • Exact difference between function and procedure

    exact difference between function and procedure(real time diff.....not like return value, dml....) and function do some work at the same time that work also do procedure..why function

    ranitB wrote:
    1. Function is called Inline a query. A return value is must.
    But, procedure may/may not contain a return value.Not true.
    A function may be called in a query providing it meets certain limitations (no DDL, or transactional statements such as commit/rollback etc.).
    A function does not have to be called from a query, it can be called from other PL/SQL code or from other external applications.
    Regular functions must return a value, though pipelined functions do not...
    SQL> CREATE OR REPLACE TYPE split_tbl IS TABLE OF VARCHAR2(32767);
      2  /
    Type created.
    SQL> CREATE OR REPLACE FUNCTION split (p_list VARCHAR2, p_delim VARCHAR2:=' ') RETURN SPLIT_TBL PIPELINED IS
      2      l_idx    PLS_INTEGER;
      3      l_list   VARCHAR2(32767) := p_list;
      4      l_value  VARCHAR2(32767);
      5    BEGIN
      6      LOOP
      7        l_idx := INSTR(l_list, p_delim);
      8        IF l_idx > 0 THEN
      9          PIPE ROW(SUBSTR(l_list, 1, l_idx-1));
    10          l_list := SUBSTR(l_list, l_idx+LENGTH(p_delim));
    11        ELSE
    12          PIPE ROW(l_list);
    13          EXIT;
    14        END IF;
    15      END LOOP;
    16      RETURN;
    17    END SPLIT;
    18  /
    Function created.
    SQL> SELECT column_value
      2  FROM TABLE(split('FRED,JIM,BOB,TED,MARK',','));
    COLUMN_VALUE
    FRED
    JIM
    BOB
    TED
    MARK... whilst the definition of the function shows a return type, the return statement inside the function simply returns, without a value. That's because the data is passed back through a special "pipeline", and you can write code to show that the data is available to a query as soon as it's piped, and before the function has completed (reached the return statement) if you like.
    A procedure does not return a value (And no an OUT parameter is not a "returned" value, it's a writeable parameter, there's a difference)
    2. There are some limitations in functions which is possbl through procedures.
    Like - Oracle doesn't support DML in functions called in Select queries (using PRAGMA AUTONOMOUS_TRANSACTION will help).Not strictly true. and SQL query is considered to be DML, so a function could perform a query and then be used inside another query...
    SQL> ed
    Wrote file afiedt.buf
      1  create or replace function f_dname(p_deptno in number) return varchar2 is
      2    v_dname varchar2(10);
      3  begin
      4    select dname into v_dname
      5    from   dept
      6    where  deptno = p_deptno;
      7    return v_dname;
      8* end;
    SQL> /
    Function created.
    SQL> ed
    Wrote file afiedt.buf
      1* select empno, ename, f_dname(deptno) as dname from emp
    SQL> /
         EMPNO ENAME      DNAME
          7369 SMITH      RESEARCH
          7499 ALLEN      SALES
          7521 WARD       SALES
          7566 JONES      RESEARCH
          7654 MARTIN     SALES
          7698 BLAKE      SALES
          7782 CLARK      ACCOUNTING
          7788 SCOTT      RESEARCH
          7839 KING       ACCOUNTING
          7844 TURNER     SALES
          7876 ADAMS      RESEARCH
          7900 JAMES      SALES
          7902 FORD       RESEARCH
          7934 MILLER     ACCOUNTING
    14 rows selected.It's been discussed many times on the forum... my favourite here...
    {message:id=1668675}
    Edited by: BluShadow on 17-Sep-2012 09:22

  • Difference between Function and Stored Procedure

    Hi guys, i don't understand the exact difference between a function and a stored procedure. I did lot of google but still. Can somebody explain in simple words. Thanks.

    Hi,
    Here's an example of a user-defined function:
    CREATE OR REPLACE FUNCTION     factorial
    (      in_num       IN     PLS_INTEGER
    RETURN     PLS_INTEGER
    DETERMINISTIC
    IS
    BEGIN
         IF  in_num IS NULL
         THEN
              RETURN     NULL;
         ELSIF in_num <= 1
         THEN
              RETURN  1;
         ELSE
              RETURN  in_num * factorial (in_num - 1);
         END IF;
    END     factorial;
    SHOW ERRORSThis function retruns an integer. You can use the function (or, more properly, the integer that it returns) anywhere an integer expression is allowed.
    For example
    SELECT     ROWNUM
    ,     factorial (ROWNUM)     AS f
    ,     loc
    ,     SUBSTR ( loc
                , 1
                , factorial (ROWNUM)
                )          AS s
    FROM     scott.dept;Output:
    `   ROWNUM          F LOC           S
             1          1 NEW YORK      N
             2          2 DALLAS        DA
             3          6 CHICAGO       CHICAG
             4         24 BOSTON        BOSTON

  • Difference between function and procedure

    Hi all,
    Please send me the difference b/w functions and procedures.
    Regards
    dskumar

    A procedure may(1 or many) or may not return a
    value,I have yet to see a procedure returning a value. Whilst it can pass out values using OUT and IN OUT parameters, it doesn't RETURN values.
    A function always returns one value.A function may also include OUT and IN OUT parameters to pass back values but it's not recommended.

  • Difference between Function and Automated Activity

    Hi All,
    After struggling with a few BPA Suite/JDev compatibility issues over the past few days, we've finally got a basic setup up and running (JDev 11.1.1.1 worked - 11.1.1.2 did not).
    I'm new to BPA and have 2 fairly basic questions - haven't found conclusive answers to these and hence, raising it on this forum...
    1. What is the difference between a "Function" and an "Automated activity" in the BPA Suite? I had expected the latter to translate to a BPEL invoke but what appears to happen is:
    - "Function" tranlsates to a BPEL Scope + Invoke.
    - "Automated activity" translates to a BPEL Scope + Empty Task.
    Based on this, I would not plan to use a "Function" for web service invocations but not sure where I would use the automated activities.
    2. Is there a BPMN construct that would translate to a BPEL "Assign"? I understand that an Assign is fairly low-level and would normally be expected to be filled in by the BPEL developer (and not by the Business Analyst specifying the BPMN model) but it would be quite handy to be able to specify this in BPMN in some cases..
    Thanks..
    TBKol
    Edited by: TBKol on Apr 23, 2010 4:58 AM

    Hi All,
    After struggling with a few BPA Suite/JDev compatibility issues over the past few days, we've finally got a basic setup up and running (JDev 11.1.1.1 worked - 11.1.1.2 did not).
    I'm new to BPA and have 2 fairly basic questions - haven't found conclusive answers to these and hence, raising it on this forum...
    1. What is the difference between a "Function" and an "Automated activity" in the BPA Suite? I had expected the latter to translate to a BPEL invoke but what appears to happen is:
    - "Function" tranlsates to a BPEL Scope + Invoke.
    - "Automated activity" translates to a BPEL Scope + Empty Task.
    Based on this, I would not plan to use a "Function" for web service invocations but not sure where I would use the automated activities.
    2. Is there a BPMN construct that would translate to a BPEL "Assign"? I understand that an Assign is fairly low-level and would normally be expected to be filled in by the BPEL developer (and not by the Business Analyst specifying the BPMN model) but it would be quite handy to be able to specify this in BPMN in some cases..
    Thanks..
    TBKol
    Edited by: TBKol on Apr 23, 2010 4:58 AM

  • Re: Difference between function and procedure

    Hello Oracles Guru’s,
    I am learning Oracle and I am beginner. My question may be simple and not worth to ask but I am sorry
    Why we call Procedures as Stored Procedure but we call functions only functions.
    As per my understanding I think but the objects are stored as objects in the database.
    Please clarify.

    HIJACKED THREAD!
    Please don't hijack another user's thread.
    If you have a question or issue create a new thread and ask it.

  • Use of function and procedures

    when we need to use function rather than procedure or viceversa???

    Welcome to the forum!
    Use a function if you want to use the value it returns as you would use any other expression in a SQL statement:
    SELECT  SYSDATE
    ,       my_function (column1)  AS c1
    ,       UPPER (column2)        AS c2
    FROM    table_x;or in PL/SQL:
    IF  my_function (x) > 0  THEN  ...Use a procedure otherwise; for example, if there is no value to be passed back.
    Functions can have OUT (and IN OUT) arguments, but they can cause confusion. Many people use procedures whenever they need OUT arguemnts, which includes all situations where 2 or more values are passed back.
    Any good book or site on PL/SQL, or any kind of procedural programming, should explain the differences between functions and procedures.
    If you don't have at least that much guidance, it's better not to try using PL/SQL.

  • Doubts in Functions and Procedures

    Hi Everybody,
    Can anybody tell the exact differences between function and the Procedure?
    My doubts are
    1. if procedure can return, and not necessary that it has to return a value,(that means if we want to return and doesnt also we can write procedure) then why do we need function?
    2. I tried to call a function which updates one table in the code,, i got an error saying that the function should not use DML.
    3. I want to know the combination that
    a. can procedure call a function and viceversa?
    b. can function (which uses DML statements)be called from sql statement ?
    and if any other combinations are there let me know with reasons.
    Thanks in advance,
    Vinay

    To elaborate on the already correct answers...
    user12281717 wrote:
    Can anybody tell the exact differences between function and the Procedure?
    My doubts are
    1. if procedure can return, and not necessary that it has to return a value,(that means if we want to return and doesnt also we can write procedure) then why do we need function?Procedures and Functions are self contained blocks of executable code. When that code completes it has to "return" to whatever called it, so both Procedures and Functions do return, however a procedure has an implicit return when it reaches the end of the code (or you can specify the keyword RETURN without any value if you like), whereas a function must contain a RETURN keyword before reaching the END keyword and a value of the correct datatype must be returned by that RETURN keyword.
    Functions must return a value, whereas Procedures do not return any value.
    If values need to be passed back from a procedure then OUT or IN OUT parameters are used, however if values are to be passed back then often it is something that should be considered for being a function rather than a procedure.
    Functions may also contain OUT or IN OUT parameters, but these types of parameters limit the function to use within PL/SQL code only and prevent them from being used in SQL, as the SQL engine will have no variable to pass back the OUT value into. Generally it is considered bad practice to use OUT or IN OUT parameters in functions.
    The underlying internal differences of Functions and Procedures comes down to how values are passed in and returned via the internal stack or via memory references where the parameter is specified as an OUT / IN OUT with NOCOPY. If you're not familiar with writing machine code / assembly language or low level C code, then this concept will probably be alien to you and it will take more than a simple post to explain it.
    2. I tried to call a function which updates one table in the code,, i got an error saying that the function should not use DML.Functions can contain DML, but those functions can only be used from a PL/SQL call to it, not from within a call from an SQL DML itself. i.e. a DML cannot contain further DML.

  • Diff between Function Module and subroutine

    sir,
      explain the difference between Function Module and Subroutine.

    Hi Sandeep,
    Subroutines:
       Subroutines are procedures that you can define in any ABAP program and also call from any program. Subroutines are normally called internally, that is, they contain sections of code or algorithms that are used frequently locally. If you want a function to be reusable throughout the system, use a function module.
    Function Modules:
    Function modules are procedures that are defined in function groups (special ABAP programs with type F) and can be called from any ABAP program. Function groups act as containers for function modules that logically belong together. You create function groups and function modules in the ABAP Workbench using the Function Builder.
    Function modules allow you to encapsulate and reuse global functions in the R/3 System. They are stored in a central library.
    Unlike subroutines, you do not define function modules in the source code of your program. Instead, you use the Function Builder.
    Regards,
    Sunil

  • 1)Now I use Lightrom 5.7 how to upgrade to 6 or CC? 2) What is the difference between 6 and CC vercion? 3) When I used lightromm 3, I could see inEXIF the distance in meters till the object I took, in the later virsions that function disappeared, it is ve

    1)Now I use Lightrom 5.7 how to upgrade to 6 or CC?
    2) What is the difference between 6 and CC version?
    3) When I used lightromm 3, I could see in EXIF the distance in meters till the object I took, in the later virsions that function disappeared, it is very sad  I am stiil waiting and hope that it would be possibble in the new  versions. Or this indication may  possible by setting?

    1)Now I use Lightrom 5.7 how to upgrade to 6 or CC?
    Purchase the standalone upgrade from here: Products
    Download CC version from here: Explore Adobe desktop apps | Adobe Creative Cloud
    2) What is the difference between 6 and CC version?
    See this comparison chart: Compare Lightroom versions | Adobe Photoshop Lightroom CC
    3) When I used lightromm 3, I could see in EXIF the distance in meters till the object I took, in the later virsions that function disappeared, it is very sad  I am stiil waiting and hope that it would be possibble in the new  versions. Or this indication may  possible by setting?
    Rob Cole's ExifMeta plugin displays the Subject Distance field (and much more).  Unfortunately, his Web site appears to be down again.  He used to be very active here, but he hasn't posted in several months.

  • Functional and data differences between W_GL_BALANCE_F and W_GL_OTHER_F

    Hi:
    Can some explain what the functional and data-source differences are between W_GL_BALANCE_F and W_GL_OTHER_F? Both seem to group by GROUP_ACCOUNT_NUM.
    Thanks.

    That is not possible; all transaction in GL Other will end up in GL Balance.
    The two tables are essentially having the same data but at different grain. Two main differences:
    - GL Other have individual journal transactions; GL Balance have them summarized to the account level.
    - GL Other is truly additive since its just individual journal transactions. i.e. you can just sum() any number of transactions and wont double count a trx; GL Balance is a monthly snapshot table. i.e. it provides account balance for all accounts for every month end, so you can never add two snapshots.

Maybe you are looking for

  • Get date AND time to show in the menu bar

    What is that technique to get date AND time to show in the menu bar please?

  • Urgent Help need for ABAP Custom Process Types

    Hi Gurus, I have created a Custom Process Type for ABAP program which returns status (Success or Failure). I followed the below procedure to create a custom ABAP process type. In RSPC, I went to Settings -> Maintain process types I selected the ABAP

  • Please help(Very Urgent)

    Hi, Iam facing with one problem I can upload file upto 40mb by running my swing interface(java -Xmx256m ActionDemo4).If I select above 40mb size of file then it giving me Error on Dos-Prompt(java.lang.OutOfMemory).Now I increase jvm memory by (-Xmx54

  • How to change audio device?

    Hi! My computer is HP Compaq 7900p small. I bought new graphics card which is Asus AMD HD6450. When I test it I saw problem - no sound. When I click on Sounds tab, I see that AMD HDMI Output-AMD High Definition Audio Device - not plugged in and I cou

  • Activate Office 2010 Professional Plus with MAK

    How do I activate a new computer to download Office Professional Plus 2010? I have an MAK but I do not know how to use it. Thanks.