; Semantic 1995 - who side do YOU are?
; VERIFICAR COM URGENCIA:"registo de percentagem" e "consulta auto de medicao"!
; nao a nivel de erros, mas se semanticamente e o desejado!
; DUVIDA: como o SISTEMA e uma variavel de estado, poder-se-a evitar de a estar
; sempre a passa-la como parametro e, entao,usa-la indiscriminadamente ?
; RESPOSTA: Sim, mas depois no relatorio por como "evento interrogativo" e nao
; como funcao, que e o que actualmente esta!
; Detectei grande ERRO - ha algo de estranho na descricao dos produtos,
; inclusive parece-me que esta nao existe !!!
; falta implementar coisas tipo (data + 1), def. estado...
; ... em '#fact' pusemos 'cod'; ha espiga? em ultima instancia #fact=cod=INT
; ... outra coisa a ter cuidado e com as insercoes destrutivas, como se pode
; ver na insercao da tabela de precos !
; os testes de existe podem ser feitos da seguinte forma, compacta e bonita
; RETURN c in dom(C)  e nao RETURN if c in dom(C)...
; Definicao do SISTEMA

( deftype sistema TUP
  ( p_empreitadas empreitada )
  ( p_central_c central_c )
  ( p_central_m_e central_m_e )
  ( p_estaleiro estaleiro )
  ( p_contabilidade contabilidade )
)
;---------------------
; Definicao de EMPREITADAS - in sistema

( deftype empreitada TUP
  ( p_obras obras )
  ( p_orcamentos orcamentos )
  ( p_fichas fichas )
  ( p_tab_produtos tab_produtos )
)
;---------------------
; Definicao de obras - in empreitada

( deftype obras FF cod obra_info )
;---------------------

( deftype obra_info TUP
  ( p_cod_orcamento cod )
  ( p_lista_consumo lista_consumo )
  ( p_data_obra data )
)
;---------------------
; Definicao de orcamentos - in empreitada

( deftype orcamentos FF cod orca_info )
;---------------------

( deftype orca_info TUP
  ( p_cod_cliente cod )
  ( p_data_orca data )
  ( p_lucro lucro )
  ( p_lista_capitulos lista_capitulos )
)
;---------------------
; Definicao de lista de capitulos - in empreitada

( deftype lista_capitulos LIST capitulo )
;---------------------

( deftype capitulo TUP
  ( p_desc_capitulo descricao )
  ( p_lista_artigos lista_artigos )
  ( p_total preco )
)
;---------------------
; Definicao de lista de artigos - in empreitada

( deftype lista_artigos LIST artigo )
;---------------------

( deftype artigo TUP
  ( p_cod_artigo cod )
  ( p_qtd_artigo quantidade )
  ( p_realizacao realizacao )
  ( p_pu preco )
)
;---------------------

( deftype realizacao LIST percentagem )
;---------------------

( deftype percentagem INT )
;---------------------
; Definicao de fichas - in empreitada

( deftype fichas FF cod info_ficha )
;---------------------

( deftype info_ficha TUP
  ( p_descricao descricao )
  ( p_tabela SET tabela )
)
;---------------------
; Definicao de consumo de uma obra - in empreitada

( deftype tabela TUP
  ( p_cod_produto cod )
  ( p_quantidade quantidade )
)
;---------------------

( deftype consumo TUP
  ( p_data data )
  ( p_tabela_lista LIST tabela )
)
;---------------------

( deftype lista_consumo LIST consumo )
;---------------------
; definicao de tabela de produtos - in empreitada

( deftype tab_produtos SET produtos )
;---------------------

( deftype produtos TUP
  ( p_cod_prod cod )
  ( p_nome_prod descricao )
)
;---------------------
; Definicao de CENTRAL DE COMPRAS

( deftype central_c TUP
  ( p_lista_pedidos lista_pedidos )
  ( p_lista_encomendas lista_encomendas )
  ( p_tab_precos tab_precos )
)
;---------------------
; Definicao da lista de pedidos - in Central_c

( deftype lista_pedidos LIST pedidos )
;---------------------

( deftype pedidos TUP
  ( p_cod_obra cod )
  ( p_lista_produtos lista_produtos )
  ( p_data data )
)
;---------------------
; Definicao de lista de produtos - in Central_c

( deftype lista_produtos LIST produto )
;---------------------

( deftype produto TUP
  ( p_cod_produto cod )
  ( p_descricao descricao )
  ( p_quantidade quantidade )
  ( p_uni uni )
)
;---------------------
; Definicao da lista de encomendas - in Central_c

( deftype lista_encomendas LIST encomenda )
;---------------------

( deftype encomenda TUP
  ( p_cod_forn cod )
  ( p_data data )
  ( p_lista_prod_enc lista_prod_end )
)
;---------------------
; Definicao de produtos encomendados - in Central_c

( deftype lista_prod_enc LIST prod_enc )
;---------------------

( deftype prod_enc TUP
  ( p_cod cod )
  ( p_quantidade quantidade )
)
;---------------------
; Definicao de tabela de precos - in Central_c

( deftype tab_precos FF chave preco )
;---------------------

( deftype chave TUP
  ( p_cod_produto cod )
  ( p_cod_forn cod )
  ( p_data data )
)
;---------------------
; Definicao de CENTRAL DE MAO-DE-OBRA E EQUIPAMENTO - in sistema

( deftype central_m_e TUP
  ( p_lista_pedme lista_pedme )
  ( p_rec_humanos rec_humanos )
  ( p_rec_equip rec_equip )
)
;---------------------
; Definicao de lista pedido de mao-de-obra e equipamento - in Central_m_e

( deftype lista_pedme LIST pedme )
;---------------------

( deftype pedme TUP
  ( p_cod_obra cod )
  ( p_produtos SET cod )
  ( p_data_entrada data )
  ( p_data_saida data )
  ( p_data_ent_des data )
  ( p_data_sai_prev data )
)
;---------------------
; Definicao de recursos humanos - in Central_m_e

( deftype rec_humanos SET humano )
;---------------------

( deftype humano TUP
  ( p_cod_pessoal cod )
  ( p_nome nome )
  ( p_descricao descricao )
  ( p_cod_obra cod )
  ( p_salario salario )
)
;---------------------
; Definicao de recursos a nivel do equipamento - in Central_m_e

( deftype rec_equip SET equip )
;---------------------

( deftype equip TUP
  ( p_cod_equip cod )
  ( p_descricao descricao )
  ( p_cod_obra cod )
)
;---------------------
; Definicao do ESTALEIRO - in sistema

( deftype estaleiro LIST pedido_estaleiro )
;---------------------

( deftype pedido_estaleiro TUP
  ( p_cod_obra obra )
  ( p_pe conj_pedido_efectivo )
  ( p_data data )
)
;---------------------

( deftype conj_pedido_efectivo SET pedido_efectivo )
;---------------------

( deftype pedido_efectivo TUP
  ( p_cod_art cod )
  ( p_quantidade quantidade )
  ( p_estado estado )
  ( p_data data )
)
;---------------------
;    estado  -1,0,1 i.e por fazer, a fazer e feito
; Definicao de CONTABILIDADE

( deftype contabilidade TUP
  ( p_clientes clientes )
  ( p_fornecedores fornecedores )
  ( p_facturas facturas )
  ( p_recibos recibos )
)
;---------------------
; Definicao de clientes - in Contabilidade

( deftype clientes FF cod inf_cliente )
;---------------------

( deftype inf_cliente TUP
  ( p_nome nome )
  ( p_morada morada )
  ( p_n_contri n_contri )
)
;---------------------
; Definicao de fornecedores - in Contabilidade

( deftype fornecedores FF cod inf_forn )
;---------------------

( deftype inf_forn TUP
  ( p_nome nome )
  ( p_morada morada )
  ( p_n_contri n_contri )
)
;---------------------
; Definicao de facturas - in Contabilidade

( deftype facturas TUP
  ( p_n_factura n_factura )
  ( p_v_factura v_factura )
)
;---------------------

( deftype n_factura FF cod fact_info1 )
;---------------------

( deftype fact_info1 TUP
  ( p_cod_obra cod )
  ( p_n_automedicao cod )
  ( p_data data )
)
;---------------------

( deftype v_factura FF cod fact_info2 )
;---------------------

( deftype fact_info2 TUP
  ( p_cod_forn cod )
  ( p_total preco )
  ( p_data data )
)
;---------------------
; Definicao de recibos - in Contabilidade

( deftype recibos TUP
  ( p_n_recibo n_recibo )
  ( p_v_recibo v_recibo )
)
;---------------------

( deftype n_recibo FF cod rec_info1 )
;---------------------

( deftype rec_info1 TUP
  ( p_n_fact cod )
  ( p_quantia preco )
  ( p_data data )
)
;---------------------

( deftype v_recibo FF cod rec_info2 )
;---------------------

( deftype rec_info2 TUP
  ( p_v_fact cod )
  ( p_quantia preco )
  ( p_data data )
)
;---------------------

( deftype cod INT )
;---------------------

( deftype nome STR )
;---------------------

( deftype morada STR )
;---------------------

( deftype descricao STR )
;---------------------

( deftype salario INT )
;---------------------

( deftype quantidade INT )
;---------------------

( deftype data INT )
;---------------------

( deftype n_contri INT )
;---------------------

( deftype uni STR )
;---------------------

( deftype preco INT )
;---------------------

( deftype lucro INT )
;---------------------
; ---------------------------------------------------------------------------
; ******************************* SISTEMA ***********************************
; ---------------------------------------------------------------------------
; Parte do sistema que trata das empreitadas

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_sistema )
        ( quote
          (
            ( )
            ( sistema )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_sistema lambda
  ( )
  ( def SISTEMA
    ( sistema
      ( inic_empreitada )
      ( inic_central_c )
      ( inic_central_m_e )
      ( inic_estaleiro )
      ( inic_contabilidade )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic )
        ( quote
          (
            ( ) NIL
          )
        )
      )
    )
  )
)
;---------------------

( def inic lambda
  ( )
  ( def SISTEMA
    ( stload "estado" )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote saida )
        ( quote
          (
            ( ) NIL
          )
        )
      )
    )
  )
)
;---------------------

( def saida lambda
  ( )
  ( stsave "estado" SISTEMA )
)
;---------------------
;------------------- Parte do sistema que trata da orcamentacao -------------
; isto de o capitulo ter total ainda vai dar merda!
; ...ou e' de mim ou terei de calcular a pata (um evento chamado pela interface!)
; funcao para dar todos os capitulos de um determinado orcamento

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote da_capitulo_orca_sis )
        ( quote
          (
            (
              ( cod )
            )
            ( SET descricao )
          )
        )
      )
    )
  )
)
;---------------------

