Patch title: Release 93 bulk changes
Abstract:
File: /language/type/misc/position.c
Key:
    Removed line
    Added line
// Copyright  Hubert Tonneau  hubert.tonneau@pliant.cx
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License version 2
// as published by the Free Software Foundation.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

/*
abstract
  text "'LisingPosition' and 'ListingPositions' data types"
*/

FUNCTION Void ListingPosition_build(struct ListingPosition *p) {
  p->module=null;
  p->line=0,p->column=0; }

FUNCTION Void ListingPosition_destroy(struct ListingPosition *p) {
  entry_unlockz(p->module); }

FUNCTION Void ListingPosition_copy(struct ListingPosition *src,struct ListingPosition *dest) {
  Arrow_set((Arrow *)&dest->module,src->module);
  dest->line=src->line,dest->column=src->column; }

FUNCTION Void ListingPosition_set(struct Module *m,Int line,Int column,struct ListingPosition *p) {
  Arrow_set((Arrow *)&p->module,m->name);
  p->line=line,p->column=column; }

FUNCTION Void ListingPosition_get(struct ListingPosition *p,struct Str *s) {
  struct Str temp1,temp2; Char buffer1[16],buffer2[16];
  if(p->module!=null) {
    Str_concat(s,
      S,p->module,
      Z," ",
      S,Str_map_area(&temp1,buffer1,Int_str2(p->line,10,buffer1)),
      Z," ",
      S,Str_map_area(&temp2,buffer2,Int_str2(p->column,10,buffer2)),
      END);
  other
    string_Str("",s); } }

FUNCTION struct Str *ListingPosition_module_name(struct ListingPosition *p) {
  return p->module; }

FUNCTION Int ListingPosition_line(struct ListingPosition *p) {
  return p->line;}

FUNCTION Int ListingPosition_column(struct ListingPosition *p) {
  return p->column;}

FUNCTION Int ListingPositions_size(struct ListingPositions *p) {
  if(p->ptr&1)
    return p->nb;
  else
    return 1; }

FUNCTION struct ListingPosition *ListingPositions_map(struct ListingPositions *p,Int i) {
  if(p->ptr&1) {
    check(i>=0 && i<p->nb);
    return ((struct ListingPosition *)address_from_integer(p->ptr-1))+i;
  other
    check(i==0);
    return (struct ListingPosition *)p; } }

FUNCTION Void ListingPositions_build(struct ListingPositions *p) {
  p->ptr=1;
  p->nb=0; }

FUNCTION Void ListingPositions_destroy(struct ListingPositions *p) {
  Int i;
  for(i=0; i<ListingPositions_size(p); i++)
    ListingPosition_destroy(ListingPositions_map(p,i));
  if(p->ptr&1)
    memory_free(address_from_integer(p->ptr-1)); }

FUNCTION Void ListingPositions_resize(struct ListingPositions *p,Int n) {
  Int i;
  ListingPositions_destroy(p);
  if(n==0) {
    ListingPositions_build(p);
  orif(n==1)
    ListingPosition_build((struct ListingPosition *)p);
  other
    p->ptr=integer_from_address(memory_allocate(n*sizeof(struct ListingPosition),&p))+1;
    p->nb=n;
    for(i=0; i<n; i++)
      ListingPosition_build(ListingPositions_map(p,i)); } }


FUNCTION Void ListingPositions_copy(struct ListingPositions *src,struct ListingPositions *dest) {
  Int i;
  ListingPositions_resize(dest,ListingPositions_size(src));
  for(i=0; i<ListingPositions_size(dest); i++)
    ListingPosition_copy(ListingPositions_map(src,i),ListingPositions_map(dest,i)); }

FUNCTION Void ListingPositions_concat(struct ListingPositions *p1,struct ListingPositions *p2,struct ListingPositions *sum) {
  Int i,j;
  ListingPositions_resize(sum,ListingPositions_size(p1)+ListingPositions_size(p2));
  for(i=0; i<ListingPositions_size(p1); i++)
    ListingPosition_copy(ListingPositions_map(p1,i),ListingPositions_map(sum,i));
  for(j=0; j<ListingPositions_size(p2); j++)
    ListingPosition_copy(ListingPositions_map(p2,j),ListingPositions_map(sum,i+j)); } 

FUNCTION Void ListingPositions_get(struct ListingPositions *p,struct Str *s) {
  Int i; struct Str t;
  Str_build(&t);
  string_Str("",s);
  for(i=0; i<ListingPositions_size(p); i++) {
    ListingPosition_get(ListingPositions_map(p,i),&t);
    if(i!=0)
      Str_addz(" ",s);
    Str_add(&t,s); }
  Str_destroy(&t); }


FUNCTION Void cast_ListingPositions(struct ListingPosition *src,struct ListingPositions *dest) {
  ListingPositions_resize(dest,1);
  ListingPosition_copy(src,ListingPositions_map(dest,0)); }