structureDeclarationTest.aec

/*
 * This is a nonsense program to test whether structures are compiled
 * correctly.
 */

Structure Point Consists Of {
  Integer16 dimensions : = 3;
  Decimal32 x, y, z;
}
EndStructure;
Integer32 a : = 0;
InstantiateStructure Point points[12];
Integer32 b : = 1;
Structure String Consists Of {
  Integer32 length;
  Character string[16];
}
EndStructure;
InstantiateStructure String helloWorld;
Integer32 c : = 2;

Function foo() Which Returns Integer16 Does {
  // Should return 3.
  Return points[c].dimensions;
}
EndFunction;

Function strlen(CharacterPointer string) Which Returns Integer32 Does {
  Return(ValueAt(string) = 0) ? (0) : (1 + strlen(string + 1));
}
EndFunction;

Function strcpy(CharacterPointer dest,
                CharacterPointer src) Which Returns Nothing Does {
  While ValueAt(src) Loop {
    ValueAt(dest) : = ValueAt(src);
    dest += 1;
    src += 1;
  }
  EndWhile;
  ValueAt(dest) : = 0;
}
EndFunction;

Function bar() Which Returns Integer32 Does {
  // Should return 12.
  CharacterPointer hw : = "Hello world!";
  strcpy(AddressOf(helloWorld.string[0]), hw);
  helloWorld.length : = strlen(hw);
  Return helloWorld.length;
}
EndFunction;

Function spam() Which Returns Integer32 Does {
  // Should return 3.
  InstantiateStructure Point localPoints[3];
  Return localPoints[b].dimensions;
}
EndFunction;

Function eggs() Which Returns Integer32 Does {
  // Should return 3.
  InstantiateStructure Point localPoint;
  Return localPoint.dimensions;
}
EndFunction;

Structure innerStructure Consists Of { Integer32 innerNumber : = 1; }
EndStructure;

Structure outerStructure Consists Of {
  Integer32 outerNumber : = 2;
  innerStructure structureWithInnerNumber;
  innerStructure arrayOfInnerStructures[2];
  innerStructurePointer structurePointer;
}
EndStructure;

InstantiateStructure outerStructure globalNestedStructure;

Function onion() Which Returns Integer32 Does {
  // Should return 1.
  InstantiateStructure outerStructure nestedStructure,
      copyOfTheNestedStructure : = nestedStructure;
  Return(nestedStructure.structureWithInnerNumber.innerNumber =
             globalNestedStructure.structureWithInnerNumber
                 .innerNumber and nestedStructure.outerNumber =
                 2 and globalNestedStructure.outerNumber =
                     2 and copyOfTheNestedStructure.structureWithInnerNumber
                         .innerNumber = 1 and copyOfTheNestedStructure
                                                  .arrayOfInnerStructures[1]
                                                  .innerNumber = 1);
}
EndFunction;

Function copyString(StringPointer destination,
                    StringPointer source) Which Returns Nothing Does {
  ValueAt(destination).length : = ValueAt(source).length;
  Integer32 i : = 0;
  While i < ValueAt(source).length Loop {
    ValueAt(destination).string[i] : = ValueAt(source).string[i];
    i += 1;
  }
  EndWhile;
}
EndFunction;

Function pomegranate() Which Returns Integer32 Does {
  // Should return 12.
  CharacterPointer hw : = "Hello world!";
  strcpy(AddressOf(helloWorld.string[0]), hw);
  helloWorld.length : = strlen(hw);
  InstantiateStructure String localString;
  copyString(AddressOf(localString), AddressOf(helloWorld));
  InstantiateStructure String copyOfLocalString : = localString;
  Return copyOfLocalString.length;
}
EndFunction;

Structure ListNode Consists Of {
  ListNodePointer next;
  Integer32 value;
}
EndStructure;

Function spaghetti() Which Returns Integer32 Does {
  // https://stackoverflow.com/questions/63951270/using-default-copy-constructor-corrupts-a-tree-in-c
  // By common sense, this should return 2. By C++ semantics, this should
  // return 3.
  InstantiateStructure ListNode list[3];
  list[0].value : = 1;
  list[1].value : = 2;
  list[2].value : = 3;
  list[0].next : = AddressOf(list[1]);
  list[1].next : = AddressOf(list[2]);
  list[0] : = ValueAt(list[0].next);
  CharacterPointer pointer : = AddressOf(list[0]);
  Return ValueAt(ListNodePointer(pointer)).value;
}
EndFunction;

Function elephant() Which Returns Integer32 Does {
  // Should return 1.
  Return(SizeOf(outerStructure) = SizeOf(Integer32) +
                                  3 * SizeOf(innerStructure) +
                                  SizeOf(innerStructurePointer));
}
EndFunction;

ListNodePointer globalStructurePointer, globalStructurePointerArray[2];

Function arrow() Which Returns Integer32 Does {
  // Should return 2.
  InstantiateStructure ListNode node[2];
  node[0].value : = 1;
  node[0].next : = AddressOf(node[1]);
  node[1].value : = 2;
  ListNodePointer ptr : = AddressOf(node[0]), localPointerArray[2];
  ptr += 1;
  Return(ptr->value);
}
EndFunction