( def da_capitulo_orca_sis lambda
  ( corca )
  ( let
    (
      ( s SISTEMA )
      ( emp
        ( p_empreitadas s )
      )
      ( o
        ( p_orcamentos emp )
      )
      ( lista
        ( p_lista_capitulos
          ( ap o corca )
        )
      )
    )
    ( da_capitulo_orca_aux lista )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote da_capitulo_orca_aux )
        ( quote
          (
            (
              ( lista_capitulos )
            )
            ( SET descricao )
          )
        )
      )
    )
  )
)
;---------------------

( def da_capitulo_orca_aux lambda
  ( l )
  ( if
    ( equal l
      ( makeseq )
    )
    ( makeset )
    ( let
      (
        ( h
          ( head l )
        )
        ( t
          ( tail l )
        )
        ( desc
          ( p_desc_capitulo h )
        )
      )
      ( union
        ( makeset desc )
        ( da_capitulo_orca_aux t )
      )
    )
  )
)
;---------------------
; funcao que da todos os codigos dos orcamentos de um determinado cliente! Tera de se verificar
; na interface se o cliente e o orcamento existe. (Usada nos orcamentos)

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote da_orca_de_cliente_sis )
        ( quote
          (
            (
              ( cod )
            )
            ( SET cod )
          )
        )
      )
    )
  )
)
;---------------------

( def da_orca_de_cliente_sis lambda
  ( cod_cli )
  ( let
    (
      ( s SISTEMA )
      ( emp
        ( p_empreitadas s )
      )
      ( o
        ( p_orcamentos emp )
      )
      ( cod_orcamentos
        ( dom o )
      )
    )
    ( da_orca_de_cliente_aux cod_cli cod_orcamentos o )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote da_orca_de_cliente_aux )
        ( quote
          (
            (
              ( cod )
              ( SET cod )
              ( orcamentos )
            )
            ( cod_set )
          )
        )
      )
    )
  )
)
;---------------------

( def da_orca_de_cliente_aux lambda
  ( cc co o )
  ( if
    ( equal co
      ( makeset )
    )
    ( makeset )
    ( let
      (
        ( c
          ( choice co )
        )
        ( new_co
          ( difference co
            ( makeset c )
          )
        )
        ( cod_cliente
          ( p_cod_cliente
            ( ap o c )
          )
        )
      )
      ( if
        ( equal cod_cliente cc )
        ( union
          ( makeset c )
          ( da_orca_de_cliente_aux cc new_co o )
        )
        ( da_orca_de_cliente_aux cc new_co o )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_orcamento_sis )
        ( quote
          (
            (
              ( cod )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_orcamento_sis lambda
  ( c )
  ( let
    (
      ( s SISTEMA )
      ( emp
        ( p_empreitadas s )
      )
      ( o
        ( p_orcamentos emp )
      )
    )
    ( existe_orcamento c o )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote regista_orcamento_sis )
        ( quote
          (
            (
              ( cod )
              ( cod )
              ( data )
              ( lucro )
              ( lista_capitulos )
            )
            ( sistema )
          )
        )
      )
    )
  )
)
;---------------------

( def regista_orcamento_sis lambda
  ( c cc d lu l )
  ( let
    (
      ( s SISTEMA )
      ( emp
        ( p_empreitadas s )
      )
      ( o
        ( p_orcamentos emp )
      )
      ( contabilidez
        ( p_contabilidade s )
      )
      ( clientes
        ( p_clientes contabilidez )
      )
    )
    ( let
      (
        ( new_orcamento
          ( regista_orcamento c cc d lu l o )
        )
        ( new_empreitadas
          ( empreitada
            ( p_obras emp ) new_orcamento
            ( p_fichas emp )
            ( p_tab_produtos emp )
          )
        )
      )
      ( def SISTEMA
        ( sistema new_empreitadas
          ( p_central_c s )
          ( p_central_m_e s )
          ( p_estaleiro s )
          ( p_contabilidade s )
        )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_orcamento_sis )
        ( quote
          (
            (
              ( cod )
            )
            ( orca_info )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_orcamento_sis lambda
  ( c )
  ( let
    (
      ( s SISTEMA )
      ( emp
        ( p_empreitadas s )
      )
      ( o
        ( p_orcamentos emp )
      )
    )
    ( consulta_orcamento c o )
  )
)
;---------------------
; o Interface tem de verificar anterior/ se este orcamento existe e o numero de capitulos 
; registado nao e' menor que o do codcap pretendido!!! (isto pra f. consulta_cap_sis)

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_capitulo_sis )
        ( quote
          (
            (
              ( cod )
              ( cod )
            )
            ( capitulo )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_capitulo_sis lambda
  ( corca codcap )
  ( let
    (
      ( s SISTEMA )
      ( emp
        ( p_empreitadas s )
      )
      ( o
        ( p_orcamentos emp )
      )
      ( lista_cap
        ( p_lista_capitulos
          ( ap o corca )
        )
      )
    )
    ( consulta_capitulo codcap lista_cap 1 )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_capitulo )
        ( quote
          (
            (
              ( cod )
              ( lista_capitulos )
              ( INT )
            )
            ( capitulo )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_capitulo lambda
  ( c l contador )
  ( if
    ( equal l
      ( makeseq )
    ) nil
    ( if
      ( equal c contador )
      ( head l )
      ( consulta_capitulo c
        ( tail l )
        ( add contador 1 )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote regista_percentagem_sis )
        ( quote
          (
            (
              ( cod )
              ( cod )
              ( percentagem )
            )
            ( sistema )
          )
        )
      )
    )
  )
)
;---------------------

( def regista_percentagem_sis lambda
  ( corca coart p )
  ( prog1
    ( let
      (
        ( s SISTEMA )
        ( emp
          ( p_empreitadas s )
        )
        ( o
          ( p_orcamentos emp )
        )
      )
      ( if
        ( not
          ( existe_orcamento corca o )
        )
        ( princ "Nao existe o orcamento " corca "!\n" )
        ( if
          ( not
            ( existe_artigo corca coart o )
          )
          ( princ "Nao existe o artigo " coart " no orcamento!\n" )
          ( princ "\nRegistado...\n" )
        )
      )
    )
    ( let
      (
        ( emp
          ( p_empreitadas s )
        )
        ( o
          ( p_orcamentos emp )
        )
      )
      ( if
        ( and
          ( existe_orcamento corca o )
          ( existe_artigo corca coart o )
        )
        ( let
          (
            ( new_orcamento
              ( regista_percentagem corca coart p o )
            )
            ( new_empreitada
              ( empreitada
                ( p_obras emp ) new_orcamento
                ( p_fichas emp )
                ( p_tab_produtos emp )
              )
            )
          )
          ( def SISTEMA
            ( sistema new_empreitada
              ( p_central_c s )
              ( p_central_m_e s )
              ( p_estaleiro s )
              ( p_contabilidade s )
            )
          )
        )
        ( def SISTEMA s )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_auto_medicao_sis )
        ( quote
          (
            (
              ( cod )
              ( cod )
            )
            ( capitulo )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_auto_medicao_sis lambda
  ( corca numero_cap )
  ( let
    (
      ( s SISTEMA )
      ( emp
        ( p_empreitadas s )
      )
      ( o
        ( p_orcamentos emp )
      )
    )
    ( consulta_auto_medicao corca numero_cap o )
  )
)
;---------------------
;____________________________________________________________________________
; ex: regista_ficha_sis(1,info_ficha("bosta",{tabela(1,10),tabela(2,20)}))
;RETURN let (
;            emp = p_empreitadas(s),
;            f = p_fichas(emp)
;           )
;        in if existe_ficha(c,f)
;              then princ("Ja existe o artigo com codigo ",c,"! \n")
;              else princ("\nRegistado...\n")

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote regista_ficha_sis )
        ( quote
          (
            (
              ( cod )
              ( info_ficha )
            )
            ( sistema )
          )
        )
      )
    )
  )
)
;---------------------

( def regista_ficha_sis lambda
  ( c t )
  ( let
    (
      ( s SISTEMA )
      ( emp
        ( p_empreitadas s )
      )
      ( f
        ( p_fichas emp )
      )
    )
    ( let
      (
        ( new_fichas
          ( regista_ficha c t f )
        )
        ( new_empreitadas
          ( empreitada
            ( p_obras emp )
            ( p_orcamentos emp ) new_fichas
            ( p_tab_produtos emp )
          )
        )
      )
      ( def SISTEMA
        ( sistema new_empreitadas
          ( p_central_c s )
          ( p_central_m_e s )
          ( p_estaleiro s )
          ( p_contabilidade s )
        )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_ficha_sis )
        ( quote
          (
            (
              ( cod )
            )
            ( info_ficha )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_ficha_sis lambda
  ( c )
  ( let
    (
      ( s SISTEMA )
      ( emp
        ( p_empreitadas s )
      )
      ( f
        ( p_fichas emp )
      )
    )
    ( consulta_ficha c f )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_ficha_sis )
        ( quote
          (
            (
              ( cod )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_ficha_sis lambda
  ( c )
  ( let
    (
      ( s SISTEMA )
      ( emp
        ( p_empreitadas s )
      )
      ( f
        ( p_fichas emp )
      )
    )
    ( existe_ficha c f )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote todas_fichas_sis )
        ( quote
          (
            ( )
            ( fichas )
          )
        )
      )
    )
  )
)
;---------------------

( def todas_fichas_sis lambda
  ( )
  ( let
    (
      ( s SISTEMA )
      ( emp
        ( p_empreitadas s )
      )
      ( f
        ( p_fichas emp )
      )
    ) f
  )
)
;---------------------
;____________________________________________________________________________

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote regista_obra_sis )
        ( quote
          (
            (
              ( cod )
              ( cod )
              ( data )
              ( sistema )
            )
            ( sistema )
          )
        )
      )
    )
  )
)
;---------------------

( def regista_obra_sis lambda
  ( cobra corca d s )
  ( prog1
    ( let
      (
        ( emp
          ( p_empreitadas s )
        )
        ( o
          ( p_orcamentos emp )
        )
        ( ob
          ( p_obras emp )
        )
      )
      ( if
        ( not
          ( existe_orcamento corca o )
        )
        ( princ "Nao existe orcamento com o numero: " corca ". O orcamento e requerido.\n" )
        ( if
          ( existe_obra cobra ob )
          ( princ "Numero invalido. Obra " cobra " ja existente.\n" )
          ( princ "\nRegistado...\n" )
        )
      )
    )
    ( let
      (
        ( emp
          ( p_empreitadas s )
        )
        ( o
          ( p_orcamentos emp )
        )
        ( ob
          ( p_obras emp )
        )
      )
      ( if
        ( and
          ( existe_orcamento corca o )
          ( not
            ( existe_obra cobra ob )
          )
        )
        ( let
          (
            ( new_obras
              ( regista_obra cobra corca d ob )
            )
            ( new_empreitadas
              ( empreitada new_obras
                ( p_orcamentos emp )
                ( p_fichas emp )
                ( p_tab_produtos emp )
              )
            )
          )
          ( def SISTEMA
            ( sistema new_empreitadas
              ( p_central_c s )
              ( p_central_m_e s )
              ( p_estaleiro s )
              ( p_contabilidade s )
            )
          )
        )
        ( def SISTEMA s )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_obra_sis )
        ( quote
          (
            (
              ( cod )
              ( sistema )
            )
            ( obra_info )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_obra_sis lambda
  ( c s )
  ( let
    (
      ( emp
        ( p_empreitadas s )
      )
      ( ob
        ( p_obras emp )
      )
    )
    ( consulta_obra c ob )
  )
)
;---------------------
;____________________________________________________________________________

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote regista_consumo_sis )
        ( quote
          (
            (
              ( cod )
              ( data )
              ( LIST tabela )
              ( sistema )
            )
            ( sistema )
          )
        )
      )
    )
  )
)
;---------------------

( def regista_consumo_sis lambda
  ( c d l s )
  ( prog1
    ( let
      (
        ( emp
          ( p_empreitadas s )
        )
        ( ob
          ( p_obras emp )
        )
      )
      ( if
        ( not
          ( existe_obra c ob )
        )
        ( princ "Nao existe obras com o codigo " c ".\n" )
        ( let
          (
            ( info
              ( ap ob c )
            )
            ( corca
              ( p_cod_orcamento info )
            )
            ( lista_consumo_actual
              ( p_lista_consumo info )
            )
            ( dat_obra
              ( p_data_obra info )
            )
            ( l_aux
              ( consumo d l )
            )
            ( lista_consumo_nova
              ( cons l_aux lista_consumo_actual )
            )
          )
          ( if
            ( existe_consumo d lista_consumo_actual )
            ( princ "Ja existe consumo para a data " d "! \n" )
            ( princ "\nRegistado...\n" )
          )
        )
      )
    )
    ( let
      (
        ( emp
          ( p_empreitadas s )
        )
        ( ob
          ( p_obras emp )
        )
      )
      ( if
        ( and
          ( existe_obra c ob )
          ( not
            ( existe_consumo d lista_consumo_actual )
          )
        )
        ( let
          (
            ( new_obras
              ( regista_consumo c d l ob )
            )
            ( new_emp
              ( empreitada new_obras
                ( p_orcamentos emp )
                ( p_fichas emp )
                ( p_tab_produtos emp )
              )
            )
          )
          ( def SISTEMA
            ( sistema new_emp
              ( p_central_c s )
              ( p_central_m_e s )
              ( p_estaleiro s )
              ( p_contabilidade s )
            )
          )
        )
        ( def SISTEMA s )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_consumo_sis )
        ( quote
          (
            (
              ( cod )
              ( data )
              ( sistema )
            )
            ( LIST tabela )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_consumo_sis lambda
  ( c dd s )
  ( let
    (
      ( emp
        ( p_empreitadas s )
      )
      ( ob
        ( p_obras emp )
      )
    )
    ( consulta_consumo c dd ob )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote desvio_total_sis )
        ( quote
          (
            (
              ( cod )
              ( sistema )
            )
            ( preco )
          )
        )
      )
    )
  )
)
;---------------------

( def desvio_total_sis lambda
  ( cobra s )
  ( let
    (
      ( emp
        ( p_empreitadas s )
      )
      ( o
        ( p_orcamentos emp )
      )
      ( ob
        ( p_obras emp )
      )
    )
    ( if
      ( not
        ( existe_obra cobra ob )
      )
      ( princ "A obra referenciada: " cobra " nao existe!\n" )
      ( desvio_total cobra ob )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_tab_produtos_sis )
        ( quote
          (
            (
              ( cod )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_tab_produtos_sis lambda
  ( c )
  ( let
    (
      ( s SISTEMA )
      ( emp
        ( p_empreitadas s )
      )
      ( t
        ( p_tab_produtos emp )
      )
    )
    ( existe_tab_produtos c t )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote insere_tab_produtos_sis )
        ( quote
          (
            (
              ( cod )
              ( descricao )
            )
            ( sistema )
          )
        )
      )
    )
  )
)
;---------------------

( def insere_tab_produtos_sis lambda
  ( c d )
  ( let
    (
      ( s SISTEMA )
      ( emp
        ( p_empreitadas s )
      )
      ( t
        ( p_tab_produtos emp )
      )
      ( new_t
        ( insere_tab_produtos c d t )
      )
    )
    ( let
      (
        ( new_empreitadas
          ( empreitada
            ( p_obras emp )
            ( p_orcamentos emp )
            ( p_fichas emp ) new_t
          )
        )
      )
      ( def SISTEMA
        ( sistema new_empreitadas
          ( p_central_c s )
          ( p_central_m_e s )
          ( p_estaleiro s )
          ( p_contabilidade s )
        )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_tab_produtos_sis )
        ( quote
          (
            (
              ( cod )
            )
            ( tab_produtos )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_tab_produtos_sis lambda
  ( c )
  ( let
    (
      ( s SISTEMA )
      ( emp
        ( p_empreitadas s )
      )
      ( t
        ( p_tab_produtos emp )
      )
    )
    ( consulta_tab_produtos c t )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote todos_tab_produtos_sis )
        ( quote
          (
            ( )
            ( tab_produtos )
          )
        )
      )
    )
  )
)
;---------------------

( def todos_tab_produtos_sis lambda
  ( )
  ( let
    (
      ( s SISTEMA )
      ( emp
        ( p_empreitadas s )
      )
      ( t
        ( p_tab_produtos emp )
      )
    )
    ( todos_tab_produtos t )
  )
)
;---------------------
; --------- Parte do sistema que trata da central de compras ----------------
; esta funcao dara todos os fornecedores (o seu codigo) de um produto da tab_precos

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote forn_tab_precos_sis )
        ( quote
          (
            (
              ( cod )
            )
            ( SET cod )
          )
        )
      )
    )
  )
)
;---------------------

( def forn_tab_precos_sis lambda
  ( c )
  ( let
    (
      ( s SISTEMA )
      ( cc
        ( p_central_c s )
      )
      ( tabela_precos
        ( p_tab_precos cc )
      )
      ( dominio
        ( dom tabela_precos )
      )
    )
    ( forn_tab_precos_aux c dominio )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote forn_tab_precos_aux )
        ( quote
          (
            (
              ( cod )
              ( SET chave )
            )
            ( SET cod )
          )
        )
      )
    )
  )
)
;---------------------

( def forn_tab_precos_aux lambda
  ( c dominio )
  ( let
    (
      ( chaves
        ( set aux
          ( from aux dominio
            ( equal
              ( p_cod_produto aux ) c
            )
          )
        )
      )
      ( codigos
        ( set
          ( p_cod_forn aux )
          ( from aux chaves )
        )
      )
    ) codigos
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_tab_precos_sis )
        ( quote
          (
            (
              ( cod )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_tab_precos_sis lambda
  ( c )
  ( let
    (
      ( s SISTEMA )
      ( cc
        ( p_central_c s )
      )
      ( tabela_precos
        ( p_tab_precos cc )
      )
      ( valor_max
        ( consulta_tab_precos c tabela_precos )
      )
    )
    ( if
      ( equal valor_max 0 ) false true
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_esp_tab_precos_sis )
        ( quote
          (
            (
              ( chave )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_esp_tab_precos_sis lambda
  ( c )
  ( let
    (
      ( s SISTEMA )
      ( cc
        ( p_central_c s )
      )
      ( tabela_precos
        ( p_tab_precos cc )
      )
    )
    ( existe_tab_precos c tabela_precos )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_esp_tab_precos_sis )
        ( quote
          (
            (
              ( chave )
            )
            ( preco )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_esp_tab_precos_sis lambda
  ( c )
  ( let
    (
      ( s SISTEMA )
      ( cc
        ( p_central_c s )
      )
      ( tabela_precos
        ( p_tab_precos cc )
      )
    )
    ( ap tabela_precos c )
  )
)
;---------------------
;RETURN let (
;			s = SISTEMA,
;           cc = p_central_c(s),
;           tabela_precos = p_tab_precos(cc)
;          )
;      in if existe_tab_precos(c,tabela_precos)
;         then princ("Ja existia esse produtos desse fornecedor...\n...assume-se que o preco foi actualizado!\n")
;         else princ("\nRegistado...\n")

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote insere_tab_precos_sis )
        ( quote
          (
            (
              ( chave )
              ( preco )
            )
            ( sistema )
          )
        )
      )
    )
  )
)
;---------------------

( def insere_tab_precos_sis lambda
  ( c p )
  ( let
    (
      ( s SISTEMA )
      ( cc
        ( p_central_c s )
      )
      ( tabela_precos
        ( p_tab_precos cc )
      )
      ( new_tab
        ( insere_tab_precos c p tabela_precos )
      )
      ( new_central_c
        ( central_c
          ( p_lista_pedidos cc )
          ( p_lista_encomendas cc ) new_tab
        )
      )
    )
    ( def SISTEMA
      ( sistema
        ( p_empreitadas s ) new_central_c
        ( p_central_m_e s )
        ( p_estaleiro s )
        ( p_contabilidade s )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_tab_precos_sis )
        ( quote
          (
            (
              ( cod )
            )
            ( preco )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_tab_precos_sis lambda
  ( c )
  ( let
    (
      ( s SISTEMA )
      ( cc
        ( p_central_c s )
      )
      ( tabela_precos
        ( p_tab_precos cc )
      )
      ( valor_max
        ( consulta_tab_precos c tabela_precos )
      )
    ) valor_max
  )
)
;---------------------
;      in if valor_max == 0
;            then princ("Esse produto nao esta registado nas tabelas de precos.\n")
;            else princ("Preco maximo de mercado desse produto = ",valor_max,".\n");
; -------- Parte do sistema que trata da central de mao-de-obra e equip. -----

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote insere_humano_sis )
        ( quote
          (
            (
              ( cod )
              ( nome )
              ( descricao )
              ( cod )
              ( salario )
              ( sistema )
            )
            ( sistema )
          )
        )
      )
    )
  )
)
;---------------------

( def insere_humano_sis lambda
  ( c n d o z s )
  ( prog1
    ( let
      (
        ( cme
          ( p_central_m_e s )
        )
        ( rh
          ( p_rec_humanos cme )
        )
        ( lixo
          ( set aux
            ( from aux rh
              ( equal
                ( p_cod_pessoal aux ) c
              )
            )
          )
        )
      )
      ( if
        ( existe_humano c rh )
        ( princ "O empregado " c " a existe!\n" )
        ( princ "\nRegistado...\n" )
      )
    )
    ( let
      (
        ( cme
          ( p_central_m_e s )
        )
        ( rh
          ( p_rec_humanos cme )
        )
        ( lixo
          ( set aux
            ( from aux rh
              ( equal
                ( p_cod_pessoal aux ) c
              )
            )
          )
        )
      )
      ( if
        ( not
          ( existe_humano c rh )
        )
        ( let
          (
            ( new_rh
              ( insere_humano c n d o z rh )
            )
            ( new_cme
              ( central_m_e
                ( p_lista_pedme cme ) new_rh
                ( p_rec_equip cme )
              )
            )
          )
          ( def SISTEMA
            ( sistema
              ( p_empreitadas s )
              ( p_central_c s ) new_cme
              ( p_estaleiro s )
              ( p_contabilidade s )
            )
          )
        )
        ( def SISTEMA s )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_humano_sis )
        ( quote
          (
            (
              ( cod )
              ( sistema )
            )
            ( humano )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_humano_sis lambda
  ( c s )
  ( let
    (
      ( cme
        ( p_central_m_e s )
      )
      ( r
        ( p_rec_humanos cme )
      )
    )
    ( consulta_humano c r )
  )
)
;---------------------
; --------------- Parte do sistema que trata da contabilidade ---------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote todos_clientes_sis )
        ( quote
          (
            ( )
            ( clientes )
          )
        )
      )
    )
  )
)
;---------------------

( def todos_clientes_sis lambda
  ( )
  ( let
    (
      ( s SISTEMA )
      ( conta
        ( p_contabilidade s )
      )
      ( clientes
        ( p_clientes conta )
      )
    ) clientes
  )
)
;---------------------
; funciona como uma especie de update

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote insere_cliente_sis )
        ( quote
          (
            (
              ( cod )
              ( nome )
              ( morada )
              ( n_contri )
            )
            ( sistema )
          )
        )
      )
    )
  )
)
;---------------------

( def insere_cliente_sis lambda
  ( c n m i )
  ( let
    (
      ( s SISTEMA )
      ( conta
        ( p_contabilidade s )
      )
      ( clientes
        ( p_clientes conta )
      )
    )
    ( let
      (
        ( new_clientes
          ( insere_cliente c n m i clientes )
        )
        ( new_conta
          ( contabilidade new_clientes
            ( p_fornecedores conta )
            ( p_facturas conta )
            ( p_recibos conta )
          )
        )
      )
      ( def SISTEMA
        ( sistema
          ( p_empreitadas s )
          ( p_central_c s )
          ( p_central_m_e s )
          ( p_estaleiro s ) new_conta
        )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_cliente_sis )
        ( quote
          (
            (
              ( cod )
            )
            ( inf_cliente )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_cliente_sis lambda
  ( c )
  ( let
    (
      ( s SISTEMA )
      ( conta
        ( p_contabilidade s )
      )
      ( clientes
        ( p_clientes conta )
      )
    )
    ( consulta_cliente c clientes )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote remove_cliente_sis )
        ( quote
          (
            (
              ( cod )
            )
            ( sistema )
          )
        )
      )
    )
  )
)
;---------------------

( def remove_cliente_sis lambda
  ( c )
  ( prog1
    ( let
      (
        ( s SISTEMA )
        ( conta
          ( p_contabilidade s )
        )
        ( clientes
          ( p_clientes conta )
        )
      )
      ( if
        ( existe_cliente c clientes )
        ( if
          ( member c
            ( todos_clientes SISTEMA )
          )
          ( princ "Esse cliente nao pode ser removido. Ha dependencias orcamentais.\n" )
          ( princ "Cliente " c " removido!\n" )
        )
        ( princ "Esse cliente nao existe!\n" )
      )
    )
    ( let
      (
        ( s SISTEMA )
        ( conta
          ( p_contabilidade s )
        )
        ( clientes
          ( p_clientes conta )
        )
      )
      ( if
        ( or
          ( not
            ( existe_cliente c clientes )
          )
          ( member c
            ( todos_clientes s )
          )
        )
        ( def SISTEMA s )
        ( let
          (
            ( new_clientes
              ( remove_cliente c clientes )
            )
            ( new_conta
              ( contabilidade new_clientes
                ( p_fornecedores conta )
                ( p_facturas conta )
                ( p_recibos conta )
              )
            )
          )
          ( def SISTEMA
            ( sistema
              ( p_empreitadas s )
              ( p_central_c s )
              ( p_central_m_e s )
              ( p_estaleiro s ) new_conta
            )
          )
        )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_cliente_sis )
        ( quote
          (
            (
              ( cod )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_cliente_sis lambda
  ( c )
  ( let
    (
      ( s SISTEMA )
      ( conta
        ( p_contabilidade s )
      )
      ( clientes
        ( p_clientes conta )
      )
    )
    ( existe_cliente c clientes )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote lista_clientes_sis )
        ( quote
          (
            ( )
            ( clientes )
          )
        )
      )
    )
  )
)
;---------------------

( def lista_clientes_sis lambda
  ( )
  ( let
    (
      ( s SISTEMA )
      ( conta
        ( p_contabilidade s )
      )
      ( clientes
        ( p_clientes conta )
      )
    ) clientes
  )
)
;---------------------
; ---------------------------------------------------------------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote todos_fornecedores_sis )
        ( quote
          (
            ( )
            ( fornecedores )
          )
        )
      )
    )
  )
)
;---------------------

( def todos_fornecedores_sis lambda
  ( )
  ( let
    (
      ( s SISTEMA )
      ( conta
        ( p_contabilidade s )
      )
      ( forn
        ( p_fornecedores conta )
      )
    ) forn
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_fornecedor_sis )
        ( quote
          (
            (
              ( cod )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_fornecedor_sis lambda
  ( c )
  ( let
    (
      ( s SISTEMA )
      ( conta
        ( p_contabilidade s )
      )
      ( forn
        ( p_fornecedores conta )
      )
    )
    ( existe_fornecedor c forn )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote insere_fornecedor_sis )
        ( quote
          (
            (
              ( cod )
              ( nome )
              ( morada )
              ( n_contri )
            )
            ( sistema )
          )
        )
      )
    )
  )
)
;---------------------

( def insere_fornecedor_sis lambda
  ( c n m i )
  ( let
    (
      ( s SISTEMA )
      ( conta
        ( p_contabilidade s )
      )
      ( forn
        ( p_fornecedores conta )
      )
    )
    ( if
      ( existe_fornecedor c forn )
      ( def SISTEMA s )
      ( let
        (
          ( new_forn
            ( insere_fornecedor c n m i forn )
          )
          ( new_conta
            ( contabilidade
              ( p_clientes conta ) new_forn
              ( p_facturas conta )
              ( p_recibos conta )
            )
          )
        )
        ( def SISTEMA
          ( sistema
            ( p_empreitadas s )
            ( p_central_c s )
            ( p_central_m_e s )
            ( p_estaleiro s ) new_conta
          )
        )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_fornecedor_sis )
        ( quote
          (
            (
              ( cod )
            )
            ( inf_forn )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_fornecedor_sis lambda
  ( c )
  ( let
    (
      ( s SISTEMA )
      ( conta
        ( p_contabilidade s )
      )
      ( forn
        ( p_fornecedores conta )
      )
    )
    ( consulta_fornecedor c forn )
  )
)
;---------------------
; Falta testar se nao se esta a remover um fornecedor que nao se pode !!!

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote remove_fornecedor_sis )
        ( quote
          (
            (
              ( cod )
              ( sistema )
            )
            ( sistema )
          )
        )
      )
    )
  )
)
;---------------------

( def remove_fornecedor_sis lambda
  ( c s )
  ( prog1
    ( let
      (
        ( conta
          ( p_contabilidade s )
        )
        ( forn
          ( p_fornecedores conta )
        )
      )
      ( if
        ( existe_fornecedor c forn )
        ( princ "\nRemovido...\n" )
        ( princ "Esse fornecedor nao existe!\n" )
      )
    )
    ( let
      (
        ( conta
          ( p_contabilidade s )
        )
        ( forn
          ( p_fornecedores conta )
        )
      )
      ( if
        ( not
          ( existe_fornecedor c forn )
        )
        ( def SISTEMA s )
        ( let
          (
            ( new_forn
              ( remove_fornecedor c forn )
            )
            ( new_conta
              ( contabilidade
                ( p_clientes conta ) new_forn
                ( p_facturas conta )
                ( p_recibos conta )
              )
            )
          )
          ( def SISTEMA
            ( sistema
              ( p_empreitadas s )
              ( p_central_c s )
              ( p_central_m_e s )
              ( p_estaleiro s ) new_conta
            )
          )
        )
      )
    )
  )
)
;---------------------
; ---------------------------------------------------------------------------
; ****************************** EMPREITADAS ********************************
; ---------------------------------------------------------------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_empreitada )
        ( quote
          (
            ( )
            ( empreitada )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_empreitada lambda
  ( )
  ( empreitada
    ( inic_obra )
    ( inic_orcamento )
    ( inic_fichas )
    ( inic_tab_produtos )
  )
)
;---------------------
; * * * * * * * * * ORCAMENTOS * * * * * * * *
; Falta tambem verificar se ha capitulos e artigos repetidos no mesmo orcamento

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_orcamento )
        ( quote
          (
            ( )
            ( orcamentos )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_orcamento lambda
  ( )
  ( makeff )
)
;---------------------
; Parte de teste se existe os produtos na tab. precos, daqueles referidos em
; cada artigo de cada capitulo do orcamento

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote resultado )
        ( quote
          (
            (
              ( INT )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def resultado lambda
  ( a )
  ( if
    ( nequal a 0 ) true false
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote corre_prod )
        ( quote
          (
            (
              ( SET tabela )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def corre_prod lambda
  ( l )
  ( if
    ( equal l
      ( makeset )
    ) true
    ( let
      (
        ( e
          ( choice l )
        )
        ( codigo
          ( p_cod_produto e )
        )
        ( tab_pre
          ( p_tab_precos
            ( p_central_c SISTEMA )
          )
        )
        ( preco
          ( consulta_tab_precos codigo tab_pre )
        )
        ( novo
          ( difference l
            ( makeset e )
          )
        )
      )
      ( and
        ( resultado preco )
        ( corre_prod novo )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote corre_art )
        ( quote
          (
            (
              ( lista_artigos )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def corre_art lambda
  ( l )
  ( if
    ( equal l
      ( makeseq )
    ) true
    ( let
      (
        ( fichas
          ( p_fichas
            ( p_empreitadas SISTEMA )
          )
        )
        ( h_art
          ( head l )
        )
        ( t_art
          ( tail l )
        )
        ( cod_art
          ( p_cod_artigo h_art )
        )
        ( info
          ( ap fichas cod_art )
        )
        ( conj_produtos
          ( p_tabela info )
        )
      )
      ( and
        ( corre_art t_art )
        ( corre_prod conj_produtos )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote corre_cap )
        ( quote
          (
            (
              ( lista_capitulos )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def corre_cap lambda
  ( l )
  ( if
    ( equal l
      ( makeseq )
    ) true
    ( let
      (
        ( fichas
          ( p_fichas
            ( p_empreitadas SISTEMA )
          )
        )
        ( h_cap
          ( head l )
        )
        ( t_cap
          ( tail l )
        )
        ( lista_art
          ( p_lista_artigos h_cap )
        )
      )
      ( and
        ( and
          ( nequal fichas
            ( makeff )
          )
          ( corre_art lista_art )
        )
        ( corre_cap t_cap )
      )
    )
  )
)
;---------------------
; tem de se garantir que as fichas existem para que nao haja erro na funcao
; "corre_art" onde se faz ...=fichas[...]

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_orcamento )
        ( quote
          (
            (
              ( cod )
              ( orcamentos )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_orcamento lambda
  ( c o )
  ( if
    ( member c
      ( dom o )
    ) true false
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote regista_orcamento )
        ( quote
          (
            (
              ( cod )
              ( cod )
              ( data )
              ( lucro )
              ( lista_capitulos )
              ( orcamentos )
            )
            ( orcamentos )
          )
        )
      )
    )
  )
)
;---------------------

( def regista_orcamento lambda
  ( c cc d lu l o )
  ( if
    ( existe_orcamento c o )
    ( let
      (
        ( lista_antiga
          ( p_lista_capitulos
            ( ap o c )
          )
        )
        ( nova_lista
          ( append lista_antiga
            ( constroi_l_cap lu l )
          )
        )
      )
      ( plus o
        ( makeff
          ( c
            ( orca_info cc d lu nova_lista )
          )
        )
      )
    )
    ( plus o
      ( makeff
        ( c
          ( orca_info cc d lu
            ( constroi_l_cap lu l )
          )
        )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote soma_prod )
        ( quote
          (
            (
              ( SET tabela )
            )
            ( preco )
          )
        )
      )
    )
  )
)
;---------------------

( def soma_prod lambda
  ( l )
  ( if
    ( equal l
      ( makeset )
    ) 0
    ( let
      (
        ( e
          ( choice l )
        )
        ( codigo
          ( p_cod_produto e )
        )
        ( tab_pre
          ( p_tab_precos
            ( p_central_c SISTEMA )
          )
        )
        ( preco
          ( consulta_tab_precos codigo tab_pre )
        )
        ( qtd
          ( p_quantidade e )
        )
        ( novo
          ( difference l
            ( makeset e )
          )
        )
      )
      ( add
        ( mul preco qtd )
        ( soma_prod novo )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote constroi_l_art )
        ( quote
          (
            (
              ( lista_artigos )
            )
            ( lista_artigos )
          )
        )
      )
    )
  )
)
;---------------------

( def constroi_l_art lambda
  ( l )
  ( if
    ( equal l
      ( makeseq )
    )
    ( makeseq )
    ( let
      (
        ( fichas
          ( p_fichas
            ( p_empreitadas SISTEMA )
          )
        )
        ( h_art
          ( head l )
        )
        ( t_art
          ( tail l )
        )
        ( cod_art
          ( p_cod_artigo h_art )
        )
        ( qtd
          ( p_qtd_artigo h_art )
        )
        ( info
          ( ap fichas cod_art )
        )
        ( conj_produtos
          ( p_tabela info )
        )
        ( custo_artigo
          ( mul
            ( soma_prod conj_produtos ) qtd
          )
        )
      )
      ( cons
        ( artigo cod_art qtd
          ( makeseq 0 ) custo_artigo
        )
        ( constroi_l_art t_art )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote cal_preco_final )
        ( quote
          (
            (
              ( lista_artigos )
            )
            ( preco )
          )
        )
      )
    )
  )
)
;---------------------

( def cal_preco_final lambda
  ( a )
  ( if
    ( equal a
      ( makeseq )
    ) 0
    ( let
      (
        ( artigo
          ( head a )
        )
        ( t_art
          ( tail a )
        )
        ( preco_artigo
          ( p_pu artigo )
        )
      )
      ( add preco_artigo
        ( cal_preco_final t_art )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote constroi_l_cap )
        ( quote
          (
            (
              ( lucro )
              ( lista_capitulos )
            )
            ( lista_capitulos )
          )
        )
      )
    )
  )
)
;---------------------

( def constroi_l_cap lambda
  ( lu l )
  ( if
    ( equal l
      ( makeseq )
    )
    ( makeseq )
    ( let
      (
        ( h_cap
          ( head l )
        )
        ( t_cap
          ( tail l )
        )
        ( descr
          ( p_desc_capitulo h_cap )
        )
        ( lista_art
          ( p_lista_artigos h_cap )
        )
        ( nova_lista_art
          ( constroi_l_art lista_art )
        )
        ( preco_cap_s_lucro
          ( cal_preco_final nova_lista_art )
        )
        ( preco_cap
          ( add
            ( div
              ( mul lu preco_cap_s_lucro ) 100
            ) preco_cap_s_lucro
          )
        )
      )
      ( cons
        ( capitulo descr nova_lista_art preco_cap )
        ( constroi_l_cap lu t_cap )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_orcamento )
        ( quote
          (
            (
              ( cod )
              ( orcamentos )
            )
            ( orca_info )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_orcamento lambda
  ( c o )
  ( if
    ( existe_orcamento c o )
    ( let
      (
        ( info
          ( ap o c )
        )
      ) info
    ) nil
  )
)
;---------------------
; Parte do orcamento que faz o registo da realizacao da obra

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_artigo_aux2 )
        ( quote
          (
            (
              ( cod )
              ( lista_artigos )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_artigo_aux2 lambda
  ( coart lista_art )
  ( if
    ( equal lista_art
      ( makeseq )
    ) false
    ( let
      (
        ( art
          ( head lista_art )
        )
        ( t
          ( tail lista_art )
        )
        ( c
          ( p_cod_artigo art )
        )
      )
      ( or
        ( equal c coart )
        ( existe_artigo_aux2 coart t )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_artigo_aux1 )
        ( quote
          (
            (
              ( cod )
              ( lista_capitulos )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_artigo_aux1 lambda
  ( coart lista_cap )
  ( if
    ( equal lista_cap
      ( makeseq )
    ) false
    ( let
      (
        ( cap
          ( head lista_cap )
        )
        ( t
          ( tail lista_cap )
        )
        ( lista_art
          ( p_lista_artigos cap )
        )
      )
      ( or
        ( existe_artigo_aux2 coart lista_art )
        ( existe_artigo_aux1 coart t )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_artigo )
        ( quote
          (
            (
              ( cod )
              ( cod )
              ( orcamentos )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_artigo lambda
  ( corca coart o )
  ( let
    (
      ( info
        ( ap o corca )
      )
      ( lista_cap
        ( p_lista_capitulos info )
      )
    )
    ( existe_artigo_aux1 coart lista_cap )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote regista_percentagem )
        ( quote
          (
            (
              ( cod )
              ( cod )
              ( percentagem )
              ( orcamentos )
            )
            ( orcamentos )
          )
        )
      )
    )
  )
)
;---------------------

( def regista_percentagem lambda
  ( corca coart p o )
  ( let
    (
      ( info
        ( ap o corca )
      )
      ( cc
        ( p_cod_cliente info )
      )
      ( d
        ( p_data_orca info )
      )
      ( lc
        ( p_lista_capitulos info )
      )
      ( nova_lista
        ( regista_per coart lc p )
      )
    )
    ( plus o
      ( makeff
        ( corca
          ( orca_info cc d nova_lista )
        )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote regista_per )
        ( quote
          (
            (
              ( cod )
              ( lista_capitulos )
              ( percentagem )
            )
            ( lista_capitulos )
          )
        )
      )
    )
  )
)
;---------------------

( def regista_per lambda
  ( c lc per )
  ( if
    ( equal lc
      ( makeseq )
    )
    ( makeseq )
    ( let
      (
        ( h
          ( head lc )
        )
        ( t
          ( tail lc )
        )
      )
      ( cons
        ( regista_per_aux c h per )
        ( regista_per c t per )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote regista_per_aux )
        ( quote
          (
            (
              ( cod )
              ( capitulo )
              ( percentagem )
            )
            ( capitulo )
          )
        )
      )
    )
  )
)
;---------------------

( def regista_per_aux lambda
  ( c cap per )
  ( let
    (
      ( d
        ( p_desc_capitulo cap )
      )
      ( l
        ( p_lista_artigos cap )
      )
      ( p
        ( p_total cap )
      )
      ( new
        ( regista_lista c l per )
      )
    )
    ( capitulo d new p )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote regista_lista )
        ( quote
          (
            (
              ( cod )
              ( lista_artigos )
              ( percentagem )
            )
            ( lista_artigos )
          )
        )
      )
    )
  )
)
;---------------------

( def regista_lista lambda
  ( c l per )
  ( if
    ( equal l
      ( makeseq )
    )
    ( makeseq )
    ( let
      (
        ( h
          ( head l )
        )
        ( t
          ( tail l )
        )
      )
      ( cons
        ( regista_art c h per )
        ( regista_lista c t per )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote regista_art )
        ( quote
          (
            (
              ( cod )
              ( artigo )
              ( percentagem )
            )
            ( artigo )
          )
        )
      )
    )
  )
)
;---------------------

( def regista_art lambda
  ( c a per )
  ( let
    (
      ( cod_artigo
        ( p_cod_artigo a )
      )
      ( q
        ( p_qtd_artigo a )
      )
      ( r
        ( p_realizacao a )
      )
      ( p
        ( p_pu a )
      )
    )
    ( if
      ( equal cod_artigo c )
      ( artigo c q
        ( actualiza r per ) p
      )
      ( artigo cod_artigo q r p )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote actualiza )
        ( quote
          (
            (
              ( realizacao )
              ( percentagem )
            )
            ( realizacao )
          )
        )
      )
    )
  )
)
;---------------------

( def actualiza lambda
  ( r per )
  ( if
    ( nao_excede_cem
      ( cons per r ) 0
    )
    ( cons per r ) r
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote nao_excede_cem )
        ( quote
          (
            (
              ( realizacao )
              ( INT )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def nao_excede_cem lambda
  ( r contador )
  ( if
    ( equal r
      ( makeseq )
    )
    ( if
      ( leq contador 100 ) true false
    )
    ( let
      (
        ( h
          ( head r )
        )
        ( t
          ( tail r )
        )
        ( new_conta
          ( add contador h )
        )
      )
      ( nao_excede_cem t new_conta )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_auto_medicao )
        ( quote
          (
            (
              ( cod )
              ( cod )
              ( orcamentos )
            )
            ( capitulo )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_auto_medicao lambda
  ( corca numero_cap o )
  ( if
    ( existe_orcamento corca o )
    ( let
      (
        ( info
          ( ap o corca )
        )
        ( l
          ( p_lista_capitulos info )
        )
      )
      ( consulta_auto_aux numero_cap l 1 )
    )
    ( princ "Nao existe esse orcamento! \n" )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_auto_aux )
        ( quote
          (
            (
              ( INT )
              ( lista_capitulos )
              ( INT )
            )
            ( lista_capitulos )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_auto_aux lambda
  ( n l contador )
  ( if
    ( equal l
      ( makeseq )
    )
    ( princ "Nao existe esse capitulo!\n" )
    ( if
      ( lt contador n )
      ( let
        (
          ( novo_conta
            ( add contador 1 )
          )
          ( t
            ( tail l )
          )
        )
        ( consulta_auto_aux n t novo_conta )
      )
      ( if
        ( equal contador n )
        ( head l )
      )
    )
  )
)
;---------------------
; * * * * * * * * * * FICHAS LNEC * * * * * * * * * * *

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_fichas )
        ( quote
          (
            ( )
            ( fichas )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_fichas lambda
  ( )
  ( makeff )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_ficha )
        ( quote
          (
            (
              ( cod )
              ( fichas )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_ficha lambda
  ( c f )
  ( if
    ( member c
      ( dom f )
    ) true false
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote regista_ficha )
        ( quote
          (
            (
              ( cod )
              ( info_ficha )
              ( fichas )
            )
            ( fichas )
          )
        )
      )
    )
  )
)
;---------------------

( def regista_ficha lambda
  ( c t f )
  ( if
    ( existe_ficha c f )
    ( let
      (
        ( desc
          ( p_descricao t )
        )
        ( new_tabela
          ( union
            ( p_tabela t )
            ( p_tabela
              ( ap f c )
            )
          )
        )
        ( new_info
          ( info_ficha desc new_tabela )
        )
      )
      ( plus f
        ( makeff
          ( c new_info )
        )
      )
    )
    ( plus f
      ( makeff
        ( c t )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_ficha )
        ( quote
          (
            (
              ( cod )
              ( fichas )
            )
            ( info_ficha )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_ficha lambda
  ( c f )
  ( if
    ( existe_ficha c f )
    ( ap f c )
    ( pp "Nao existe esse artigo! \n" )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote regista_ficha_aux )
        ( quote
          (
            (
              ( cod )
              ( tabela )
              ( fichas )
            )
            ( fichas )
          )
        )
      )
    )
  )
)
;---------------------

( def regista_ficha_aux lambda
  ( c t f )
  ( if
    ( existe_ficha c f )
    ( let
      (
        ( ficha
          ( ap f c )
        )
        ( tab
          ( union
            ( p_tabela ficha ) t
          )
        )
      )
      ( plus f
        ( makeff
          ( c tab )
        )
      )
    )
  )
)
;---------------------
; * * * * * * * * * OBRAS * * * * * * * * * *
; falta interligar os consumos com a obra ??

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_obra )
        ( quote
          (
            ( )
            ( obras )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_obra lambda
  ( )
  ( makeff )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_obra )
        ( quote
          (
            (
              ( cod )
              ( obras )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_obra lambda
  ( c o )
  ( if
    ( member c
      ( dom o )
    ) true false
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote regista_obra )
        ( quote
          (
            (
              ( cod )
              ( cod )
              ( data )
              ( obras )
            )
            ( obras )
          )
        )
      )
    )
  )
)
;---------------------

( def regista_obra lambda
  ( cobra corca d o )
  ( plus o
    ( makeff
      ( cobra
        ( obra_info corca
          ( makeseq ) d
        )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_obra )
        ( quote
          (
            (
              ( cod )
              ( obras )
            )
            ( obra_info )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_obra lambda
  ( c o )
  ( if
    ( existe_obra c o )
    ( ap o c )
    ( pp "Nao existe obra com esse codigo! \n" )
  )
)
;---------------------
; * * * * * * * CONSUMO * * * * * * * *  esta dependente da obra

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_consumo )
        ( quote
          (
            (
              ( data )
              ( lista_consumo )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_consumo lambda
  ( dd c )
  ( if
    ( equal c
      ( makeseq )
    ) false
    ( let
      (
        ( h
          ( head c )
        )
        ( t
          ( tail c )
        )
        ( d_aux
          ( p_data h )
        )
      )
      ( if
        ( equal dd d_aux ) true
        ( existe_consumo dd t )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote regista_consumo )
        ( quote
          (
            (
              ( cod )
              ( data )
              ( LIST tabela )
              ( obras )
            )
            ( obras )
          )
        )
      )
    )
  )
)
;---------------------

( def regista_consumo lambda
  ( c d l o )
  ( let
    (
      ( info
        ( ap o c )
      )
      ( corca
        ( p_cod_orcamento info )
      )
      ( lista_consumo_actual
        ( p_lista_consumo info )
      )
      ( dat_obra
        ( p_data_obra info )
      )
      ( l_aux
        ( consumo d l )
      )
      ( lista_consumo_nova
        ( cons l_aux lista_consumo_actual )
      )
    )
    ( plus o
      ( makeff
        ( c
          ( obra_info corca lista_consumo_nova dat_obra )
        )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_consumo )
        ( quote
          (
            (
              ( cod )
              ( data )
              ( obras )
            )
            ( LIST tabela )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_consumo lambda
  ( c dd o )
  ( if
    ( not
      ( existe_obra c o )
    )
    ( princ "Nao existe obra com o codigo " c "\n" )
    ( let
      (
        ( info
          ( ap o c )
        )
        ( lista
          ( p_lista_consumo info )
        )
      )
      ( consulta_consumo_aux dd lista )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_consumo_aux )
        ( quote
          (
            (
              ( data )
              ( lista_consumo )
            )
            ( LIST tabela )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_consumo_aux lambda
  ( dd c )
  ( if
    ( equal c
      ( makeseq )
    )
    ( pp "Nao ha consumos nessa data. \n" )
    ( let
      (
        ( h
          ( head c )
        )
        ( t
          ( tail c )
        )
        ( d_aux
          ( p_data h )
        )
        ( info
          ( p_tabela_lista h )
        )
      )
      ( if
        ( equal dd d_aux ) info
        ( consulta_consumo_aux dd t )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote desvio_total )
        ( quote
          (
            (
              ( cod )
              ( obras )
            )
            ( INT )
          )
        )
      )
    )
  )
)
;---------------------

( def desvio_total lambda
  ( cobra o )
  ( let
    (
      ( info
        ( ap o cobra )
      )
      ( l_consumos
        ( p_lista_consumo info )
      )
      ( emp
        ( p_empreitadas SISTEMA )
      )
      ( orcamentos
        ( p_orcamentos emp )
      )
      ( orca
        ( ap orcamentos
          ( p_cod_orcamento
            ( ap o cobra )
          )
        )
      )
      ( l_capitulos
        ( p_lista_capitulos orca )
      )
      ( total_orcamentado
        ( desvio_aux1 l_capitulos 0 )
      )
      ( total_gasto
        ( desvio_aux2 l_consumos 0 )
      )
      ( total
        ( sub total_orcamentado total_gasto )
      )
    )
    ( princ "Total orcamentado - total gasto = " total " ate hoje!\n" )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote desvio_aux1 )
        ( quote
          (
            (
              ( lista_capitulos )
              ( INT )
            )
            ( INT )
          )
        )
      )
    )
  )
)
;---------------------

( def desvio_aux1 lambda
  ( lc contador )
  ( if
    ( equal lc
      ( makeseq )
    ) contador
    ( let
      (
        ( h
          ( head lc )
        )
        ( t
          ( tail lc )
        )
        ( preco_cap
          ( p_total h )
        )
        ( conta
          ( add contador preco_cap )
        )
      )
      ( desvio_aux1 t conta )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote desvio_aux2 )
        ( quote
          (
            (
              ( lista_consumo )
              ( INT )
            )
            ( INT )
          )
        )
      )
    )
  )
)
;---------------------

( def desvio_aux2 lambda
  ( l soma )
  ( if
    ( equal l
      ( makeseq )
    ) soma
    ( let
      (
        ( h
          ( head l )
        )
        ( t
          ( tail l )
        )
        ( tab
          ( p_tabela_lista h )
        )
        ( soma_aux
          ( desvio_aux3 tab soma )
        )
      )
      ( desvio_aux2 t soma_aux )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote desvio_aux3 )
        ( quote
          (
            (
              ( tabela_lista )
              ( INT )
            )
            ( INT )
          )
        )
      )
    )
  )
)
;---------------------

( def desvio_aux3 lambda
  ( l soma )
  ( if
    ( equal l
      ( makeseq )
    ) soma
    ( let
      (
        ( h
          ( head l )
        )
        ( t
          ( tail l )
        )
        ( cod_prod
          ( p_cod_produto h )
        )
        ( qtd
          ( p_quantidade h )
        )
        ( tab_pre
          ( p_tab_precos
            ( p_central_c SISTEMA )
          )
        )
        ( preco
          ( consulta_tab_precos cod_prod tab_pre )
        )
        ( new_soma
          ( add soma preco )
        )
      )
      ( desvio_aux3 t new_soma )
    )
  )
)
;---------------------
; * * * * * * * * * * TABELA DE PRODUTOS * * * * * * * *

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_tab_produtos )
        ( quote
          (
            ( )
            ( tab_produtos )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_tab_produtos lambda
  ( )
  ( makeset )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_tab_produtos )
        ( quote
          (
            (
              ( cod )
              ( tab_produtos )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_tab_produtos lambda
  ( c t )
  ( let
    (
      ( lixo
        ( set aux
          ( from aux t
            ( equal
              ( p_cod_prod aux ) c
            )
          )
        )
      )
    )
    ( nequal lixo
      ( makeset )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote insere_tab_produtos )
        ( quote
          (
            (
              ( cod )
              ( descricao )
              ( tab_produtos )
            )
            ( tab_produtos )
          )
        )
      )
    )
  )
)
;---------------------

( def insere_tab_produtos lambda
  ( c d t )
  ( let
    (
      ( novo
        ( produtos c d )
      )
      ( new
        ( makeset novo )
      )
    )
    ( if
      ( existe_tab_produtos c t )
      ( union
        ( remove_tab_produtos c t ) new
      )
      ( union t new )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_tab_produtos )
        ( quote
          (
            (
              ( cod )
              ( tab_produtos )
            )
            ( produtos )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_tab_produtos lambda
  ( c t )
  ( if
    ( existe_tab_produtos c t )
    ( let
      (
        ( lixo
          ( set aux
            ( from aux t
              ( equal
                ( p_cod_prod aux ) c
              )
            )
          )
        )
        ( lixo2
          ( choice lixo )
        )
        ( lixo3
          ( p_nome_prod lixo2 )
        )
      ) lixo3
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote remove_tab_produtos )
        ( quote
          (
            (
              ( cod )
              ( tab_produtos )
            )
            ( tab_produtos )
          )
        )
      )
    )
  )
)
;---------------------

( def remove_tab_produtos lambda
  ( c t )
  ( if
    ( not
      ( existe_tab_produtos c t )
    ) t
    ( let
      (
        ( lixo
          ( set aux
            ( from aux t
              ( equal
                ( p_cod_prod aux ) c
              )
            )
          )
        )
      )
      ( difference t lixo )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote todos_tab_produtos )
        ( quote
          (
            (
              ( tab_produtos )
            )
            ( tab_produtos )
          )
        )
      )
    )
  )
)
;---------------------

( def todos_tab_produtos lambda
  ( t ) t
)
;---------------------
; ---------------------------------------------------------------------------
; *************************** CENTRAL DE COMPRAS ****************************
; ---------------------------------------------------------------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_central_c )
        ( quote
          (
            ( )
            ( central_c )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_central_c lambda
  ( )
  ( central_c
    ( inic_l_pedidos )
    ( inic_l_encomendas )
    ( inic_tab_precos )
  )
)
;---------------------
; * * * * * * * * * * * * LISTA DE PEDIDOS * * * * * * * * *

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_l_pedidos )
        ( quote
          (
            ( )
            ( lista_pedidos )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_l_pedidos lambda
  ( )
  ( makeseq )
)
;---------------------
;FUNC insere_l_pedidos(cobra:cod,p:lista_produtos,d:data,l:lista_pedidos) : lista_pedidos
;RETURN if l == <>
;          then let (
;                    new_l = pedidos(cobra,p,d),
;                    l_final = <new_l>
;                   )
;               in l_final
;          else if existe_pedido(cobra,d,l)
;                  then l
;                  else let (
;                            lp = insere_produto(cobra,
; * * * * * * * * * * * LISTA DE ENCOMENDAS * * * * * * * *

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_l_encomendas )
        ( quote
          (
            ( )
            ( lista_encomendas )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_l_encomendas lambda
  ( )
  ( makeseq )
)
;---------------------
; * * * * * * * * * * * TABELA DE PRECOS * * * * * * * *

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_tab_precos )
        ( quote
          (
            ( )
            ( tab_precos )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_tab_precos lambda
  ( )
  ( makeff )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_tab_precos )
        ( quote
          (
            (
              ( chave )
              ( tab_precos )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_tab_precos lambda
  ( c t )
  ( if
    ( member c
      ( dom t )
    ) true false
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote insere_tab_precos )
        ( quote
          (
            (
              ( chave )
              ( preco )
              ( tab_precos )
            )
            ( tab_precos )
          )
        )
      )
    )
  )
)
;---------------------

( def insere_tab_precos lambda
  ( c p t )
  ( plus t
    ( makeff
      ( c p )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_tab_precos )
        ( quote
          (
            (
              ( cod )
              ( tab_precos )
            )
            ( preco )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_tab_precos lambda
  ( c t )
  ( let
    (
      ( dominio
        ( ff1
          ( list x
            ( ap t x )
          )
          ( from x
            ( dom t )
            ( equal c
              ( p_cod_produto x )
            )
          )
        )
      )
      ( contra
        ( ran dominio )
      )
    )
    ( maximo contra 0 )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote maximo )
        ( quote
          (
            (
              ( SET preco )
              ( preco )
            )
            ( preco )
          )
        )
      )
    )
  )
)
;---------------------

( def maximo lambda
  ( conj valor_maximo )
  ( if
    ( equal conj
      ( makeset )
    ) valor_maximo
    ( let
      (
        ( p
          ( choice conj )
        )
        ( novo_conj
          ( difference conj
            ( makeset p )
          )
        )
      )
      ( if
        ( gt p valor_maximo )
        ( maximo novo_conj p )
        ( maximo novo_conj valor_maximo )
      )
    )
  )
)
;---------------------
; falta dar warning quando mencionar-se um produto que nao esta na tab_precos
; acabamos por optar deixar definir uma ficha sem  ter informacao  do produto
; isto para que  se possa ter  actualizadas as fichas do LNEC, mas aquando da
; feitura  do  orcamento  nao deixa inserir  caso os  produtos  nao   estejam
; definidos!
; * * * * * * * *  LISTA DE PRODUTOS * * * * * * * * * *

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_produto )
        ( quote
          (
            ( )
            ( lista_produtos )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_produto lambda
  ( )
  ( makeseq )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_produto )
        ( quote
          (
            (
              ( cod )
              ( lista_produtos )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_produto lambda
  ( cod p )
  ( if
    ( equal p
      ( makeseq )
    ) false
    ( let
      (
        ( h
          ( head p )
        )
        ( t
          ( tail p )
        )
        ( cod_aux
          ( p_cod_produto h )
        )
      )
      ( if
        ( equal cod cod_aux ) true
        ( existe_produto cod t )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote insere_produto )
        ( quote
          (
            (
              ( cod )
              ( quantidade )
              ( uni )
              ( lista_produtos )
            )
            ( lista_produtos )
          )
        )
      )
    )
  )
)
;---------------------

( def insere_produto lambda
  ( c q u p )
  ( let
    (
      ( pro
        ( produto c q u )
      )
      ( aux
        ( makeseq pro )
      )
    )
    ( append aux p )
  )
)
;---------------------
;FUNC insere_produto(c:cod,q:quantidade,u:uni,p:lista_produtos) : lista_produtos
;RETURN if not(existe_produto(c,p))
;          then let (
;                    pro = produto(c,q,u),
;                    aux = <pro>
;                   )
;               in aux^p
;          else let (
;                    lista_sem = remove(c,p),
;                    pro = produto(c,q,u),
;                    aux = <pro>
;                   )
;               in aux^lista_sem;

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_produto )
        ( quote
          (
            (
              ( cod )
              ( lista_produtos )
            )
            ( produto )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_produto lambda
  ( cod p )
  ( if
    ( not
      ( existe_produto cod p )
    )
    ( pp "Nao encontro esse produto! \n" )
    ( let
      (
        ( h
          ( head p )
        )
        ( t
          ( tail p )
        )
        ( cod_aux
          ( p_cod_produto h )
        )
      )
      ( if
        ( equal cod cod_aux ) h
        ( consulta_produto cod t )
      )
    )
  )
)
;---------------------
; ---------------------------------------------------------------------------
; ****************** CENTRAL DE MAO-DE-OBRA E EQUIPAMENTO *******************
; ---------------------------------------------------------------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_central_m_e )
        ( quote
          (
            ( )
            ( central_m_e )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_central_m_e lambda
  ( )
  ( central_m_e
    ( inic_l_pedidos_me )
    ( inic_rec_humanos )
    ( inic_rec_equip )
  )
)
;---------------------
; * * * * * * * * LISTA DE PEDIDOS DE MAO-DE-OBRA E EQUIP. * * * * * * *

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_l_pedidos_me )
        ( quote
          (
            ( )
            ( lista_pedme )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_l_pedidos_me lambda
  ( )
  ( makeseq )
)
;---------------------
; * * * * * * * *  RECURSOS HUMANOS * * * * * * *

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_rec_humanos )
        ( quote
          (
            ( )
            ( rec_humanos )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_rec_humanos lambda
  ( )
  ( makeset )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_humano )
        ( quote
          (
            (
              ( cod )
              ( rec_humanos )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_humano lambda
  ( c r )
  ( let
    (
      ( lixo
        ( set aux
          ( from aux r
            ( equal
              ( p_cod_pessoal aux ) c
            )
          )
        )
      )
    )
    ( if
      ( equal lixo
        ( makeset )
      ) false true
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote insere_humano )
        ( quote
          (
            (
              ( cod )
              ( nome )
              ( descricao )
              ( cod )
              ( salario )
              ( rec_humanos )
            )
            ( rec_humanos )
          )
        )
      )
    )
  )
)
;---------------------

( def insere_humano lambda
  ( c n d o s r )
  ( let
    (
      ( novo
        ( humano c n d o s )
      )
      ( new
        ( makeset novo )
      )
    )
    ( union r new )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_humano )
        ( quote
          (
            (
              ( cod )
              ( rec_humanos )
            )
            ( humano )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_humano lambda
  ( c r )
  ( if
    ( existe_humano c r )
    ( let
      (
        ( lixo
          ( set aux
            ( from aux r
              ( equal
                ( p_cod_pessoal aux ) c
              )
            )
          )
        )
      ) lixo
    )
    ( pp "Nao existe conhecimento sobre esse individuo! \n" )
  )
)
;---------------------
; altera a obra onde esta o trolha
;FUNC altera_local_humano
; * * * * * * * * * * * * RECURSOS A NIVEL DE EQUIPAMENTO * * * * * * * * *

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_rec_equip )
        ( quote
          (
            ( )
            ( rec_equip )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_rec_equip lambda
  ( )
  ( makeset )
)
;---------------------
; ---------------------------------------------------------------------------
; ****************************** ESTALEIRO **********************************
; ---------------------------------------------------------------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_estaleiro )
        ( quote
          (
            ( )
            ( estaleiro )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_estaleiro lambda
  ( )
  ( makeseq )
)
;---------------------
; ---------------------------------------------------------------------------
; ****************************** CONTABILIDADE ******************************
; ---------------------------------------------------------------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_contabilidade )
        ( quote
          (
            ( )
            ( contabilidade )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_contabilidade lambda
  ( )
  ( contabilidade
    ( inic_cliente )
    ( inic_fornecedores )
    ( inic_facturas )
    ( inic_recibos )
  )
)
;---------------------
; * * * * * * * * *  CLIENTES * * * * * * * * * *  *

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_cliente )
        ( quote
          (
            ( )
            ( clientes )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_cliente lambda
  ( )
  ( makeff )
)
;---------------------
;RETURN if dom(C) != {} /\ c in dom(C)
;RETURN c in dom(C)  esta e a forma benefica

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_cliente )
        ( quote
          (
            (
              ( cod )
              ( clientes )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_cliente lambda
  ( c C )
  ( if
    ( member c
      ( dom C )
    ) true false
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote insere_cliente )
        ( quote
          (
            (
              ( cod )
              ( nome )
              ( morada )
              ( n_contri )
              ( clientes )
            )
            ( clientes )
          )
        )
      )
    )
  )
)
;---------------------

( def insere_cliente lambda
  ( a n m i C )
  ( plus C
    ( makeff
      ( a
        ( inf_cliente n m i )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_cliente )
        ( quote
          (
            (
              ( cod )
              ( clientes )
            )
            ( inf_cliente )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_cliente lambda
  ( c C )
  ( if
    ( existe_cliente c C )
    ( ap C c )
    ( pp "Esse cliente nao existe! \n" )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote remove_cliente )
        ( quote
          (
            (
              ( cod )
              ( clientes )
            )
            ( clientes )
          )
        )
      )
    )
  )
)
;---------------------

( def remove_cliente lambda
  ( c C )
  ( ds C
    ( makeset c )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote todos_clientes )
        ( quote
          (
            (
              ( sistema )
            )
            ( SET cod )
          )
        )
      )
    )
  )
)
;---------------------

( def todos_clientes lambda
  ( s )
  ( let
    (
      ( emp
        ( p_empreitadas s )
      )
      ( o
        ( p_orcamentos emp )
      )
      ( dominio
        ( dom o )
      )
    )
    ( todos_clientes_aux1 dominio o )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote todos_clientes_aux1 )
        ( quote
          (
            (
              ( SET cod )
              ( orcamentos )
            )
            ( SET cod )
          )
        )
      )
    )
  )
)
;---------------------

( def todos_clientes_aux1 lambda
  ( d o )
  ( if
    ( equal d
      ( makeset )
    )
    ( makeset )
    ( let
      (
        ( c
          ( choice d )
        )
        ( new_d
          ( difference d
            ( makeset c )
          )
        )
        ( cli
          ( p_cod_cliente
            ( ap o c )
          )
        )
      )
      ( union
        ( makeset cli )
        ( todos_clientes_aux1 new_d o )
      )
    )
  )
)
;---------------------
; * * * * * * * * * * * * FORNECEDORES * * * * * * * * * *  *

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_fornecedores )
        ( quote
          (
            ( )
            ( fornecedores )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_fornecedores lambda
  ( )
  ( makeff )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote existe_fornecedor )
        ( quote
          (
            (
              ( cod )
              ( fornecedores )
            )
            ( SYM )
          )
        )
      )
    )
  )
)
;---------------------

( def existe_fornecedor lambda
  ( c C )
  ( if
    ( member c
      ( dom C )
    ) true false
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote insere_fornecedor )
        ( quote
          (
            (
              ( cod )
              ( nome )
              ( morada )
              ( n_contri )
              ( fornecedores )
            )
            ( fornecedores )
          )
        )
      )
    )
  )
)
;---------------------

( def insere_fornecedor lambda
  ( a n m i C )
  ( plus C
    ( makeff
      ( a
        ( inf_forn n m i )
      )
    )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote consulta_fornecedor )
        ( quote
          (
            (
              ( cod )
              ( fornecedores )
            )
            ( inf_forn )
          )
        )
      )
    )
  )
)
;---------------------

( def consulta_fornecedor lambda
  ( c C )
  ( if
    ( existe_fornecedor c C )
    ( ap C c )
    ( pp "Esse fornecedor nao existe! \n" )
  )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote remove_fornecedor )
        ( quote
          (
            (
              ( cod )
              ( fornecedores )
            )
            ( fornecedores )
          )
        )
      )
    )
  )
)
;---------------------

( def remove_fornecedor lambda
  ( c C )
  ( ds C
    ( makeset c )
  )
)
;---------------------
; * * * * * * * * * * * * * FACTURAS * * * * * * * * * * *

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_facturas )
        ( quote
          (
            ( )
            ( facturas )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_facturas lambda
  ( )
  ( facturas
    ( inic_n_factura )
    ( inic_v_factura )
  )
)
;---------------------
; * * * * * * * * * * * * * * NOSSAS FACTURAS * * * * * * * *

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_n_factura )
        ( quote
          (
            ( )
            ( n_factura )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_n_factura lambda
  ( )
  ( makeff )
)
;---------------------
; * * * * * * * * * * * * * * VOSSAS FACTURAS * * * * * * * *

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_v_factura )
        ( quote
          (
            ( )
            ( v_factura )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_v_factura lambda
  ( )
  ( makeff )
)
;---------------------
; * * * * * * * * * * * * RECIBOS * * * * * * * * * * *

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_recibos )
        ( quote
          (
            ( )
            ( recibos )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_recibos lambda
  ( )
  ( recibos
    ( inic_n_recibo )
    ( inic_v_recibo )
  )
)
;---------------------
; * * * * * * * * * * * * * * NOSSOS RECIBOS * * * * * * * *

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_n_recibo )
        ( quote
          (
            ( )
            ( n_recibo )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_n_recibo lambda
  ( )
  ( makeff )
)
;---------------------
; * * * * * * * * * * * * * * VOSSOS RECIBOS * * * * * * * *

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote inic_v_recibo )
        ( quote
          (
            ( )
            ( v_recibo )
          )
        )
      )
    )
  )
)
;---------------------

( def inic_v_recibo lambda
  ( )
  ( makeff )
)
;---------------------

( def _ops
  ( plus _ops
    ( makeff
      (
        ( quote fuck )
        ( quote
          (
            ( )
            ( sistema )
          )
        )
      )
    )
  )
)
;---------------------

( def fuck lambda
  ( ) SISTEMA
)
;---------------------
;nload("fx.cam");
;nload("ila.cam");
; Este ficheiro serve para carregar exemplos

( inic_sistema )
;---------------------

( fuck )
;---------------------

( insere_cliente_sis 1 "ricardo" "sts" 10 )
;---------------------

( insere_cliente_sis 2 "luis pedro" "braga" 20 )
;---------------------

( insere_fornecedor_sis 1 "bloqueira" "matos" 111 )
;---------------------

( insere_fornecedor_sis 2 "cimpor" "porto" 222 )
;---------------------

( insere_fornecedor_sis 3 "pica_ferro" "begaga" 333 )
;---------------------

( insere_tab_produtos_sis 1 "cimento" )
;---------------------

( insere_tab_produtos_sis 2 "entukho" )
;---------------------

( insere_tab_produtos_sis 3 "agua" )
;---------------------

( insere_tab_produtos_sis 4 "tijolo" )
;---------------------

( regista_ficha_sis 1
  ( info_ficha "bosta"
    ( makeset
      ( tabela 1 10 )
      ( tabela 2 20 )
      ( tabela 3 30 )
    )
  )
)
;---------------------

