Procedure definition structure:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 +---proc ProcName, [arg]---+  Arguments have to be local (dotted).
 |                          |  Otherwise, error will araise.
 |     .cloc1 dd ?          |  Common locals block, between "proc" and
 |     .cloc2 dd ?          |  "begin". Not overlaped by "locals" blocks.
 +---begin------------------+
 | +--locals -------+       | Code block between "begin" and
 | |    .loc1 dd ?  |       | "endp" - optional content.
 | |    .loc2 dw ?  |       |
 | +--endl ---------+       | Floating locals blocks inside the
 |                          | code, enclosed between "locals"
 | +--locals--------+       | and "endl" where every block
 | |    .loc3 db ?  |       | overlaps the others in stack
 | |    .loc4 db ?  |       | memory.
 | +--endl----------+       |
 |                          |
 +--endp--------------------+


Frame structure:
~~~~~~~~~~~~~~~~
+----+ ---------> [ebp - Frame1 - commsize]
|    | Frame 1
|    |----+ ----------> [ebp-Frame2-commsize]
|    |    | Frame 2
|    |    |----+ ---------> [ebp-Frame3-commsize]
|    |    |    | Frame 3
+--------------+ ---------> [ebp-commsize]
|              | Frame, that is common for
|              | entire procedure.
+--------------+ -------------------> [ebp]
|              | Arguments
+--------------+ ------> [ebp+Arguments]    

Procedure definition structure:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 +--proc ProcedureName------+ 
 |    .arg1 dd ?            | Arguments block between "proc" 
 |    .arg2 dd ?            | and "begin" - optional content 
 |    .arg3 dd ?            | 
 | +--locals -------+       | Common locals block, between "proc" and
 | |    .cloc1 dd ? |       | "begin". Not overlaped by "locals" blocks.
 | |    .cloc2 dw ? |       |
 | +--endl ---------+       | Floating locals blocks inside the
 +---begin------------------+
 | +--locals -------+       | Code block between "begin" and
 | |    .loc1 dd ?  |       | "endp" - optional content.
 | |    .loc2 dw ?  |       |
 | +--endl ---------+       | Floating locals blocks inside the
 |                          | code, enclosed between "locals"
 | +--locals--------+       | and "endl" where every block
 | |    .loc3 db ?  |       | overlaps the others in stack
 | |    .loc4 db ?  |       | memory.
 | +--endl----------+       |
 |                          |
 +--endp--------------------+
    

Hi, all.
S.T.A.S, I am agree - we don't need two proc macroses. Only two returns.

I agree, but I would prefer your style "4"

cproc equ proc    

Also, I found the method to track whether the arguments are dotted or not, so now it is not a problem to keep arguments in the "proc" statement.

IMO, from user point of view, it would be better to have two proc macroses. It simply would be more readable, when I will see "proc" or "cproc" I will know what calling convensions it uses. Using two returns, I would have to scroll through its code to find what kind of proc it is.

; stdcall
proc  foo  arg,arg2,arg3
...........
; cdecl
proc  bar  arg,arg2, ...  ; <- notice name of the last argument
..........     

And what if I write one proc with two different returns?

What I mean is something like this:

Code:

; stdcall
proc  foo  arg,arg2,arg3
...........
; cdecl
proc  bar  arg,arg2, ...  ; <- notice name of the last argument
..........     

Quote:

And what if I write one proc with two different returns?

For which purpose ?

proc foo
...some code...
    stdcall_ret
...some other code...
    c_ret
endp    

of course it doesn't have any sense, but solution with different returns would allow this.