New tokens, proper parsing and new VMT slots for new management operators: AddRef and Copy. New operators require changes to RTL (that will be committed next time).

pdecsub.pas:
  + parse new _ADDREF and _COPY tokens as _OP_ADDREF and _OP_COPY
  + proper handling for new operators

symconst.pas, tmanagementoperator:
  + new enum items: mop_addref and mop_copy

symtable.pas:
  * overloaded_names and managementoperator2tok adjusted to new operators

tokens.pas:
  + new tokens for management operators: _ADDREF, _COPY, _OP_ADDREF, _OP_COPY

git-svn-id: branches/maciej/smart_pointers@33469 -

compiler/pdecsub.pas

@@ -595,6 +595,8 @@ implementation
                     _DEC:optoken:=_OP_DEC;
                     _INITIALIZE:optoken:=_OP_INITIALIZE;
                     _FINALIZE:optoken:=_OP_FINALIZE;
+                    _ADDREF:optoken:=_OP_ADDREF;
+                    _COPY:optoken:=_OP_COPY;
                     else
                     if (m_delphi in current_settings.modeswitches) then
                       case lastidtoken of
@@ -1409,11 +1411,25 @@ implementation
                 end;
 
               { operators without result }
-              if optoken in [_OP_INITIALIZE, _OP_FINALIZE] then
+              if optoken in [_OP_INITIALIZE, _OP_FINALIZE, _OP_ADDREF, _OP_COPY] then
                 begin
-                  if (pd.parast.SymList.Count <> 1) or
-                     (tparavarsym(pd.parast.SymList[0]).vardef<>pd.struct) or
-                     (tparavarsym(pd.parast.SymList[0]).varspez<>vs_var) then
+                  { single var parameter to point the record }
+                  if (optoken in [_OP_INITIALIZE, _OP_FINALIZE, _OP_ADDREF]) and
+                     (
+                      (pd.parast.SymList.Count <> 1) or
+                      (tparavarsym(pd.parast.SymList[0]).vardef<>pd.struct) or
+                      (tparavarsym(pd.parast.SymList[0]).varspez<>vs_var)
+                     ) then
+                    Message(parser_e_overload_impossible)
+                  { constref (source) and var (dest) parameter to point the records }
+                  else if (optoken = _OP_COPY) and
+                     (
+                      (pd.parast.SymList.Count <> 2) or
+                      (tparavarsym(pd.parast.SymList[0]).vardef<>pd.struct) or
+                      (tparavarsym(pd.parast.SymList[0]).varspez<>vs_constref) or
+                      (tparavarsym(pd.parast.SymList[1]).vardef<>pd.struct) or
+                      (tparavarsym(pd.parast.SymList[1]).varspez<>vs_var)
+                     ) then
                     Message(parser_e_overload_impossible);
 
                   trecordsymtable(pd.procsym.Owner).includemanagementoperator(

compiler/symconst.pas

@@ -574,7 +574,9 @@ type
 
   tmanagementoperator=(mop_none,
     mop_initialize,
-    mop_finalize
+    mop_finalize,
+    mop_addref,
+    mop_copy
   );
   tmanagementoperators=set of tmanagementoperator;
 

compiler/symtable.pas

@@ -430,14 +430,19 @@ interface
     { _OP_EXPLICIT   }  'explicit',
     { _OP_ENUMERATOR }  'enumerator',
     { _OP_INITIALIZE }  'initialize',
-    { _OP_FINALIZE   }  'finalize',    
+    { _OP_FINALIZE   }  'finalize',
+    { _OP_ADDREF     }  'addref',
+    { _OP_COPY       }  'copy',
     { _OP_INC        }  'inc',
     { _OP_DEC        }  'dec');
 
       managementoperator2tok:array[tmanagementoperator] of ttoken = (
     { mop_none       }  NOTOKEN,
     { mop_initialize }  _OP_INITIALIZE,
-    { mop_finalize   }  _OP_FINALIZE);
+    { mop_finalize   }  _OP_FINALIZE,
+    { mop_addref     }  _OP_ADDREF,
+    { mop_copy       }  _OP_COPY
+    );
 
 
 implementation

compiler/tokens.pas

@@ -57,7 +57,9 @@ type
     _OP_EXPLICIT,
     _OP_ENUMERATOR,
     _OP_INITIALIZE,
-    _OP_FINALIZE,    
+    _OP_FINALIZE,
+    _OP_ADDREF,
+    _OP_COPY,
     _OP_INC,
     _OP_DEC,
     { special chars }
@@ -131,6 +133,7 @@ type
     _VAR,
     _XOR,
     _CASE,
+    _COPY,
     _CVAR,
     _ELSE,
     _EXIT,
@@ -166,6 +169,7 @@ type
     _UNTIL,
     _WHILE,
     _WRITE,
+    _ADDREF,
     _DISPID,
     _DIVIDE,
     _DOWNTO,
@@ -323,7 +327,7 @@ const
   last_overloaded  = _OP_DEC;
   last_operator = _GENERICSPECIALTOKEN;
   first_managment_operator = _OP_INITIALIZE;
-  last_managment_operator = _OP_FINALIZE;
+  last_managment_operator = _OP_COPY;
 
   highest_precedence = oppower;
 
@@ -385,6 +389,8 @@ const
       (str:'enumerator'    ;special:true ;keyword:[m_none];op:NOTOKEN),
       (str:'initialize'    ;special:true ;keyword:[m_none];op:NOTOKEN),
       (str:'finalize'      ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'addref'        ;special:true ;keyword:[m_none];op:NOTOKEN),
+      (str:'copy'          ;special:true ;keyword:[m_none];op:NOTOKEN),
       (str:'inc'           ;special:true ;keyword:[m_none];op:NOTOKEN),
       (str:'dec'           ;special:true ;keyword:[m_none];op:NOTOKEN),
     { Special chars }
@@ -458,6 +464,7 @@ const
       (str:'VAR'           ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
       (str:'XOR'           ;special:false;keyword:alllanguagemodes;op:_OP_XOR),
       (str:'CASE'          ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
+      (str:'COPY'          ;special:false;keyword:[m_none];op:NOTOKEN),
       (str:'CVAR'          ;special:false;keyword:[m_none];op:NOTOKEN),
       (str:'ELSE'          ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
       (str:'EXIT'          ;special:false;keyword:[m_none];op:NOTOKEN),
@@ -493,6 +500,7 @@ const
       (str:'UNTIL'         ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
       (str:'WHILE'         ;special:false;keyword:alllanguagemodes;op:NOTOKEN),
       (str:'WRITE'         ;special:false;keyword:[m_none];op:NOTOKEN),
+      (str:'ADDREF'        ;special:false;keyword:[m_none];op:NOTOKEN),
       (str:'DISPID'        ;special:false;keyword:[m_none];op:NOTOKEN),
       (str:'DIVIDE'        ;special:false;keyword:[m_none];op:NOTOKEN), { delphi operator name }
       (str:'DOWNTO'        ;special:false;keyword:alllanguagemodes;op:NOTOKEN),