( regista_ficha_sis 2
  ( info_ficha "juntas"
    ( makeset
      ( tabela 3 30 )
      ( tabela 4 40 )
    )
  )
)
;---------------------

( regista_ficha_sis 3
  ( info_ficha "juntas"
    ( makeset
      ( tabela 5 30 )
      ( tabela 6 40 )
    )
  )
)
;---------------------

( insere_tab_precos_sis
  ( chave 1 1 111 ) 100
)
;---------------------

( insere_tab_precos_sis
  ( chave 2 1 111 ) 200
)
;---------------------

( insere_tab_precos_sis
  ( chave 3 1 111 ) 300
)
;---------------------

( insere_tab_precos_sis
  ( chave 4 1 111 ) 400
)
;---------------------

( insere_tab_precos_sis
  ( chave 1 2 111 ) 100
)
;---------------------

( insere_tab_precos_sis
  ( chave 2 2 111 ) 202
)
;---------------------

( insere_tab_precos_sis
  ( chave 3 2 111 ) 300
)
;---------------------

( insere_tab_precos_sis
  ( chave 4 2 111 ) 402
)
;---------------------

( regista_orcamento_sis 1 1 10 20
  ( makeseq )
)
;---------------------

( regista_orcamento_sis 1 1 10 20
  ( makeseq )
)
;---------------------

( regista_orcamento_sis 1 1 10 20
  ( makeseq
    ( capitulo "lev terras"
      ( makeseq
        ( artigo 3 10
          ( makeseq ) 10
        )
        ( artigo 2 20
          ( makeseq ) 0
        )
      ) 20
    )
  )
)
;---------------------

( regista_orcamento_sis 2 1 10 20
  ( makeseq )
)
;---------------------

( regista_orcamento_sis 2 1 10 20
  ( makeseq
    ( capitulo "terras"
      ( makeseq
        ( artigo 2 30
          ( makeseq 30 40 ) 20
        )
      ) 0
    )
  )
)
;---------------------