testtools/source/bridgetest/idl/bridgetest.idl

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <com/sun/star/lang/IllegalArgumentException.idl>
  21 #include <com/sun/star/lang/XComponent.idl>
  22 #include <com/sun/star/uno/XComponentContext.idl>
  23 #include <com/sun/star/uno/XInterface.idl>
  24
  25 module test { module testtools { module bridgetest {
  26
  27 enum TestEnum
  28 {
  29     TEST,
  30     ONE,
  31     TWO,
  32     CHECK,
  33     LOLA,
  34     PALOO,
  35     ZA
  36 };
  37
  38 enum TestBadEnum { M = 1 };
  39
  40 struct TestStruct
  41 {
  42     long member;
  43 };
  44
  45 /**
  46  * simple types
  47  */
  48 struct TestSimple
  49 {
  50     boolean                    Bool;
  51     char                       Char;
  52     byte                       Byte;
  53     short                      Short;
  54     unsigned short             UShort;
  55     long                       Long;
  56     unsigned long              ULong;
  57     hyper                      Hyper;
  58     unsigned hyper             UHyper;
  59     float                      Float;
  60     double                     Double;
  61     TestEnum                   Enum;
  62 };
  63 /**
  64  * equal to max size returned in registers on x86_64
  65  */
  66 struct SmallStruct
  67 {
  68     hyper                      a;
  69     hyper                      b;
  70 };
  71 /**
  72  * equal to max size returned in registers on ia64
  73  */
  74 struct MediumStruct
  75 {
  76     hyper                      a;
  77     hyper                      b;
  78     hyper                      c;
  79     hyper                      d;
  80 };
  81 /**
  82  * bigger than max size returned in registers on ia64
  83  */
  84 struct BigStruct
  85 {
  86     hyper                      a;
  87     hyper                      b;
  88     hyper                      c;
  89     hyper                      d;
  90     hyper                      e;
  91     hyper                      f;
  92     hyper                      g;
  93     hyper                      h;
  94 };
  95 /**
  96  * two floats, BSDs/MacOSX on intel handle returning small
  97  * structs differently than Linux
  98  */
  99 struct TwoFloats
 100 {
 101     float                      a;
 102     float                      b;
 103 };
 104 /**
 105  * all floats, ia64 handles them specially
 106  */
 107 struct FourFloats
 108 {
 109     float                      a;
 110     float                      b;
 111     float                      c;
 112     float                      d;
 113 };
 114 /**
 115  * Small struct with mixed float and integers.
 116  * Should return in registers on BSDs/MACOSx
 117  */
 118 struct MixedFloatAndInteger
 119 {
 120     float                      a;
 121     long                       b;
 122 };
 123 /**
 124  * Small struct with three bytes.  Should *not* return in registers on
 125  * BSDs/MACOSx
 126  */
 127 struct ThreeByteStruct
 128 {
 129     byte                       a;
 130     byte                       b;
 131     byte                       c;
 132 };
 133 /**
 134  * complex types adding string, interface, any
 135  */
 136 struct TestElement : TestSimple
 137 {
 138     string                     String;
 139     com::sun::star::uno::XInterface   Interface;
 140     any                        Any;
 141 };
 142 /**
 143  * adding even more complexity, sequence< TestElement >
 144  */
 145 struct TestDataElements : TestElement
 146 {
 147     sequence< TestElement > Sequence;
 148 };
 149
 150 /**
 151  * typedef used in interface
 152  */
 153 typedef TestDataElements TestData;
 154
 155 struct TestPolyStruct<T> { T member; };
 156 struct TestPolyStruct2<T,C> {
 157     T member1;
 158     C member2;
 159 };
 160
 161 interface XRecursiveCall : com::sun::star::uno::XInterface
 162 {
 163     /***
 164      * @param nToCall If nToCall is 0, the method returns immeadiatly.
 165      *                Otherwise, call the given interface with nToCall -1
 166      *
 167      ***/
 168     void callRecursivly( [in] XRecursiveCall xCall , [in] long nToCall );
 169 };
 170
 171 interface XMultiBase1 {
 172     [attribute] double att1; // initially 0.0
 173     long fn11([in] long arg); // return 11 * arg
 174     string fn12([in] string arg); // return "12" + arg
 175 };
 176
 177 interface XMultiBase2: XMultiBase1 {
 178     long fn21([in] long arg); // return 21 * arg
 179     string fn22([in] string arg); // return "22" + arg
 180 };
 181
 182 interface XMultiBase3 {
 183     [attribute] double att3; // initially 0.0
 184     long fn31([in] long arg); // return 31 * arg
 185     string fn32([in] string arg); // return "32" + arg
 186     long fn33(); // return 33
 187 };
 188
 189 interface XMultiBase3a: XMultiBase3 {};
 190
 191 interface XMultiBase4 {
 192     long fn41([in] long arg); // return 41 * arg
 193 };
 194
 195 interface XMultiBase5 {
 196     interface XMultiBase3;
 197     interface XMultiBase4;
 198     interface XMultiBase1;
 199 };
 200
 201 interface XMultiBase6 {
 202     interface XMultiBase2;
 203     interface XMultiBase3a;
 204     interface XMultiBase5;
 205     long fn61([in] long arg); // return 61 * arg
 206     string fn62([in] string arg); // return "62" + arg
 207 };
 208
 209 interface XMultiBase7 {
 210     long fn71([in] long arg); // return 71 * arg
 211     string fn72([in] string arg); // return "72" + arg
 212     long fn73(); // return 73
 213 };
 214
 215 interface XMulti {
 216     interface XMultiBase6;
 217     interface XMultiBase7;
 218 };
 219
 220 /**
 221  * Monster test interface to test bridge calls.
 222  * An implementation of this object has to store given values and return whenever there
 223  * is an out param or return value.
 224  */
 225 interface XBridgeTestBase : com::sun::star::uno::XInterface
 226 {
 227     /**
 228      * in parameter test, tests by calls reference also (complex types)
 229      */
 230     void setValues( [in] boolean bBool, [in] char cChar, [in] byte nByte,
 231                              [in] short nShort, [in] unsigned short nUShort,
 232                              [in] long nLong, [in] unsigned long nULong,
 233                              [in] hyper nHyper, [in] unsigned hyper nUHyper,
 234                              [in] float fFloat, [in] double fDouble,
 235                              [in] TestEnum eEnum, [in] string aString,
 236                              [in] com::sun::star::uno::XInterface xInterface, [in] any aAny,
 237                              [in] sequence< TestElement > aSequence,
 238                              [in] TestData aStruct );
 239     /**
 240      * inout parameter test
 241      *
 242      * @return aStruct. The out parameter contain the values, that were previously set
 243      *         by setValues or (if not called before) default constructed values.
 244      *
 245      */
 246     TestData setValues2( [inout] boolean bBool, [inout] char cChar, [inout] byte nByte,
 247                          [inout] short nShort, [inout] unsigned short nUShort,
 248                          [inout] long nLong, [inout] unsigned long nULong,
 249                          [inout] hyper nHyper, [inout] unsigned hyper nUHyper,
 250                          [inout] float fFloat, [inout] double fDouble,
 251                          [inout] TestEnum eEnum, [inout] string aString,
 252                          [inout] com::sun::star::uno::XInterface xInterface, [inout] any aAny,
 253                          [inout] sequence< TestElement > aSequence,
 254                          [inout] TestData aStruct );
 255
 256     /**
 257      * out parameter test
 258      */
 259     TestData getValues( [out] boolean bBool, [out] char cChar, [out] byte nByte,
 260                         [out] short nShort, [out] unsigned short nUShort,
 261                         [out] long nLong, [out] unsigned long nULong,
 262                         [out] hyper nHyper, [out] unsigned hyper nUHyper,
 263                         [out] float fFloat, [out] double fDouble,
 264                         [out] TestEnum eEnum, [out] string aString,
 265                         [out] com::sun::star::uno::XInterface xInterface, [out] any aAny,
 266                         [out] sequence< TestElement > aSequence,
 267                         [out] TestData aStruct );
 268
 269     /**
 270      * register return test 1
 271      */
 272     SmallStruct echoSmallStruct( [in] SmallStruct aStruct );
 273
 274     /**
 275      * register return test 2
 276      */
 277     MediumStruct echoMediumStruct( [in] MediumStruct aStruct );
 278
 279     /**
 280      * register return test 3
 281      */
 282     BigStruct echoBigStruct( [in] BigStruct aStruct );
 283
 284     /**
 285      * register return test 4
 286      */
 287     TwoFloats echoTwoFloats( [in] TwoFloats aStruct );
 288
 289     /**
 290      * register return test 5
 291      */
 292     FourFloats echoFourFloats( [in] FourFloats aStruct );
 293
 294     /**
 295      * register return test 6
 296      */
 297     MixedFloatAndInteger echoMixedFloatAndInteger( [in] MixedFloatAndInteger aStruct );
 298
 299     /**
 300      * register return test 7
 301      */
 302     ThreeByteStruct echoThreeByteStruct( [in] ThreeByteStruct aStruct );
 303
 304     /**
 305      * PPC Alignment test (#i107182#)
 306      */
 307     long testPPCAlignment( [in] hyper l1, [in] hyper l2, [in] long i1, [in] hyper l3, [in] long i2 );
 308
 309     /**
 310      * PPC64 Alignment test
 311      */
 312     long testPPC64Alignment( [in] double d1, [in] double d2, [in] double d3, [in] long i1 );
 313
 314
 315     /**
 316      * VFP ABI (armhf) doubles test
 317      */
 318     double testTenDoubles( [in] double d1, [in] double d2, [in] double d3, [in] double d4, [in] double d5, [in] double d6, [in] double d7, [in] double d8, [in] double d9, [in] double d10 );
 319
 320     [attribute] boolean                  Bool;
 321     [attribute] byte                     Byte;
 322     [attribute] char                     Char;
 323     [attribute] short                    Short;
 324     [attribute] unsigned short           UShort;
 325     [attribute] long                     Long;
 326     [attribute] unsigned long            ULong;
 327     [attribute] hyper                    Hyper;
 328     [attribute] unsigned hyper           UHyper;
 329     [attribute] float                    Float;
 330     [attribute] double                   Double;
 331     [attribute] TestEnum                 Enum;
 332     [attribute] string                   String;
 333     [attribute] com::sun::star::uno::XInterface Interface;
 334     [attribute] any                      Any;
 335     [attribute] sequence< TestElement >  Sequence;
 336     [attribute] TestData                 Struct;
 337
 338     [attribute] long RaiseAttr1 {
 339         set raises (com::sun::star::lang::IllegalArgumentException);
 340     };
 341     [attribute, readonly] long RaiseAttr2 {
 342         get raises (com::sun::star::lang::IllegalArgumentException);
 343     };
 344
 345     TestPolyStruct<boolean> transportPolyBoolean(
 346         [in] TestPolyStruct<boolean> arg);
 347     void transportPolyHyper([inout] TestPolyStruct<hyper> arg);
 348     void transportPolySequence(
 349         [in] TestPolyStruct<sequence<any> > arg1,
 350         [out] TestPolyStruct<sequence<any> > arg2);
 351
 352     TestPolyStruct<long> getNullPolyLong();
 353     TestPolyStruct<string> getNullPolyString();
 354     TestPolyStruct<type> getNullPolyType();
 355     TestPolyStruct<any> getNullPolyAny();
 356     TestPolyStruct<sequence<boolean> > getNullPolySequence();
 357     TestPolyStruct<TestEnum> getNullPolyEnum();
 358     TestPolyStruct<TestBadEnum> getNullPolyBadEnum();
 359     TestPolyStruct<TestStruct> getNullPolyStruct();
 360     TestPolyStruct<XBridgeTestBase> getNullPolyInterface();
 361
 362     /***
 363      * This method returns the parameter value.
 364      * Method to extensivly test anys.
 365      ****/
 366     any transportAny( [in] any value );
 367
 368     /***
 369      * methods to check sequence of calls. Call call() and callOneway
 370      * in an arbitrary sequence. Increase the callId for every call.
 371      * The testobject sets an error flag.
 372
 373         @see testSequencePassed
 374      ***/
 375     void call( [in] long nCallId, [in] long nWaitMUSEC );
 376     void callOneway( [in] long nCallId, [in] long nWaitMUSEC );
 377     boolean sequenceOfCallTestPassed();
 378
 379     /****
 380      * methods to check, if threads thread identity is holded.
 381      *
 382      ***/
 383     void startRecursiveCall( [in] XRecursiveCall xCall , [in] long nToCall );
 384
 385     XMulti getMulti();
 386     string testMulti([in] XMulti multi);
 387 };
 388
 389
 390 /**
 391  * Inherting from monster; adds raiseException(), attribute raising RuntimeException.
 392  */
 393 interface XBridgeTest : XBridgeTestBase
 394 {
 395     /**
 396      * the exception struct returned has to be filled with given arguments.
 397      * return value is for dummy.
 398      */
 399     TestData raiseException( [in] short ArgumentPosition,
 400                              [in] string Message,
 401                              [in] com::sun::star::uno::XInterface Context )
 402         raises( com::sun::star::lang::IllegalArgumentException );
 403
 404
 405     /**
 406      * Throws runtime exception.
 407      * check remote bridges handle exceptions during oneway calls properly.
 408      * Note that on client side the exception may fly or not. When it flies, it should
 409      * have the proper message and context.
 410      ***/
 411     void raiseRuntimeExceptionOneway(  [in] string Message,
 412                                        [in] com::sun::star::uno::XInterface Context );
 413
 414     /**
 415      * raises runtime exception;
 416      * the exception struct returned has to be filled with formerly set test data.
 417      */
 418     [attribute] long                     RuntimeException;
 419 };
 420
 421
 422 exception BadConstructorArguments: com::sun::star::uno::Exception {};
 423
 424 service Constructors: com::sun::star::uno::XInterface {
 425     create1(
 426         [in] boolean arg0,
 427         [in] byte arg1,
 428         [in] short arg2,
 429         [in] unsigned short arg3,
 430         [in] long arg4,
 431         [in] unsigned long arg5,
 432         [in] hyper arg6,
 433         [in] unsigned hyper arg7,
 434         [in] float arg8,
 435         [in] double arg9,
 436         [in] char arg10,
 437         [in] string arg11,
 438         [in] type arg12,
 439         [in] any arg13,
 440         [in] sequence< boolean > arg14,
 441         [in] sequence< byte > arg15,
 442         [in] sequence< short > arg16,
 443         [in] sequence< unsigned short > arg17,
 444         [in] sequence< long > arg18,
 445         [in] sequence< unsigned long > arg19,
 446         [in] sequence< hyper > arg20,
 447         [in] sequence< unsigned hyper > arg21,
 448         [in] sequence< float > arg22,
 449         [in] sequence< double > arg23,
 450         [in] sequence< char > arg24,
 451         [in] sequence< string > arg25,
 452         [in] sequence< type > arg26,
 453         [in] sequence< any > arg27,
 454         [in] sequence< sequence< boolean > > arg28,
 455         [in] sequence< sequence< any > > arg29,
 456         [in] sequence< TestEnum > arg30,
 457         [in] sequence< TestStruct > arg31,
 458         [in] sequence< TestPolyStruct< boolean > > arg32,
 459         [in] sequence< TestPolyStruct< any > > arg33,
 460         [in] sequence< com::sun::star::uno::XInterface > arg34,
 461         [in] TestEnum arg35,
 462         [in] TestStruct arg36,
 463         [in] TestPolyStruct< boolean > arg37,
 464         [in] TestPolyStruct< any > arg38,
 465         [in] com::sun::star::uno::XInterface arg39)
 466         raises (BadConstructorArguments);
 467
 468     create2([in] any... args) raises (BadConstructorArguments);
 469
 470 };
 471
 472 service Constructors2: XMultiBase1 {
 473
 474     create1(
 475         [in] TestPolyStruct<type> arg1,
 476         [in] TestPolyStruct<any> arg2,
 477         [in] TestPolyStruct<boolean> arg3,
 478         [in] TestPolyStruct<byte> arg4,
 479         [in] TestPolyStruct<short> arg5,
 480         [in] TestPolyStruct<long> arg6,
 481         [in] TestPolyStruct<hyper> arg7,
 482         [in] TestPolyStruct<char> arg8,
 483         [in] TestPolyStruct<string> arg9,
 484         [in] TestPolyStruct<float> arg10,
 485         [in] TestPolyStruct<double> arg11,
 486         [in] TestPolyStruct<com::sun::star::uno::XInterface> arg12,
 487         [in] TestPolyStruct<com::sun::star::lang::XComponent> arg13,
 488         [in] TestPolyStruct<TestEnum> arg14,
 489         [in] TestPolyStruct<TestPolyStruct2<char,any> > arg15,
 490         [in] TestPolyStruct<TestPolyStruct2<TestPolyStruct2<char,any>,string> > arg16,
 491         [in] TestPolyStruct2<string, TestPolyStruct2<char, TestPolyStruct<any> > > arg17,
 492         [in] TestPolyStruct2<TestPolyStruct2<char,any>, TestPolyStruct<char> > arg18,
 493         [in] TestPolyStruct<sequence<type> > arg19,
 494         [in] TestPolyStruct<sequence<any> > arg20,
 495         [in] TestPolyStruct<sequence<boolean> > arg21,
 496         [in] TestPolyStruct<sequence<byte> > arg22,
 497         [in] TestPolyStruct<sequence<short> > arg23,
 498         [in] TestPolyStruct<sequence<long> > arg24,
 499         [in] TestPolyStruct<sequence<hyper> > arg25,
 500         [in] TestPolyStruct<sequence<char> > arg26,
 501         [in] TestPolyStruct<sequence<string> > arg27,
 502         [in] TestPolyStruct<sequence<float> > arg28,
 503         [in] TestPolyStruct<sequence<double> > arg29,
 504         [in] TestPolyStruct<sequence<com::sun::star::uno::XInterface> > arg30,
 505         [in] TestPolyStruct<sequence<com::sun::star::lang::XComponent> > arg31,
 506         [in] TestPolyStruct<sequence<TestEnum> > arg32,
 507         [in] TestPolyStruct<sequence<TestPolyStruct2<char, sequence<any> > > > arg33,
 508         [in] TestPolyStruct<sequence<TestPolyStruct2<TestPolyStruct<char>, sequence<any> > > > arg34,
 509         [in] TestPolyStruct<sequence<sequence<long> > > arg35,
 510         [in] sequence<TestPolyStruct<long > > arg36,
 511         [in] sequence<TestPolyStruct<TestPolyStruct2<char,any> > > arg37,
 512         [in] sequence<TestPolyStruct<TestPolyStruct2<TestPolyStruct2<char,any>,string> > > arg38,
 513         [in] sequence<TestPolyStruct2<string, TestPolyStruct2<char, TestPolyStruct<any> > > > arg39,
 514         [in] sequence<TestPolyStruct2<TestPolyStruct2<char,any>, TestPolyStruct<char> > > arg40,
 515         [in] sequence<sequence<TestPolyStruct< char > > > arg41,
 516         [in] sequence<sequence<TestPolyStruct<TestPolyStruct2<char,any> > > >arg42,
 517         [in] sequence<sequence<TestPolyStruct<TestPolyStruct2<TestPolyStruct2<char,any>,string> > > > arg43,
 518         [in] sequence<sequence<TestPolyStruct2<string, TestPolyStruct2<char, TestPolyStruct<any> > > > > arg44,
 519         [in] sequence<sequence<TestPolyStruct2<TestPolyStruct2<char,any>, TestPolyStruct<char> > > > arg45
 520         );
 521 };
 522
 523 interface XCurrentContextChecker {
 524     boolean perform(
 525         [in] XCurrentContextChecker other, [in] long setSteps,
 526         [in] long checkSteps);
 527 };
 528
 529 /** Extended tests with sequences.
 530  */
 531 interface XBridgeTest2 : XBridgeTest
 532 {
 533     sequence< boolean > setSequenceBool( [in] sequence< boolean > aSeq);
 534     sequence< char > setSequenceChar( [in] sequence< char > aSeq);
 535     sequence< byte> setSequenceByte( [in] sequence< byte > aSeq);
 536     sequence< short> setSequenceShort( [in] sequence< short > aSeq);
 537     sequence< unsigned short > setSequenceUShort( [in] sequence< unsigned short > aSeq);
 538     sequence< long > setSequenceLong( [in] sequence< long > aSeq);
 539     sequence< unsigned long > setSequenceULong( [in] sequence< unsigned long > aSeq);
 540     sequence< hyper > setSequenceHyper( [in] sequence< hyper > aSeq);
 541     sequence< unsigned hyper > setSequenceUHyper( [in] sequence< unsigned hyper > aSeq);
 542     sequence< float > setSequenceFloat( [in] sequence< float > aSeq);
 543     sequence< double > setSequenceDouble( [in] sequence< double > aSeq);
 544     sequence< TestEnum > setSequenceEnum( [in] sequence< TestEnum > aSeq);
 545     sequence< string > setSequenceString( [in] sequence< string > aString);
 546     sequence< com::sun::star::uno::XInterface > setSequenceXInterface(
 547         [in] sequence< com::sun::star::uno::XInterface > aSeq);
 548     sequence< any > setSequenceAny( [in] sequence< any > aSeq);
 549     sequence< TestElement > setSequenceStruct( [in] sequence< TestElement > aSeq);
 550
 551     sequence< sequence< long > > setDim2( [in] sequence< sequence< long > > aSeq);
 552     sequence< sequence < sequence < long > > > setDim3(
 553         [in] sequence< sequence < sequence < long > > > aSeq);
 554
 555     void setSequencesInOut( [inout] sequence< boolean > aSeqBoolean,
 556                        [inout] sequence< char > aSeqChar,
 557                        [inout] sequence< byte > aSeqByte,
 558                        [inout] sequence< short > aSeqShort,
 559                        [inout] sequence< unsigned short> aSeqUShort,
 560                        [inout] sequence< long > aSeqLong,
 561                        [inout] sequence< unsigned long > aSeqULong,
 562                        [inout] sequence< hyper > aSeqHyper,
 563                        [inout] sequence< unsigned hyper > aSeqUHyper,
 564                        [inout] sequence< float > aSeqFloat,
 565                        [inout] sequence< double > aSeqDouble,
 566                        [inout] sequence< TestEnum > aSeqEnum,
 567                        [inout] sequence< string > aSeqString,
 568                        [inout] sequence< com::sun::star::uno::XInterface > aSeqXInterface,
 569                        [inout] sequence< any > aSeqAny,
 570                        [inout] sequence< sequence< long > > aSeqDim2,
 571                        [inout] sequence< sequence < sequence < long > > > aSeqDim3);
 572
 573     void setSequencesOut( [out] sequence< boolean > aSeqBoolean,
 574                        [out] sequence< char > aSeqChar,
 575                        [out] sequence< byte > aSeqByte,
 576                        [out] sequence< short > aSeqShort,
 577                        [out] sequence< unsigned short> aSeqUShort,
 578                        [out] sequence< long > aSeqLong,
 579                        [out] sequence< unsigned long > aSeqULong,
 580                        [out] sequence< hyper > aSeqHyper,
 581                        [out] sequence< unsigned hyper > aSeqUHyper,
 582                        [out] sequence< float > aSeqFloat,
 583                        [out] sequence< double > aSeqDouble,
 584                        [out] sequence< TestEnum > aSeqEnum,
 585                        [out] sequence< string > aSeqString,
 586                        [out] sequence< com::sun::star::uno::XInterface > aSeqXInterface,
 587                        [out] sequence< any > aSeqAny,
 588                        [out] sequence< sequence< long > > aSeqDim2,
 589                        [out] sequence< sequence < sequence < long > > > aSeqDim3);
 590
 591     void testConstructorsService(
 592         [in] com::sun::star::uno::XComponentContext context)
 593         raises (BadConstructorArguments);
 594
 595     XCurrentContextChecker getCurrentContextChecker();
 596 };
 597
 598 }; }; };
 599
 600 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */